/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2021-2022, Ideas On Board * * dpcc.cpp - RkISP1 Defect Pixel Cluster Correction control */ #include "dpcc.h" #include #include "libcamera/internal/yaml_parser.h" #include "linux/rkisp1-config.h" /** * \file dpcc.h */ namespace libcamera { namespace ipa::rkisp1::algorithms { /** * \class DefectPixelClusterCorrection * \brief RkISP1 Defect Pixel Cluster Correction control * * Depending of the sensor quality, some pixels can be defective and then * appear significantly brighter or darker than the other pixels. * * The Defect Pixel Cluster Correction algorithms is responsible to minimize * the impact of the pixels. This can be done with algorithms applied at run * time (on-the-fly method) or with a table of defective pixels. Only the first * method is supported for the moment. */ LOG_DEFINE_CATEGORY(RkISP1Dpcc) DefectPixelClusterCorrection::DefectPixelClusterCorrection() : config_({}) { } /** * \copydoc libcamera::ipa::Algorithm::init */ int DefectPixelClusterCorrection::init([[maybe_unused]] IPAContext &context, const YamlObject &tuningData) { config_.mode = RKISP1_CIF_ISP_DPCC_MODE_STAGE1_ENABLE; config_.output_mode = RKISP1_CIF_ISP_DPCC_OUTPUT_MODE_STAGE1_INCL_G_CENTER | RKISP1_CIF_ISP_DPCC_OUTPUT_MODE_STAGE1_INCL_RB_CENTER; config_.set_use = tuningData["fixed-set"].get(false) ? RKISP1_CIF_ISP_DPCC_SET_USE_STAGE1_USE_FIX_SET : 0; /* Get all defined sets to apply (up to 3). */ const YamlObject &setsObject = tuningData["sets"]; if (!setsObject.isList()) { LOG(RkISP1Dpcc, Error) << "'sets' parameter not found in tuning file"; return -EINVAL; } if (setsObject.size() > RKISP1_CIF_ISP_DPCC_METHODS_MAX) { LOG(RkISP1Dpcc, Error) << "'sets' size in tuning file (" << setsObject.size() << ") exceeds the maximum hardware capacity (3)"; return -EINVAL; } for (std::size_t i = 0; i < setsObject.size(); ++i) { struct rkisp1_cif_isp_dpcc_methods_config &method = config_.methods[i]; const YamlObject &set = setsObject[i]; uint16_t value; /* Enable set if described in YAML tuning file. */ config_.set_use |= 1 << i; /* PG Method */ const YamlObject &pgObject = set["pg-factor"]; if (pgObject.contains("green")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_PG_GREEN_ENABLE; value = pgObject["green"].get(0); method.pg_fac |= RKISP1_CIF_ISP_DPCC_PG_FAC_G(value); } if (pgObject.contains("red-blue")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_PG_RED_BLUE_ENABLE; value = pgObject["red-blue"].get(0); method.pg_fac |= RKISP1_CIF_ISP_DPCC_PG_FAC_RB(value); } /* RO Method */ const YamlObject &roObject = set["ro-limits"]; if (roObject.contains("green")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RO_GREEN_ENABLE; value = roObject["green"].get(0); config_.ro_limits |= RKISP1_CIF_ISP_DPCC_RO_LIMITS_n_G(i, value); } if (roObject.contains("red-blue")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RO_RED_BLUE_ENABLE; value = roObject["red-blue"].get(0); config_.ro_limits |= RKISP1_CIF_ISP_DPCC_RO_LIMITS_n_RB(i, value); } /* RG Method */ const YamlObject &rgObject = set["rg-factor"]; method.rg_fac = 0; if (rgObject.contains("green")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RG_GREEN_ENABLE; value = rgObject["green"].get(0); method.rg_fac |= RKISP1_CIF_ISP_DPCC_RG_FAC_G(value); } if (rgObject.contains("red-blue")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RG_RED_BLUE_ENABLE; value = rgObject["red-blue"].get(0); method.rg_fac |= RKISP1_CIF_ISP_DPCC_RG_FAC_RB(value); } /* RND Method */ const YamlObject &rndOffsetsObject = set["rnd-offsets"]; if (rndOffsetsObject.contains("green")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RND_GREEN_ENABLE; value = rndOffsetsObject["green"].get(0); config_.rnd_offs |= RKISP1_CIF_ISP_DPCC_RND_OFFS_n_G(i, value); } if (rndOffsetsObject.contains("red-blue")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RND_RED_BLUE_ENABLE; value = rndOffsetsObject["red-blue"].get(0); config_.rnd_offs |= RKISP1_CIF_ISP_DPCC_RND_OFFS_n_RB(i, value); } const YamlObject &rndThresholdObject = set["rnd-threshold"]; method.rnd_thresh = 0; if (rndThresholdObject.contains("green")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RND_GREEN_ENABLE; value = rndThresholdObject["green"].get(0); method.rnd_thresh |= RKISP1_CIF_ISP_DPCC_RND_THRESH_G(value); } if (rndThresholdObject.contains("red-blue")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_RND_RED_BLUE_ENABLE; value = rndThresholdObject["red-blue"].get(0); method.rnd_thresh |= RKISP1_CIF_ISP_DPCC_RND_THRESH_RB(value); } /* LC Method */ const YamlObject &lcThresholdObject = set["line-threshold"]; method.line_thresh = 0; if (lcThresholdObject.contains("green")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_LC_GREEN_ENABLE; value = lcThresholdObject["green"].get(0); method.line_thresh |= RKISP1_CIF_ISP_DPCC_LINE_THRESH_G(value); } if (lcThresholdObject.contains("red-blue")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_LC_RED_BLUE_ENABLE; value = lcThresholdObject["red-blue"].get(0); method.line_thresh |= RKISP1_CIF_ISP_DPCC_LINE_THRESH_RB(value); } const YamlObject &lcTMadFactorObject = set["line-mad-factor"]; method.line_mad_fac = 0; if (lcTMadFactorObject.contains("green")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_LC_GREEN_ENABLE; value = lcTMadFactorObject["green"].get(0); method.line_mad_fac |= RKISP1_CIF_ISP_DPCC_LINE_MAD_FAC_G(value); } if (lcTMadFactorObject.contains("red-blue")) { method.method |= RKISP1_CIF_ISP_DPCC_METHODS_SET_LC_RED_BLUE_ENABLE; value = lcTMadFactorObject["red-blue"].get(0); method.line_mad_fac |= RKISP1_CIF_ISP_DPCC_LINE_MAD_FAC_RB(value); } } return 0; } /** * \copydoc libcamera::ipa::Algorithm::prepare */ void DefectPixelClusterCorrection::prepare([[maybe_unused]] IPAContext &context, const uint32_t frame, [[maybe_unused]] IPAFrameContext &frameContext, rkisp1_params_cfg *params) { if (frame > 0) return; params->others.dpcc_config = config_; params->module_en_update |= RKISP1_CIF_ISP_MODULE_DPCC; params->module_ens |= RKISP1_CIF_ISP_MODULE_DPCC; params->module_cfg_update |= RKISP1_CIF_ISP_MODULE_DPCC; } REGISTER_IPA_ALGORITHM(DefectPixelClusterCorrection, "DefectPixelClusterCorrection") } /* namespace ipa::rkisp1::algorithms */ } /* namespace libcamera */ a id='n110' href='#n110'>110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2020, Google Inc.
 *
 * post_processor_jpeg.cpp - JPEG Post Processor
 */

#include "post_processor_jpeg.h"

#include <chrono>

#include "../camera_device.h"
#include "../camera_metadata.h"
#include "../camera_request.h"
#if defined(OS_CHROMEOS)
#include "encoder_jea.h"
#else /* !defined(OS_CHROMEOS) */
#include "encoder_libjpeg.h"
#endif
#include "exif.h"

#include <libcamera/base/log.h>

#include <libcamera/formats.h>

using namespace libcamera;
using namespace std::chrono_literals;

LOG_DEFINE_CATEGORY(JPEG)

PostProcessorJpeg::PostProcessorJpeg(CameraDevice *const device)
	: cameraDevice_(device)
{
}

int PostProcessorJpeg::configure(const StreamConfiguration &inCfg,
				 const StreamConfiguration &outCfg)
{
	if (inCfg.size != outCfg.size) {
		LOG(JPEG, Error) << "Mismatch of input and output stream sizes";
		return -EINVAL;
	}

	if (outCfg.pixelFormat != formats::MJPEG) {
		LOG(JPEG, Error) << "Output stream pixel format is not JPEG";
		return -EINVAL;
	}

	streamSize_ = outCfg.size;

	thumbnailer_.configure(inCfg.size, inCfg.pixelFormat);

#if defined(OS_CHROMEOS)
	encoder_ = std::make_unique<EncoderJea>();
#else /* !defined(OS_CHROMEOS) */
	encoder_ = std::make_unique<EncoderLibJpeg>();
#endif

	return encoder_->configure(inCfg);
}

void PostProcessorJpeg::generateThumbnail(const FrameBuffer &source,
					  const Size &targetSize,
					  unsigned int quality,
					  std::vector<unsigned char> *thumbnail)
{
	/* Stores the raw scaled-down thumbnail bytes. */
	std::vector<unsigned char> rawThumbnail;

	thumbnailer_.createThumbnail(source, targetSize, &rawThumbnail);

	StreamConfiguration thCfg;
	thCfg.size = targetSize;
	thCfg.pixelFormat = thumbnailer_.pixelFormat();
	int ret = thumbnailEncoder_.configure(thCfg);

	if (!rawThumbnail.empty() && !ret) {
		/*
		 * \todo Avoid value-initialization of all elements of the
		 * vector.
		 */
		thumbnail->resize(rawThumbnail.size());

		/*
		 * Split planes manually as the encoder expects a vector of
		 * planes.
		 *
		 * \todo Pass a vector of planes directly to
		 * Thumbnailer::createThumbnailer above and remove the manual
		 * planes split from here.
		 */
		std::vector<Span<uint8_t>> thumbnailPlanes;
		const PixelFormatInfo &formatNV12 = PixelFormatInfo::info(formats::NV12);
		size_t yPlaneSize = formatNV12.planeSize(targetSize, 0);
		size_t uvPlaneSize = formatNV12.planeSize(targetSize, 1);
		thumbnailPlanes.push_back({ rawThumbnail.data(), yPlaneSize });
		thumbnailPlanes.push_back({ rawThumbnail.data() + yPlaneSize, uvPlaneSize });

		int jpeg_size = thumbnailEncoder_.encode(thumbnailPlanes,
							 *thumbnail, {}, quality);
		thumbnail->resize(jpeg_size);

		LOG(JPEG, Debug)
			<< "Thumbnail compress returned "
			<< jpeg_size << " bytes";
	}
}

void PostProcessorJpeg::process(Camera3RequestDescriptor::StreamBuffer *streamBuffer)
{
	ASSERT(encoder_);

	const FrameBuffer &source = *streamBuffer->srcBuffer;
	CameraBuffer *destination = streamBuffer->dstBuffer.get();

	ASSERT(destination->numPlanes() == 1);

	const CameraMetadata &requestMetadata = streamBuffer->request->settings_;
	CameraMetadata *resultMetadata = streamBuffer->request->resultMetadata_.get();
	camera_metadata_ro_entry_t entry;
	int ret;

	/* Set EXIF metadata for various tags. */
	Exif exif;
	exif.setMake(cameraDevice_->maker());
	exif.setModel(cameraDevice_->model());

	ret = requestMetadata.getEntry(ANDROID_JPEG_ORIENTATION, &entry);

	const uint32_t jpegOrientation = ret ? *entry.data.i32 : 0;
	resultMetadata->addEntry(ANDROID_JPEG_ORIENTATION, jpegOrientation);
	exif.setOrientation(jpegOrientation);

	exif.setSize(streamSize_);
	/*
	 * We set the frame's EXIF timestamp as the time of encode.
	 * Since the precision we need for EXIF timestamp is only one
	 * second, it is good enough.
	 */
	exif.setTimestamp(std::time(nullptr), 0ms);

	ret = resultMetadata->getEntry(ANDROID_SENSOR_EXPOSURE_TIME, &entry);
	exif.setExposureTime(ret ? *entry.data.i64 : 0);
	ret = requestMetadata.getEntry(ANDROID_LENS_APERTURE, &entry);
	if (ret)
		exif.setAperture(*entry.data.f);

	ret = resultMetadata->getEntry(ANDROID_SENSOR_SENSITIVITY, &entry);
	exif.setISO(ret ? *entry.data.i32 : 100);

	exif.setFlash(Exif::Flash::FlashNotPresent);
	exif.setWhiteBalance(Exif::WhiteBalance::Auto);

	exif.setFocalLength(1.0);

	ret = requestMetadata.getEntry(ANDROID_JPEG_GPS_TIMESTAMP, &entry);
	if (ret) {
		exif.setGPSDateTimestamp(*entry.data.i64);
		resultMetadata->addEntry(ANDROID_JPEG_GPS_TIMESTAMP,
					 *entry.data.i64);
	}

	ret = requestMetadata.getEntry(ANDROID_JPEG_THUMBNAIL_SIZE, &entry);
	if (ret) {
		const int32_t *data = entry.data.i32;
		Size thumbnailSize = { static_cast<uint32_t>(data[0]),
				       static_cast<uint32_t>(data[1]) };

		ret = requestMetadata.getEntry(ANDROID_JPEG_THUMBNAIL_QUALITY, &entry);
		uint8_t quality = ret ? *entry.data.u8 : 95;
		resultMetadata->addEntry(ANDROID_JPEG_THUMBNAIL_QUALITY, quality);

		if (thumbnailSize != Size(0, 0)) {
			std::vector<unsigned char> thumbnail;
			generateThumbnail(source, thumbnailSize, quality, &thumbnail);
			if (!thumbnail.empty())
				exif.setThumbnail(std::move(thumbnail), Exif::Compression::JPEG);
		}

		resultMetadata->addEntry(ANDROID_JPEG_THUMBNAIL_SIZE, data, 2);
	}

	ret = requestMetadata.getEntry(ANDROID_JPEG_GPS_COORDINATES, &entry);
	if (ret) {
		exif.setGPSLocation(entry.data.d);
		resultMetadata->addEntry(ANDROID_JPEG_GPS_COORDINATES,
					 entry.data.d, 3);
	}

	ret = requestMetadata.getEntry(ANDROID_JPEG_GPS_PROCESSING_METHOD, &entry);
	if (ret) {
		std::string method(entry.data.u8, entry.data.u8 + entry.count);
		exif.setGPSMethod(method);
		resultMetadata->addEntry(ANDROID_JPEG_GPS_PROCESSING_METHOD,
					 entry.data.u8, entry.count);
	}

	if (exif.generate() != 0)
		LOG(JPEG, Error) << "Failed to generate valid EXIF data";

	ret = requestMetadata.getEntry(ANDROID_JPEG_QUALITY, &entry);
	const uint8_t quality = ret ? *entry.data.u8 : 95;
	resultMetadata->addEntry(ANDROID_JPEG_QUALITY, quality);

	int jpeg_size = encoder_->encode(streamBuffer, exif.data(), quality);
	if (jpeg_size < 0) {
		LOG(JPEG, Error) << "Failed to encode stream image";
		processComplete.emit(streamBuffer, PostProcessor::Status::Error);
		return;
	}

	/* Fill in the JPEG blob header. */
	uint8_t *resultPtr = destination->plane(0).data()
			   + destination->jpegBufferSize(cameraDevice_->maxJpegBufferSize())
			   - sizeof(struct camera3_jpeg_blob);
	auto *blob = reinterpret_cast<struct camera3_jpeg_blob *>(resultPtr);
	blob->jpeg_blob_id = CAMERA3_JPEG_BLOB_ID;
	blob->jpeg_size = jpeg_size;

	/* Update the JPEG result Metadata. */
	resultMetadata->addEntry(ANDROID_JPEG_SIZE, jpeg_size);
	processComplete.emit(streamBuffer, PostProcessor::Status::Success);
}