index : libcamera/pinchartl/libcamera.git	master mtk/camsv mtk/multi-cam rpi/streams/next simple/imx8
	Laurent Pinchart's clone of libcamera	git repository hosting on libcamera.org

summaryrefslogtreecommitdiff

log msg author committer range

Age	Commit message (Expand)	Author
2021-12-14	utils: tracepoints: gen-tp-header: Add execute permission	Brian Olson
2021-12-14	libcamera: Restrict .gitignore build/ and patches/ to the root directory	Laurent Pinchart
2021-12-13	test: fence: Signal fence once	Jacopo Mondi
2021-12-13	test: fence: Check write return value	Jacopo Mondi
2021-12-13	libcamera: pipeline: raspberrypi: Support color spaces	David Plowman
2021-12-13	libcamera: camera: Add validateColorSpaces to CameraConfiguration class	David Plowman
2021-12-13	libcamera: v4l2_subdevice: Support passing ColorSpaces to V4L2 subdevices	David Plowman
2021-12-13	libcamera: v4l2_subdevice: Add colorSpace field to V4L2SubdeviceFormat	David Plowman
2021-12-13	libcamera: video_device: Support passing ColorSpaces to V4L2 video devices	David Plowman
2021-12-13	libcamera: video_device: Convert between ColorSpace class and V4L2 formats	David Plowman
2021-12-13	libcamera: stream: Add ColorSpace fields to StreamConfiguration	David Plowman
2021-12-13	libcamera: Add ColorSpace class	David Plowman
2021-12-11	android: Remove CameraWorker	Jacopo Mondi
2021-12-11	test: fence: Add test for the Fence class	Jacopo Mondi
2021-12-11	libcamera: pipeline_handler: Prepare Request	Jacopo Mondi
2021-12-11	libcamera: request: Add Request::Private::prepare()	Jacopo Mondi
2021-12-11	libcamera: pipeline: Introduce stopDevice()	Jacopo Mondi
2021-12-11	libcamera: pipeline_handler: Split request queueing	Jacopo Mondi
2021-12-11	libcamera: request: Add Fence to Request::addBuffer()	Jacopo Mondi
2021-12-11	libcamera: framebuffer: Add Fence to FrameBuffer	Jacopo Mondi
2021-12-11	libcamera: fence: Introduce Fence	Jacopo Mondi
2021-12-11	libcamera: request: Make Request class Extensible	Laurent Pinchart
2021-12-11	libcamera: Print Timer identifier	Jacopo Mondi
2021-12-08	pipeline: raspberrypi: Restrict the advertised maximum ISP output resolution	Naushir Patuck
2021-12-08	pipeline: raspberrypi: Reduce logging verbosity	Naushir Patuck
2021-12-07	libcamera: media_device: Skip all non-data links during enumeration	Laurent Pinchart
2021-12-07	libcamera: Use utils::abs_diff()	Laurent Pinchart
2021-12-07	libcamera: base: utils: Add abs_diff() utility function	Laurent Pinchart
2021-12-07	libcamera: base: shared_fd: Don't dup() an invalid fd	Laurent Pinchart
2021-12-07	android: Apply 1% tolerance to minFrameDuration capping	Umang Jain
2021-12-07	pipeline: raspberrypi: Return the sensor formats from generateConfiguration()	Naushir Patuck
2021-12-06	libcamera: pipeline: ipu3: Apply a requested test pattern mode	Hirokazu Honda
2021-12-06	libcamera: camera_sensor: Enable to set a test pattern mode	Hirokazu Honda
2021-12-06	libcamera: camera_sensor: Reference test pattern modes by enum type	Hirokazu Honda
2021-12-06	android: camera_stream: Use PlatformFrameBufferAllocator	Hirokazu Honda
2021-12-06	android: Introduce PlatformFrameBufferAllocator	Hirokazu Honda
2021-12-06	libcamera: framebuffer: Enable attaching additional data to FrameBuffer	Hirokazu Honda
2021-12-06	libcamera: ipu3: Only process focus if we have a lens	Kieran Bingham
2021-12-04	libcamera: base: shared_fd: Add comparison operators	Laurent Pinchart
2021-12-04	libcamera: base: shared_fd: Rename fd() to get()	Laurent Pinchart
2021-12-04	libcamera: base: Rename FileDescriptor to SharedFD	Laurent Pinchart
2021-12-04	v4l2: v4l2_camera: Return int in getBufferFd()	Hirokazu Honda
2021-12-04	libcamera: pipeline: raspberrypi: DmaHeaps: Use UniqueFD for a file descriptor	Hirokazu Honda
2021-12-04	libcamera: v4l2_videodevice: Pass FileDescriptor to open()	Laurent Pinchart
2021-12-04	libcamera: v4l2_videodevice: Use fd for a file descriptor	Hirokazu Honda
2021-12-04	libcamera: v4l2_device: Use UniqueFD for a file descriptor	Hirokazu Honda
2021-12-04	libcamera: media_device: Manage fd by UniqueFD	Hirokazu Honda
2021-12-04	libcamera: process: Manage pipe fds by UniqueFD	Hirokazu Honda
2021-12-04	libcamera: ipc_unixsocket: Fix file descriptor leak	Laurent Pinchart
2021-12-04	libcamera: ipc_unixsocket: Use UniqueFD for a file descriptor	Hirokazu Honda

• [next]

generated by cgit v1.2.1 (git 2.18.0) at 2024-12-24 10:57:26 +0000

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * camera_sensor.cpp - A camera sensor
 */

#include "libcamera/internal/camera_sensor.h"
#include "libcamera/internal/media_device.h"

#include <algorithm>
#include <float.h>
#include <iomanip>
#include <limits.h>
#include <math.h>
#include <regex>
#include <string.h>

#include <libcamera/property_ids.h>

#include <libcamera/base/utils.h>

#include "libcamera/internal/bayer_format.h"
#include "libcamera/internal/camera_sensor_properties.h"
#include "libcamera/internal/formats.h"
#include "libcamera/internal/sysfs.h"

/**
 * \file camera_sensor.h
 * \brief A camera sensor
 */

namespace libcamera {

LOG_DEFINE_CATEGORY(CameraSensor)

/**
 * \class CameraSensor
 * \brief A camera sensor based on V4L2 subdevices
 *
 * The CameraSensor class eases handling of sensors for pipeline handlers by
 * hiding the details of the V4L2 subdevice kernel API and caching sensor
 * information.
 *
 * The implementation is currently limited to sensors that expose a single V4L2
 * subdevice with a single pad. It will be extended to support more complex
 * devices as the needs arise.
 */

/**
 * \brief Construct a CameraSensor
 * \param[in] entity The media entity backing the camera sensor
 *
 * Once constructed the instance must be initialized with init().
 */
CameraSensor::CameraSensor(const MediaEntity *entity)
	: entity_(entity), pad_(UINT_MAX), bayerFormat_(nullptr),
	  properties_(properties::properties)
{
}

/**
 * \brief Destroy a CameraSensor
 */
CameraSensor::~CameraSensor()
{
}

/**
 * \brief Initialize the camera sensor instance
 *
 * This function performs the initialisation steps of the CameraSensor that may
 * fail. It shall be called once and only once after constructing the instance.
 *
 * \return 0 on success or a negative error code otherwise
 */
int CameraSensor::init()
{
	for (const MediaPad *pad : entity_->pads()) {
		if (pad->flags() & MEDIA_PAD_FL_SOURCE) {
			pad_ = pad->index();
			break;
		}
	}

	if (pad_ == UINT_MAX) {
		LOG(CameraSensor, Error)
			<< "Sensors with more than one pad are not supported";
		return -EINVAL;
	}

	switch (entity_->function()) {
	case MEDIA_ENT_F_CAM_SENSOR:
	case MEDIA_ENT_F_PROC_VIDEO_ISP:
		break;

	default:
		LOG(CameraSensor, Error)
			<< "Invalid sensor function "
			<< utils::hex(entity_->function());
		return -EINVAL;
	}

	/* Create and open the subdev. */
	subdev_ = std::make_unique<V4L2Subdevice>(entity_);
	int ret = subdev_->open();
	if (ret < 0)
		return ret;

	/* Enumerate, sort and cache media bus codes and sizes. */
	formats_ = subdev_->formats(pad_);
	if (formats_.empty()) {
		LOG(CameraSensor, Error) << "No image format found";
		return -EINVAL;
	}

	mbusCodes_ = utils::map_keys(formats_);
	std::sort(mbusCodes_.begin(), mbusCodes_.end());

	for (const auto &format : formats_) {
		const std::vector<SizeRange> &ranges = format.second;
		std::transform(ranges.begin(), ranges.end(), std::back_inserter(sizes_),
			       [](const SizeRange &range) { return range.max; });
	}

	std::sort(sizes_.begin(), sizes_.end());

	/* Remove duplicates. */
	auto last = std::unique(sizes_.begin(), sizes_.end());
	sizes_.erase(last, sizes_.end());

	/*
	 * VIMC is a bit special, as it does not yet support all the mandatory
	 * requirements regular sensors have to respect.
	 *
	 * Do not validate the driver if it's VIMC and initialize the sensor
	 * properties with static information.
	 *
	 * \todo Remove the special case once the VIMC driver has been
	 * updated in all test platforms.
	 */
	if (entity_->device()->driver() == "vimc") {
		initVimcDefaultProperties();
		return initProperties();
	}

	/* Get the color filter array pattern (only for RAW sensors). */
	for (unsigned int mbusCode : mbusCodes_) {
		const BayerFormat &bayerFormat = BayerFormat::fromMbusCode(mbusCode);
		if (bayerFormat.isValid()) {
			bayerFormat_ = &bayerFormat;
			break;
		}
	}

	ret = validateSensorDriver();
	if (ret)
		return ret;

	ret = initProperties();
	if (ret)
		return ret;

	return 0;
}

int CameraSensor::validateSensorDriver()
{
	int err = 0;

	/*
	 * Optional controls are used to register optional sensor properties. If
	 * not present, some values will be defaulted.
	 */
	static constexpr uint32_t optionalControls[] = {
		V4L2_CID_CAMERA_SENSOR_ROTATION,
	};

	const ControlIdMap &controls = subdev_->controls().idmap();
	for (uint32_t ctrl : optionalControls) {
		if (!controls.count(ctrl))
			LOG(CameraSensor, Debug)
				<< "Optional V4L2 control " << utils::hex(ctrl)
				<< " not supported";
	}

	/*
	 * Recommended controls are similar to optional controls, but will
	 * become mandatory in the near future. Be loud if they're missing.
	 */
	static constexpr uint32_t recommendedControls[] = {
		V4L2_CID_CAMERA_ORIENTATION,
	};

	for (uint32_t ctrl : recommendedControls) {
		if (!controls.count(ctrl)) {
			LOG(CameraSensor, Warning)
				<< "Recommended V4L2 control " << utils::hex(ctrl)
				<< " not supported";
			err = -EINVAL;
		}
	}

	/*
	 * Make sure the required selection targets are supported.
	 *
	 * Failures in reading any of the targets are not deemed to be fatal,
	 * but some properties and features, like constructing a
	 * IPACameraSensorInfo for the IPA module, won't be supported.
	 *
	 * \todo Make support for selection targets mandatory as soon as all
	 * test platforms have been updated.
	 */
	Rectangle rect;
	int ret = subdev_->getSelection(pad_, V4L2_SEL_TGT_CROP_BOUNDS, &rect);
	if (ret) {
		/*
		 * Default the pixel array size to the largest size supported
		 * by the sensor. The sizes_ vector is sorted in ascending
		 * order, the largest size is thus the last element.
		 */
		pixelArraySize_ = sizes_.back();

		LOG(CameraSensor, Warning)
			<< "The PixelArraySize property has been defaulted to "
			<< pixelArraySize_.toString();
		err = -EINVAL;
	} else {
		pixelArraySize_ = rect.size();
	}

	ret = subdev_->getSelection(pad_, V4L2_SEL_TGT_CROP_DEFAULT, &activeArea_);
	if (ret) {
		activeArea_ = Rectangle(pixelArraySize_);
		LOG(CameraSensor, Warning)
			<< "The PixelArrayActiveAreas property has been defaulted to "
			<< activeArea_.toString();
		err = -EINVAL;
	}

	ret = subdev_->getSelection(pad_, V4L2_SEL_TGT_CROP, &rect);
	if (ret) {
		LOG(CameraSensor, Warning)
			<< "Failed to retrieve the sensor crop rectangle";
		err = -EINVAL;
	}

	if (err) {
		LOG(CameraSensor, Warning)
			<< "The sensor kernel driver needs to be fixed";
		LOG(CameraSensor, Warning)
			<< "See Documentation/sensor_driver_requirements.rst in the libcamera sources for more information";
	}

	if (!bayerFormat_)
		return 0;

	/*
	 * For raw sensors, make sure the sensor driver supports the controls
	 * required by the CameraSensor class.
	 */
	static constexpr uint32_t mandatoryControls[] = {
		V4L2_CID_EXPOSURE,
		V4L2_CID_HBLANK,
		V4L2_CID_PIXEL_RATE,
		V4L2_CID_VBLANK,
	};

	err = 0;
	for (uint32_t ctrl : mandatoryControls) {
		if (!controls.count(ctrl)) {
			LOG(CameraSensor, Error)
				<< "Mandatory V4L2 control " << utils::hex(ctrl)
				<< " not available";
			err = -EINVAL;
		}
	}

	if (err) {
		LOG(CameraSensor, Error)
			<< "The sensor kernel driver needs to be fixed";
		LOG(CameraSensor, Error)
			<< "See Documentation/sensor_driver_requirements.rst in the libcamera sources for more information";
		return err;
	}

	return 0;
}

/*
 * \brief Initialize properties that cannot be intialized by the
 * regular initProperties() function for VIMC
 */
void CameraSensor::initVimcDefaultProperties()
{
	/* Use the largest supported size. */
	pixelArraySize_ = sizes_.back();
	activeArea_ = Rectangle(pixelArraySize_);
}

void CameraSensor::initStaticProperties()
{
	const CameraSensorProperties *props = CameraSensorProperties::get(model_);
	if (!props)
		return;

	/* Register the properties retrieved from the sensor database. */
	properties_.set(properties::UnitCellSize, props->unitCellSize);

	initTestPatternModes(props->testPatternModes);
}

void CameraSensor::initTestPatternModes(
	const std::map<int32_t, int32_t> &testPatternModes)
{
	const auto &v4l2TestPattern = controls().find(V4L2_CID_TEST_PATTERN);
	if (v4l2TestPattern == controls().end()) {
		LOG(CameraSensor, Debug) << "No static test pattern map for \'"
					 << model() << "\'";
		return;
	}

	for (const ControlValue &value : v4l2TestPattern->second.values()) {
		const int32_t index = value.get<int32_t>();

		const auto it = testPatternModes.find(index);
		if (it == testPatternModes.end()) {
			LOG(CameraSensor, Debug)
				<< "Test pattern mode " << index << " ignored";
			continue;
		}

		testPatternModes_.push_back(it->second);
	}
}

int CameraSensor::initProperties()
{
	/*
	 * Extract the camera sensor model name from the media entity name.
	 *
	 * There is no standardized naming scheme for sensor entities in the
	 * Linux kernel at the moment.
	 *
	 * - The most common rule, used by I2C sensors, associates the model
	 *   name with the I2C bus number and address (e.g. 'imx219 0-0010').
	 *
	 * - When the sensor exposes multiple subdevs, the model name is
	 *   usually followed by a function name, as in the smiapp driver (e.g.
	 *   'jt8ew9 pixel_array 0-0010').
	 *
	 * - The vimc driver names its sensors 'Sensor A' and 'Sensor B'.
	 *
	 * Other schemes probably exist. As a best effort heuristic, use the
	 * part of the entity name before the first space if the name contains
	 * an I2C address, and use the full entity name otherwise.
	 */
	std::string entityName = entity_->name();
	std::regex i2cRegex{ " [0-9]+-[0-9a-f]{4}" };
	std::smatch match;

	if (std::regex_search(entityName, match, i2cRegex))
		model_ = entityName.substr(0, entityName.find(' '));
	else
		model_ = entityName;

	properties_.set(properties::Model, utils::toAscii(model_));

	/* Generate a unique ID for the sensor. */
	int ret = generateId();
	if (ret)
		return ret;

	/* Initialize the static properties from the sensor database. */
	initStaticProperties();

	/* Retrieve and register properties from the kernel interface. */
	const ControlInfoMap &controls = subdev_->controls();
	int32_t propertyValue;

	const auto &orientation = controls.find(V4L2_CID_CAMERA_ORIENTATION);
	if (orientation != controls.end()) {
		int32_t v4l2Orientation = orientation->second.def().get<int32_t>();

		switch (v4l2Orientation) {
		default:
			LOG(CameraSensor, Warning)
				<< "Unsupported camera location "
				<< v4l2Orientation << ", setting to External";
			/* Fall-through */
		case V4L2_CAMERA_ORIENTATION_EXTERNAL:
			propertyValue = properties::CameraLocationExternal;
			break;
		case V4L2_CAMERA_ORIENTATION_FRONT:
			propertyValue = properties::CameraLocationFront;
			break;
		case V4L2_CAMERA_ORIENTATION_BACK:
			propertyValue = properties::CameraLocationBack;
			break;
		}
		properties_.set(properties::Location, propertyValue);
	} else {
		LOG(CameraSensor, Warning) << "Failed to retrieve the camera location";
	}

	const auto &rotationControl = controls.find(V4L2_CID_CAMERA_SENSOR_ROTATION);
	if (rotationControl != controls.end()) {
		propertyValue = rotationControl->second.def().get<int32_t>();
		properties_.set(properties::Rotation, propertyValue);
	}

	properties_.set(properties::PixelArraySize, pixelArraySize_);
	properties_.set(properties::PixelArrayActiveAreas, { activeArea_ });

	/* Color filter array pattern, register only for RAW sensors. */
	if (bayerFormat_) {
		int32_t cfa;
		switch (bayerFormat_->order) {
		case BayerFormat::BGGR:
			cfa = properties::draft::BGGR;
			break;
		case BayerFormat::GBRG:
			cfa = properties::draft::GBRG;
			break;
		case BayerFormat::GRBG:
			cfa = properties::draft::GRBG;
			break;
		case BayerFormat::RGGB:
			cfa = properties::draft::RGGB;
			break;
		case BayerFormat::MONO:
			cfa = properties::draft::MONO;
			break;
		}

		properties_.set(properties::draft::ColorFilterArrangement, cfa);
	}

	return 0;
}

/**
 * \fn CameraSensor::model()
 * \brief Retrieve the sensor model name
 *
 * The sensor model name is a free-formed string that uniquely identifies the