[RFC,1/6] camera_sensor: Add camera_sensor_basic

25390 diff mbox series

camera_sensor_legacy assumes camera sensors support bayer formats, and
requires mandatory controls. This means other camera sensors which do
not have those controls cannot be used with libcamera.

Create a new type of camera_sensor that has no mandatory control
requirements other than HBLANK and VBLANK.

Signed-off-by: Isaac Scott <isaac.scott@ideasonboard.com>
---
 src/libcamera/sensor/camera_sensor_basic.cpp | 964 +++++++++++++++++++
 src/libcamera/sensor/meson.build             |   1 +
 2 files changed, 965 insertions(+)
 create mode 100644 src/libcamera/sensor/camera_sensor_basic.cpp

Hi Isaac,

Thank you for the patch.

On Tue, Dec 09, 2025 at 06:09:49PM +0000, Isaac Scott wrote:
> camera_sensor_legacy assumes camera sensors support bayer formats, and
> requires mandatory controls. This means other camera sensors which do
> not have those controls cannot be used with libcamera.
> 
> Create a new type of camera_sensor that has no mandatory control
> requirements other than HBLANK and VBLANK.

Please tighten the requirements, not loosen them. The idea behind
CameraSensor and its derived classes is to have one derived class per
type of camera sensor driver. By driver type I mean the API exposed by
the driver to userspace. They are all based on V4L2, but use the V4L2
API elements in different ways. We're standardizing an API for raw
sensors, and need to do the same for other types of sensors too.

To put it differently, I don't want a "basic" catch-all class, but a
class that addresses a clearly defined set of sensors with a consistent
and documented API. Let's start with the first question: could you
please document what types of sensors you're addressing here, what they
have in common, and the scope of the allowed differences between them ?

> Signed-off-by: Isaac Scott <isaac.scott@ideasonboard.com>
> ---
>  src/libcamera/sensor/camera_sensor_basic.cpp | 964 +++++++++++++++++++
>  src/libcamera/sensor/meson.build             |   1 +
>  2 files changed, 965 insertions(+)
>  create mode 100644 src/libcamera/sensor/camera_sensor_basic.cpp
> 
> diff --git a/src/libcamera/sensor/camera_sensor_basic.cpp b/src/libcamera/sensor/camera_sensor_basic.cpp
> new file mode 100644
> index 000000000..57213a1ab
> --- /dev/null
> +++ b/src/libcamera/sensor/camera_sensor_basic.cpp
> @@ -0,0 +1,964 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2019, Google Inc.
> + *
> + * A V4L2-backed camera sensor
> + */
> +
> +#include <algorithm>
> +#include <cmath>
> +#include <float.h>
> +#include <iomanip>
> +#include <limits.h>
> +#include <map>
> +#include <memory>
> +#include <string.h>
> +#include <string>
> +#include <vector>
> +
> +#include <libcamera/base/class.h>
> +#include <libcamera/base/log.h>
> +#include <libcamera/base/utils.h>
> +
> +#include <libcamera/camera.h>
> +#include <libcamera/control_ids.h>
> +#include <libcamera/controls.h>
> +#include <libcamera/geometry.h>
> +#include <libcamera/orientation.h>
> +#include <libcamera/property_ids.h>
> +#include <libcamera/transform.h>
> +
> +#include <libcamera/ipa/core_ipa_interface.h>
> +
> +#include "libcamera/internal/bayer_format.h"
> +#include "libcamera/internal/camera_lens.h"
> +#include "libcamera/internal/camera_sensor.h"
> +#include "libcamera/internal/camera_sensor_properties.h"
> +#include "libcamera/internal/formats.h"
> +#include "libcamera/internal/media_device.h"
> +#include "libcamera/internal/sysfs.h"
> +#include "libcamera/internal/v4l2_subdevice.h"
> +
> +namespace libcamera {
> +
> +class BayerFormat;
> +class CameraLens;
> +class MediaEntity;
> +class SensorConfiguration;
> +
> +struct CameraSensorProperties;
> +
> +enum class Orientation;
> +
> +LOG_DECLARE_CATEGORY(CameraSensor)
> +
> +class CameraSensorBasic : public CameraSensor, protected Loggable
> +{
> +public:
> +	CameraSensorBasic(const MediaEntity *entity);
> +	~CameraSensorBasic();
> +
> +	static std::variant<std::unique_ptr<CameraSensor>, int>
> +	match(MediaEntity *entity);
> +
> +	const std::string &model() const override { return model_; }
> +	const std::string &id() const override { return id_; }
> +
> +	const MediaEntity *entity() const override { return entity_; }
> +	V4L2Subdevice *device() override { return subdev_.get(); }
> +
> +	CameraLens *focusLens() override { return focusLens_.get(); }
> +
> +	const std::vector<unsigned int> &mbusCodes() const override { return mbusCodes_; }
> +	std::vector<Size> sizes(unsigned int mbusCode) const override;
> +	Size resolution() const override;
> +
> +	V4L2SubdeviceFormat getFormat(Span<const unsigned int> mbusCodes,
> +				      const Size &size,
> +				      const Size maxSize) const override;
> +	int setFormat(V4L2SubdeviceFormat *format,
> +		      Transform transform = Transform::Identity) override;
> +	int tryFormat(V4L2SubdeviceFormat *format) const override;
> +
> +	int applyConfiguration(const SensorConfiguration &config,
> +			       Transform transform = Transform::Identity,
> +			       V4L2SubdeviceFormat *sensorFormat = nullptr) override;
> +
> +	const ControlList &properties() const override { return properties_; }
> +	int sensorInfo(IPACameraSensorInfo *info) const override;
> +	Transform computeTransform(Orientation *orientation) const override;
> +
> +	const ControlInfoMap &controls() const override;
> +	ControlList getControls(Span<const uint32_t> ids) override;
> +	int setControls(ControlList *ctrls) override;
> +
> +	const std::vector<controls::draft::TestPatternModeEnum> &
> +	testPatternModes() const override { return testPatternModes_; }
> +	int setTestPatternMode(controls::draft::TestPatternModeEnum mode) override;
> +	const CameraSensorProperties::SensorDelays &sensorDelays() override;
> +	BayerFormat::Order bayerOrder(Transform t) const override;
> +
> +protected:
> +	std::string logPrefix() const override;
> +
> +private:
> +	LIBCAMERA_DISABLE_COPY(CameraSensorBasic)
> +
> +	int init();
> +	int generateId();
> +	int validateSensorDriver();
> +	void initVimcDefaultProperties();
> +	void initStaticProperties();
> +	void initTestPatternModes();
> +	int initProperties();
> +	int applyTestPatternMode(controls::draft::TestPatternModeEnum mode);
> +	int discoverAncillaryDevices();
> +
> +	const MediaEntity *entity_;
> +	std::unique_ptr<V4L2Subdevice> subdev_;
> +	unsigned int pad_;
> +
> +	const CameraSensorProperties *staticProps_;
> +
> +	std::string model_;
> +	std::string id_;
> +
> +	V4L2Subdevice::Formats formats_;
> +	std::vector<unsigned int> mbusCodes_;
> +	std::vector<Size> sizes_;
> +	std::vector<controls::draft::TestPatternModeEnum> testPatternModes_;
> +	controls::draft::TestPatternModeEnum testPatternMode_;
> +
> +	Size pixelArraySize_;
> +	Rectangle activeArea_;
> +	bool supportFlips_;
> +	Orientation mountingOrientation_;
> +
> +	ControlList properties_;
> +
> +	std::unique_ptr<CameraLens> focusLens_;
> +};
> +
> +/**
> + * \class CameraSensorBasic
> + * \brief A camera sensor based on V4L2 subdevices
> + *
> + * 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.
> + */
> +
> +CameraSensorBasic::CameraSensorBasic(const MediaEntity *entity)
> +	: entity_(entity), pad_(UINT_MAX), staticProps_(nullptr),
> +	  supportFlips_(false), properties_(properties::properties)
> +{
> +}
> +
> +CameraSensorBasic::~CameraSensorBasic() = default;
> +
> +std::variant<std::unique_ptr<CameraSensor>, int>
> +CameraSensorBasic::match(MediaEntity *entity)
> +{
> +	std::unique_ptr<CameraSensorBasic> sensor =
> +		std::make_unique<CameraSensorBasic>(entity);
> +
> +	int ret = sensor->init();
> +	if (ret)
> +		return { ret };
> +
> +	return { std::move(sensor) };
> +}
> +
> +int CameraSensorBasic::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;
> +
> +	/*
> +	 * Clear any flips to be sure we get the "native" Bayer order. This is
> +	 * harmless for sensors where the flips don't affect the Bayer order.
> +	 */
> +	ControlList ctrls(subdev_->controls());
> +	if (subdev_->controls().find(V4L2_CID_HFLIP) != subdev_->controls().end())
> +		ctrls.set(V4L2_CID_HFLIP, 0);
> +	if (subdev_->controls().find(V4L2_CID_VFLIP) != subdev_->controls().end())
> +		ctrls.set(V4L2_CID_VFLIP, 0);
> +	subdev_->setControls(&ctrls);
> +
> +	/* 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();
> +
> +		ret = initProperties();
> +		if (ret)
> +			return ret;
> +
> +		return discoverAncillaryDevices();
> +	}
> +
> +	ret = validateSensorDriver();
> +	if (ret)
> +		return ret;
> +
> +	ret = initProperties();
> +	if (ret)
> +		return ret;
> +
> +	ret = discoverAncillaryDevices();
> +	if (ret)
> +		return ret;
> +
> +	/*
> +	 * Set HBLANK to the minimum to start with a well-defined line length,
> +	 * allowing IPA modules that do not modify HBLANK to use the sensor
> +	 * minimum line length in their calculations.
> +	 */
> +	const struct v4l2_query_ext_ctrl *hblankInfo = subdev_->controlInfo(V4L2_CID_HBLANK);
> +	if (hblankInfo && !(hblankInfo->flags & V4L2_CTRL_FLAG_READ_ONLY)) {
> +		ControlList ctrl(subdev_->controls());
> +
> +		ctrl.set(V4L2_CID_HBLANK, static_cast<int32_t>(hblankInfo->minimum));
> +		ret = subdev_->setControls(&ctrl);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	return applyTestPatternMode(controls::draft::TestPatternModeEnum::TestPatternModeOff);
> +}
> +
> +int CameraSensorBasic::generateId()
> +{
> +	const std::string devPath = subdev_->devicePath();
> +
> +	/* Try to get ID from firmware description. */
> +	id_ = sysfs::firmwareNodePath(devPath);
> +	if (!id_.empty())
> +		return 0;
> +
> +	/*
> +	 * Virtual sensors not described in firmware
> +	 *
> +	 * Verify it's a platform device and construct ID from the device path
> +	 * and model of sensor.
> +	 */
> +	if (devPath.find("/sys/devices/platform/", 0) == 0) {
> +		id_ = devPath.substr(strlen("/sys/devices/")) + " " + model();
> +		return 0;
> +	}
> +
> +	LOG(CameraSensor, Error) << "Can't generate sensor ID";
> +	return -EINVAL;
> +}
> +
> +int CameraSensorBasic::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;
> +		}
> +	}
> +
> +	/*
> +	 * Verify if sensor supports horizontal/vertical flips
> +	 *
> +	 * \todo Handle horizontal and vertical flips independently.
> +	 */
> +	const struct v4l2_query_ext_ctrl *hflipInfo = subdev_->controlInfo(V4L2_CID_HFLIP);
> +	const struct v4l2_query_ext_ctrl *vflipInfo = subdev_->controlInfo(V4L2_CID_VFLIP);
> +	if (hflipInfo && !(hflipInfo->flags & V4L2_CTRL_FLAG_READ_ONLY) &&
> +	    vflipInfo && !(vflipInfo->flags & V4L2_CTRL_FLAG_READ_ONLY)) {
> +		supportFlips_ = true;
> +
> +	}
> +
> +	if (!supportFlips_)
> +		LOG(CameraSensor, Debug)
> +			<< "Camera sensor does not support horizontal/vertical flip";
> +
> +	/*
> +	 * 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_;
> +		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_;
> +		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, 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;
> +}
> +
> +void CameraSensorBasic::initVimcDefaultProperties()
> +{
> +	/* Use the largest supported size. */
> +	pixelArraySize_ = sizes_.back();
> +	activeArea_ = Rectangle(pixelArraySize_);
> +}
> +
> +void CameraSensorBasic::initStaticProperties()
> +{
> +	staticProps_ = CameraSensorProperties::get(model_);
> +	if (!staticProps_)
> +		return;
> +
> +	/* Register the properties retrieved from the sensor database. */
> +	properties_.set(properties::UnitCellSize, staticProps_->unitCellSize);
> +
> +	initTestPatternModes();
> +}
> +
> +const CameraSensorProperties::SensorDelays &CameraSensorBasic::sensorDelays()
> +{
> +	static constexpr CameraSensorProperties::SensorDelays defaultSensorDelays = {
> +		.exposureDelay = 2,
> +		.gainDelay = 1,
> +		.vblankDelay = 2,
> +		.hblankDelay = 2,
> +	};
> +
> +	if (!staticProps_ ||
> +	    (!staticProps_->sensorDelays.exposureDelay &&
> +	     !staticProps_->sensorDelays.gainDelay &&
> +	     !staticProps_->sensorDelays.vblankDelay &&
> +	     !staticProps_->sensorDelays.hblankDelay)) {
> +		LOG(CameraSensor, Warning)
> +			<< "No sensor delays found in static properties. "
> +			   "Assuming unverified defaults.";
> +
> +		return defaultSensorDelays;
> +	}
> +
> +	return staticProps_->sensorDelays;
> +}
> +
> +void CameraSensorBasic::initTestPatternModes()
> +{
> +	const auto &v4l2TestPattern = controls().find(V4L2_CID_TEST_PATTERN);
> +	if (v4l2TestPattern == controls().end()) {
> +		LOG(CameraSensor, Debug) << "V4L2_CID_TEST_PATTERN is not supported";
> +		return;
> +	}
> +
> +	const auto &testPatternModes = staticProps_->testPatternModes;
> +	if (testPatternModes.empty()) {
> +		/*
> +		 * The camera sensor supports test patterns but we don't know
> +		 * how to map them so this should be fixed.
> +		 */
> +		LOG(CameraSensor, Debug) << "No static test pattern map for \'"
> +					 << model() << "\'";
> +		return;
> +	}
> +
> +	/*
> +	 * Create a map that associates the V4L2 control index to the test
> +	 * pattern mode by reversing the testPatternModes map provided by the
> +	 * camera sensor properties. This makes it easier to verify if the
> +	 * control index is supported in the below for loop that creates the
> +	 * list of supported test patterns.
> +	 */
> +	std::map<int32_t, controls::draft::TestPatternModeEnum> indexToTestPatternMode;
> +	for (const auto &it : testPatternModes)
> +		indexToTestPatternMode[it.second] = it.first;
> +
> +	for (const ControlValue &value : v4l2TestPattern->second.values()) {
> +		const int32_t index = value.get<int32_t>();
> +
> +		const auto it = indexToTestPatternMode.find(index);
> +		if (it == indexToTestPatternMode.end()) {
> +			LOG(CameraSensor, Debug)
> +				<< "Test pattern mode " << index << " ignored";
> +			continue;
> +		}
> +
> +		testPatternModes_.push_back(it->second);
> +	}
> +}
> +
> +int CameraSensorBasic::initProperties()
> +{
> +	model_ = subdev_->model();
> +	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();
> +
> +	const auto &orientation = controls.find(V4L2_CID_CAMERA_ORIENTATION);
> +	if (orientation != controls.end()) {
> +		int32_t v4l2Orientation = orientation->second.def().get<int32_t>();
> +		int32_t propertyValue;
> +
> +		switch (v4l2Orientation) {
> +		default:
> +			LOG(CameraSensor, Warning)
> +				<< "Unsupported camera location "
> +				<< v4l2Orientation << ", setting to External";
> +			[[fallthrough]];
> +		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()) {
> +		int32_t propertyValue = rotationControl->second.def().get<int32_t>();
> +
> +		/*
> +		 * Cache the Transform associated with the camera mounting
> +		 * rotation for later use in computeTransform().
> +		 */
> +		bool success;
> +		mountingOrientation_ = orientationFromRotation(propertyValue, &success);
> +		if (!success) {
> +			LOG(CameraSensor, Warning)
> +				<< "Invalid rotation of " << propertyValue
> +				<< " degrees - ignoring";
> +			mountingOrientation_ = Orientation::Rotate0;
> +		}
> +
> +		properties_.set(properties::Rotation, propertyValue);
> +	} else {
> +		LOG(CameraSensor, Warning)
> +			<< "Rotation control not available, default to 0 degrees";
> +		properties_.set(properties::Rotation, 0);
> +		mountingOrientation_ = Orientation::Rotate0;
> +	}
> +
> +	properties_.set(properties::PixelArraySize, pixelArraySize_);
> +	properties_.set(properties::PixelArrayActiveAreas, { activeArea_ });
> +
> +	return 0;
> +}
> +
> +int CameraSensorBasic::discoverAncillaryDevices()
> +{
> +	int ret;
> +
> +	for (MediaEntity *ancillary : entity_->ancillaryEntities()) {
> +		switch (ancillary->function()) {
> +		case MEDIA_ENT_F_LENS:
> +			focusLens_ = std::make_unique<CameraLens>(ancillary);
> +			ret = focusLens_->init();
> +			if (ret) {
> +				LOG(CameraSensor, Error)
> +					<< "Lens initialisation failed, lens disabled";
> +				focusLens_.reset();
> +			}
> +			break;
> +
> +		default:
> +			LOG(CameraSensor, Warning)
> +				<< "Unsupported ancillary entity function "
> +				<< ancillary->function();
> +			break;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +std::vector<Size> CameraSensorBasic::sizes(unsigned int mbusCode) const
> +{
> +	std::vector<Size> sizes;
> +
> +	const auto &format = formats_.find(mbusCode);
> +	if (format == formats_.end())
> +		return sizes;
> +
> +	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());
> +
> +	return sizes;
> +}
> +
> +Size CameraSensorBasic::resolution() const
> +{
> +	return std::min(sizes_.back(), activeArea_.size());
> +}
> +
> +V4L2SubdeviceFormat
> +CameraSensorBasic::getFormat(Span<const unsigned int> mbusCodes,
> +			      const Size &size, Size maxSize) const
> +{
> +	unsigned int desiredArea = size.width * size.height;
> +	unsigned int bestArea = UINT_MAX;
> +	float desiredRatio = static_cast<float>(size.width) / size.height;
> +	float bestRatio = FLT_MAX;
> +	const Size *bestSize = nullptr;
> +	uint32_t bestCode = 0;
> +
> +	for (unsigned int code : mbusCodes) {
> +		const auto formats = formats_.find(code);
> +		if (formats == formats_.end())
> +			continue;
> +
> +		for (const SizeRange &range : formats->second) {
> +			const Size &sz = range.max;
> +
> +			if (!maxSize.isNull() &&
> +			    (sz.width > maxSize.width || sz.height > maxSize.height))
> +				continue;
> +
> +			if (sz.width < size.width || sz.height < size.height)
> +				continue;
> +
> +			float ratio = static_cast<float>(sz.width) / sz.height;
> +			float ratioDiff = std::abs(ratio - desiredRatio);
> +			unsigned int area = sz.width * sz.height;
> +			unsigned int areaDiff = area - desiredArea;
> +
> +			if (ratioDiff > bestRatio)
> +				continue;
> +
> +			if (ratioDiff < bestRatio || areaDiff < bestArea) {
> +				bestRatio = ratioDiff;
> +				bestArea = areaDiff;
> +				bestSize = &sz;
> +				bestCode = code;
> +			}
> +		}
> +	}
> +
> +	if (!bestSize) {
> +		LOG(CameraSensor, Debug) << "No supported format or size found";
> +		return {};
> +	}
> +
> +	V4L2SubdeviceFormat format{
> +		.code = bestCode,
> +		.size = *bestSize,
> +		.colorSpace = ColorSpace::Raw,
> +	};
> +
> +	return format;
> +}
> +
> +int CameraSensorBasic::setFormat(V4L2SubdeviceFormat *format, Transform transform)
> +{
> +	/* Configure flips if the sensor supports that. */
> +	if (supportFlips_) {
> +		ControlList flipCtrls(subdev_->controls());
> +
> +		flipCtrls.set(V4L2_CID_HFLIP,
> +			      static_cast<int32_t>(!!(transform & Transform::HFlip)));
> +		flipCtrls.set(V4L2_CID_VFLIP,
> +			      static_cast<int32_t>(!!(transform & Transform::VFlip)));
> +
> +		int ret = subdev_->setControls(&flipCtrls);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	/* Apply format on the subdev. */
> +	int ret = subdev_->setFormat(pad_, format);
> +	if (ret)
> +		return ret;
> +
> +	subdev_->updateControlInfo();
> +	return 0;
> +}
> +
> +int CameraSensorBasic::tryFormat(V4L2SubdeviceFormat *format) const
> +{
> +	return subdev_->setFormat(pad_, format,
> +				  V4L2Subdevice::Whence::TryFormat);
> +}
> +
> +int CameraSensorBasic::applyConfiguration(const SensorConfiguration &config,
> +					   Transform transform,
> +					   V4L2SubdeviceFormat *sensorFormat)
> +{
> +	if (!config.isValid()) {
> +		LOG(CameraSensor, Error) << "Invalid sensor configuration";
> +		return -EINVAL;
> +	}
> +
> +	std::vector<unsigned int> filteredCodes;
> +	std::copy_if(mbusCodes_.begin(), mbusCodes_.end(),
> +		     std::back_inserter(filteredCodes),
> +		     [&config](unsigned int mbusCode) {
> +			     BayerFormat bayer = BayerFormat::fromMbusCode(mbusCode);
> +			     if (bayer.bitDepth == config.bitDepth)
> +				     return true;
> +			     return false;
> +		     });
> +	if (filteredCodes.empty()) {
> +		LOG(CameraSensor, Error)
> +			<< "Cannot find any format with bit depth "
> +			<< config.bitDepth;
> +		return -EINVAL;
> +	}
> +
> +	/*
> +	 * Compute the sensor's data frame size by applying the cropping
> +	 * rectangle, subsampling and output crop to the sensor's pixel array
> +	 * size.
> +	 *
> +	 * \todo The actual size computation is for now ignored and only the
> +	 * output size is considered. This implies that resolutions obtained
> +	 * with two different cropping/subsampling will look identical and
> +	 * only the first found one will be considered.
> +	 */
> +	V4L2SubdeviceFormat subdevFormat = {};
> +	for (unsigned int code : filteredCodes) {
> +		for (const Size &size : sizes(code)) {
> +			if (size.width != config.outputSize.width ||
> +			    size.height != config.outputSize.height)
> +				continue;
> +
> +			subdevFormat.code = code;
> +			subdevFormat.size = size;
> +			break;
> +		}
> +	}
> +	if (!subdevFormat.code) {
> +		LOG(CameraSensor, Error) << "Invalid output size in sensor configuration";
> +		return -EINVAL;
> +	}
> +
> +	int ret = setFormat(&subdevFormat, transform);
> +	if (ret)
> +		return ret;
> +
> +	/*
> +	 * Return to the caller the format actually applied to the sensor.
> +	 * This is relevant if transform has changed the bayer pattern order.
> +	 */
> +	if (sensorFormat)
> +		*sensorFormat = subdevFormat;
> +
> +	/* \todo Handle AnalogCrop. Most sensors do not support set_selection */
> +	/* \todo Handle scaling in the digital domain. */
> +
> +	return 0;
> +}
> +
> +int CameraSensorBasic::sensorInfo(IPACameraSensorInfo *info) const
> +{
> +	info->model = model();
> +
> +	/*
> +	 * The active area size is a static property, while the crop
> +	 * rectangle needs to be re-read as it depends on the sensor
> +	 * configuration.
> +	 */
> +	info->activeAreaSize = { activeArea_.width, activeArea_.height };
> +
> +	/*
> +	 * \todo Support for retreiving the crop rectangle is scheduled to
> +	 * become mandatory. For the time being use the default value if it has
> +	 * been initialized at sensor driver validation time.
> +	 */
> +	int ret = subdev_->getSelection(pad_, V4L2_SEL_TGT_CROP, &info->analogCrop);
> +	if (ret) {
> +		info->analogCrop = activeArea_;
> +		LOG(CameraSensor, Warning)
> +			<< "The analogue crop rectangle has been defaulted to the active area size";
> +	}
> +
> +	/*
> +	 * IPACameraSensorInfo::analogCrop::x and IPACameraSensorInfo::analogCrop::y
> +	 * are defined relatively to the active pixel area, while V4L2's
> +	 * TGT_CROP target is defined in respect to the full pixel array.
> +	 *
> +	 * Compensate it by subtracting the active area offset.
> +	 */
> +	info->analogCrop.x -= activeArea_.x;
> +	info->analogCrop.y -= activeArea_.y;
> +
> +	/* The bit depth and image size depend on the currently applied format. */
> +	V4L2SubdeviceFormat format{};
> +	ret = subdev_->getFormat(pad_, &format);
> +	if (ret)
> +		return ret;
> +	info->bitsPerPixel = MediaBusFormatInfo::info(format.code).bitsPerPixel;
> +	info->outputSize = format.size;
> +
> +	std::optional<int32_t> cfa = properties_.get(properties::draft::ColorFilterArrangement);
> +	info->cfaPattern = cfa ? *cfa : properties::draft::RGB;
> +
> +	/*
> +	 * Retrieve the pixel rate, line length and minimum/maximum frame
> +	 * duration through V4L2 controls. Support for the V4L2_CID_PIXEL_RATE,
> +	 * V4L2_CID_HBLANK and V4L2_CID_VBLANK controls is mandatory.
> +	 */
> +	static constexpr uint32_t cids[] = {
> +		V4L2_CID_PIXEL_RATE,
> +		V4L2_CID_HBLANK,
> +		V4L2_CID_VBLANK,
> +	};
> +
> +	ControlList ctrls = subdev_->getControls(cids);
> +	if (ctrls.empty()) {
> +		LOG(CameraSensor, Error)
> +			<< "Failed to retrieve camera info controls";
> +		return -EINVAL;
> +	}
> +
> +	info->pixelRate = ctrls.get(V4L2_CID_PIXEL_RATE).get<int64_t>();
> +
> +	const ControlInfo hblank = ctrls.infoMap()->at(V4L2_CID_HBLANK);
> +	info->minLineLength = info->outputSize.width + hblank.min().get<int32_t>();
> +	info->maxLineLength = info->outputSize.width + hblank.max().get<int32_t>();
> +
> +	const ControlInfo vblank = ctrls.infoMap()->at(V4L2_CID_VBLANK);
> +	info->minFrameLength = info->outputSize.height + vblank.min().get<int32_t>();
> +	info->maxFrameLength = info->outputSize.height + vblank.max().get<int32_t>();
> +
> +	return 0;
> +}
> +
> +Transform CameraSensorBasic::computeTransform(Orientation *orientation) const
> +{
> +	/*
> +	 * If we cannot do any flips we cannot change the native camera mounting
> +	 * orientation.
> +	 */
> +	if (!supportFlips_) {
> +		*orientation = mountingOrientation_;
> +		return Transform::Identity;
> +	}
> +
> +	/*
> +	 * Now compute the required transform to obtain 'orientation' starting
> +	 * from the mounting rotation.
> +	 *
> +	 * As a note:
> +	 * 	orientation / mountingOrientation_ = transform
> +	 * 	mountingOrientation_ * transform = orientation
> +	 */
> +	Transform transform = *orientation / mountingOrientation_;
> +
> +	/*
> +	 * If transform contains any Transpose we cannot do it, so adjust
> +	 * 'orientation' to report the image native orientation and return Identity.
> +	 */
> +	if (!!(transform & Transform::Transpose)) {
> +		*orientation = mountingOrientation_;
> +		return Transform::Identity;
> +	}
> +
> +	return transform;
> +}
> +
> +BayerFormat::Order CameraSensorBasic::bayerOrder([[maybe_unused]] Transform t) const
> +{
> +	return BayerFormat::Order::RGGB;
> +}
> +
> +const ControlInfoMap &CameraSensorBasic::controls() const
> +{
> +	return subdev_->controls();
> +}
> +
> +ControlList CameraSensorBasic::getControls(Span<const uint32_t> ids)
> +{
> +	return subdev_->getControls(ids);
> +}
> +
> +int CameraSensorBasic::setControls(ControlList *ctrls)
> +{
> +	return subdev_->setControls(ctrls);
> +}
> +
> +int CameraSensorBasic::setTestPatternMode(controls::draft::TestPatternModeEnum mode)
> +{
> +	if (testPatternMode_ == mode)
> +		return 0;
> +
> +	if (testPatternModes_.empty()) {
> +		LOG(CameraSensor, Error)
> +			<< "Camera sensor does not support test pattern modes.";
> +		return -EINVAL;
> +	}
> +
> +	return applyTestPatternMode(mode);
> +}
> +
> +int CameraSensorBasic::applyTestPatternMode(controls::draft::TestPatternModeEnum mode)
> +{
> +	if (testPatternModes_.empty())
> +		return 0;
> +
> +	auto it = std::find(testPatternModes_.begin(), testPatternModes_.end(),
> +			    mode);
> +	if (it == testPatternModes_.end()) {
> +		LOG(CameraSensor, Error) << "Unsupported test pattern mode "
> +					 << mode;
> +		return -EINVAL;
> +	}
> +
> +	LOG(CameraSensor, Debug) << "Apply test pattern mode " << mode;
> +
> +	int32_t index = staticProps_->testPatternModes.at(mode);
> +	ControlList ctrls{ controls() };
> +	ctrls.set(V4L2_CID_TEST_PATTERN, index);
> +
> +	int ret = setControls(&ctrls);
> +	if (ret)
> +		return ret;
> +
> +	testPatternMode_ = mode;
> +
> +	return 0;
> +}
> +
> +std::string CameraSensorBasic::logPrefix() const
> +{
> +	return "'" + entity_->name() + "'";
> +}
> +
> +REGISTER_CAMERA_SENSOR(CameraSensorBasic, -100)
> +
> +} /* namespace libcamera */
> diff --git a/src/libcamera/sensor/meson.build b/src/libcamera/sensor/meson.build
> index dce74ed6a..9fe627713 100644
> --- a/src/libcamera/sensor/meson.build
> +++ b/src/libcamera/sensor/meson.build
> @@ -2,6 +2,7 @@
>  
>  libcamera_internal_sources += files([
>      'camera_sensor.cpp',
> +    'camera_sensor_basic.cpp',
>      'camera_sensor_legacy.cpp',
>      'camera_sensor_properties.cpp',
>      'camera_sensor_raw.cpp',

Hi Laurent,

Thank you for the review!

Quoting Laurent Pinchart (2025-12-11 01:56:17)
> Hi Isaac,
> 
> Thank you for the patch.
> 
> On Tue, Dec 09, 2025 at 06:09:49PM +0000, Isaac Scott wrote:
> > camera_sensor_legacy assumes camera sensors support bayer formats, and
> > requires mandatory controls. This means other camera sensors which do
> > not have those controls cannot be used with libcamera.
> > 
> > Create a new type of camera_sensor that has no mandatory control
> > requirements other than HBLANK and VBLANK.
> 
> Please tighten the requirements, not loosen them. The idea behind
> CameraSensor and its derived classes is to have one derived class per
> type of camera sensor driver. By driver type I mean the API exposed by
> the driver to userspace. They are all based on V4L2, but use the V4L2
> API elements in different ways. We're standardizing an API for raw
> sensors, and need to do the same for other types of sensors too.
> 
> To put it differently, I don't want a "basic" catch-all class, but a
> class that addresses a clearly defined set of sensors with a consistent
> and documented API. Let's start with the first question: could you
> please document what types of sensors you're addressing here, what they
> have in common, and the scope of the allowed differences between them ?

The aim of adding this CameraSensor is to allow support for sensors
which do not support any RAW formats. The reason this patch series
exists is because I am working with a sensor that only has the
capability to output UYVY8_1X16 at a fixed size of 640x480, which was
not allowed before because the camera_sensor_legacy requires a
bayerFormat.

This camera also doesn't support any controls in particular, as
AEGC is performed on the device itself, and the only way to get data off
the camera is through MIPI CSI2 over a deserialiser.

I can see that the implementation is not ideal, and having a new
CameraSensor class with looser requirements is a slippery slope, because
it means camera sensors that could more aptly be represented by, say,
CameraSensorRaw could also be matched by this looser class.

What do you think is the best way to handle support for sensors that do
not support RAW formats in any way? Would it be better to create
something like 'CameraSensorYUV'?

Best wishes,
Isaac

> 
> > Signed-off-by: Isaac Scott <isaac.scott@ideasonboard.com>
> > ---
> >  src/libcamera/sensor/camera_sensor_basic.cpp | 964 +++++++++++++++++++
> >  src/libcamera/sensor/meson.build             |   1 +
> >  2 files changed, 965 insertions(+)
> >  create mode 100644 src/libcamera/sensor/camera_sensor_basic.cpp
> > 
> > diff --git a/src/libcamera/sensor/camera_sensor_basic.cpp b/src/libcamera/sensor/camera_sensor_basic.cpp
> > new file mode 100644
> > index 000000000..57213a1ab
> > --- /dev/null
> > +++ b/src/libcamera/sensor/camera_sensor_basic.cpp
> > @@ -0,0 +1,964 @@
> > +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> > +/*
> > + * Copyright (C) 2019, Google Inc.
> > + *
> > + * A V4L2-backed camera sensor
> > + */
> > +
> > +#include <algorithm>
> > +#include <cmath>
> > +#include <float.h>
> > +#include <iomanip>
> > +#include <limits.h>
> > +#include <map>
> > +#include <memory>
> > +#include <string.h>
> > +#include <string>
> > +#include <vector>
> > +
> > +#include <libcamera/base/class.h>
> > +#include <libcamera/base/log.h>
> > +#include <libcamera/base/utils.h>
> > +
> > +#include <libcamera/camera.h>
> > +#include <libcamera/control_ids.h>
> > +#include <libcamera/controls.h>
> > +#include <libcamera/geometry.h>
> > +#include <libcamera/orientation.h>
> > +#include <libcamera/property_ids.h>
> > +#include <libcamera/transform.h>
> > +
> > +#include <libcamera/ipa/core_ipa_interface.h>
> > +
> > +#include "libcamera/internal/bayer_format.h"
> > +#include "libcamera/internal/camera_lens.h"
> > +#include "libcamera/internal/camera_sensor.h"
> > +#include "libcamera/internal/camera_sensor_properties.h"
> > +#include "libcamera/internal/formats.h"
> > +#include "libcamera/internal/media_device.h"
> > +#include "libcamera/internal/sysfs.h"
> > +#include "libcamera/internal/v4l2_subdevice.h"
> > +
> > +namespace libcamera {
> > +
> > +class BayerFormat;
> > +class CameraLens;
> > +class MediaEntity;
> > +class SensorConfiguration;
> > +
> > +struct CameraSensorProperties;
> > +
> > +enum class Orientation;
> > +
> > +LOG_DECLARE_CATEGORY(CameraSensor)
> > +
> > +class CameraSensorBasic : public CameraSensor, protected Loggable
> > +{
> > +public:
> > +     CameraSensorBasic(const MediaEntity *entity);
> > +     ~CameraSensorBasic();
> > +
> > +     static std::variant<std::unique_ptr<CameraSensor>, int>
> > +     match(MediaEntity *entity);
> > +
> > +     const std::string &model() const override { return model_; }
> > +     const std::string &id() const override { return id_; }
> > +
> > +     const MediaEntity *entity() const override { return entity_; }
> > +     V4L2Subdevice *device() override { return subdev_.get(); }
> > +
> > +     CameraLens *focusLens() override { return focusLens_.get(); }
> > +
> > +     const std::vector<unsigned int> &mbusCodes() const override { return mbusCodes_; }
> > +     std::vector<Size> sizes(unsigned int mbusCode) const override;
> > +     Size resolution() const override;
> > +
> > +     V4L2SubdeviceFormat getFormat(Span<const unsigned int> mbusCodes,
> > +                                   const Size &size,
> > +                                   const Size maxSize) const override;
> > +     int setFormat(V4L2SubdeviceFormat *format,
> > +                   Transform transform = Transform::Identity) override;
> > +     int tryFormat(V4L2SubdeviceFormat *format) const override;
> > +
> > +     int applyConfiguration(const SensorConfiguration &config,
> > +                            Transform transform = Transform::Identity,
> > +                            V4L2SubdeviceFormat *sensorFormat = nullptr) override;
> > +
> > +     const ControlList &properties() const override { return properties_; }
> > +     int sensorInfo(IPACameraSensorInfo *info) const override;
> > +     Transform computeTransform(Orientation *orientation) const override;
> > +
> > +     const ControlInfoMap &controls() const override;
> > +     ControlList getControls(Span<const uint32_t> ids) override;
> > +     int setControls(ControlList *ctrls) override;
> > +
> > +     const std::vector<controls::draft::TestPatternModeEnum> &
> > +     testPatternModes() const override { return testPatternModes_; }
> > +     int setTestPatternMode(controls::draft::TestPatternModeEnum mode) override;
> > +     const CameraSensorProperties::SensorDelays &sensorDelays() override;
> > +     BayerFormat::Order bayerOrder(Transform t) const override;
> > +
> > +protected:
> > +     std::string logPrefix() const override;
> > +
> > +private:
> > +     LIBCAMERA_DISABLE_COPY(CameraSensorBasic)
> > +
> > +     int init();
> > +     int generateId();
> > +     int validateSensorDriver();
> > +     void initVimcDefaultProperties();
> > +     void initStaticProperties();
> > +     void initTestPatternModes();
> > +     int initProperties();
> > +     int applyTestPatternMode(controls::draft::TestPatternModeEnum mode);
> > +     int discoverAncillaryDevices();
> > +
> > +     const MediaEntity *entity_;
> > +     std::unique_ptr<V4L2Subdevice> subdev_;
> > +     unsigned int pad_;
> > +
> > +     const CameraSensorProperties *staticProps_;
> > +
> > +     std::string model_;
> > +     std::string id_;
> > +
> > +     V4L2Subdevice::Formats formats_;
> > +     std::vector<unsigned int> mbusCodes_;
> > +     std::vector<Size> sizes_;
> > +     std::vector<controls::draft::TestPatternModeEnum> testPatternModes_;
> > +     controls::draft::TestPatternModeEnum testPatternMode_;
> > +
> > +     Size pixelArraySize_;
> > +     Rectangle activeArea_;
> > +     bool supportFlips_;
> > +     Orientation mountingOrientation_;
> > +
> > +     ControlList properties_;
> > +
> > +     std::unique_ptr<CameraLens> focusLens_;
> > +};
> > +
> > +/**
> > + * \class CameraSensorBasic
> > + * \brief A camera sensor based on V4L2 subdevices
> > + *
> > + * 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.
> > + */
> > +
> > +CameraSensorBasic::CameraSensorBasic(const MediaEntity *entity)
> > +     : entity_(entity), pad_(UINT_MAX), staticProps_(nullptr),
> > +       supportFlips_(false), properties_(properties::properties)
> > +{
> > +}
> > +
> > +CameraSensorBasic::~CameraSensorBasic() = default;
> > +
> > +std::variant<std::unique_ptr<CameraSensor>, int>
> > +CameraSensorBasic::match(MediaEntity *entity)
> > +{
> > +     std::unique_ptr<CameraSensorBasic> sensor =
> > +             std::make_unique<CameraSensorBasic>(entity);
> > +
> > +     int ret = sensor->init();
> > +     if (ret)
> > +             return { ret };
> > +
> > +     return { std::move(sensor) };
> > +}
> > +
> > +int CameraSensorBasic::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;
> > +
> > +     /*
> > +      * Clear any flips to be sure we get the "native" Bayer order. This is
> > +      * harmless for sensors where the flips don't affect the Bayer order.
> > +      */
> > +     ControlList ctrls(subdev_->controls());
> > +     if (subdev_->controls().find(V4L2_CID_HFLIP) != subdev_->controls().end())
> > +             ctrls.set(V4L2_CID_HFLIP, 0);
> > +     if (subdev_->controls().find(V4L2_CID_VFLIP) != subdev_->controls().end())
> > +             ctrls.set(V4L2_CID_VFLIP, 0);
> > +     subdev_->setControls(&ctrls);
> > +
> > +     /* 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();
> > +
> > +             ret = initProperties();
> > +             if (ret)
> > +                     return ret;
> > +
> > +             return discoverAncillaryDevices();
> > +     }
> > +
> > +     ret = validateSensorDriver();
> > +     if (ret)
> > +             return ret;
> > +
> > +     ret = initProperties();
> > +     if (ret)
> > +             return ret;
> > +
> > +     ret = discoverAncillaryDevices();
> > +     if (ret)
> > +             return ret;
> > +
> > +     /*
> > +      * Set HBLANK to the minimum to start with a well-defined line length,
> > +      * allowing IPA modules that do not modify HBLANK to use the sensor
> > +      * minimum line length in their calculations.
> > +      */
> > +     const struct v4l2_query_ext_ctrl *hblankInfo = subdev_->controlInfo(V4L2_CID_HBLANK);
> > +     if (hblankInfo && !(hblankInfo->flags & V4L2_CTRL_FLAG_READ_ONLY)) {
> > +             ControlList ctrl(subdev_->controls());
> > +
> > +             ctrl.set(V4L2_CID_HBLANK, static_cast<int32_t>(hblankInfo->minimum));
> > +             ret = subdev_->setControls(&ctrl);
> > +             if (ret)
> > +                     return ret;
> > +     }
> > +
> > +     return applyTestPatternMode(controls::draft::TestPatternModeEnum::TestPatternModeOff);
> > +}
> > +
> > +int CameraSensorBasic::generateId()
> > +{
> > +     const std::string devPath = subdev_->devicePath();
> > +
> > +     /* Try to get ID from firmware description. */
> > +     id_ = sysfs::firmwareNodePath(devPath);
> > +     if (!id_.empty())
> > +             return 0;
> > +
> > +     /*
> > +      * Virtual sensors not described in firmware
> > +      *
> > +      * Verify it's a platform device and construct ID from the device path
> > +      * and model of sensor.
> > +      */
> > +     if (devPath.find("/sys/devices/platform/", 0) == 0) {
> > +             id_ = devPath.substr(strlen("/sys/devices/")) + " " + model();
> > +             return 0;
> > +     }
> > +
> > +     LOG(CameraSensor, Error) << "Can't generate sensor ID";
> > +     return -EINVAL;
> > +}
> > +
> > +int CameraSensorBasic::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;
> > +             }
> > +     }
> > +
> > +     /*
> > +      * Verify if sensor supports horizontal/vertical flips
> > +      *
> > +      * \todo Handle horizontal and vertical flips independently.
> > +      */
> > +     const struct v4l2_query_ext_ctrl *hflipInfo = subdev_->controlInfo(V4L2_CID_HFLIP);
> > +     const struct v4l2_query_ext_ctrl *vflipInfo = subdev_->controlInfo(V4L2_CID_VFLIP);
> > +     if (hflipInfo && !(hflipInfo->flags & V4L2_CTRL_FLAG_READ_ONLY) &&
> > +         vflipInfo && !(vflipInfo->flags & V4L2_CTRL_FLAG_READ_ONLY)) {
> > +             supportFlips_ = true;
> > +
> > +     }
> > +
> > +     if (!supportFlips_)
> > +             LOG(CameraSensor, Debug)
> > +                     << "Camera sensor does not support horizontal/vertical flip";
> > +
> > +     /*
> > +      * 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_;
> > +             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_;
> > +             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, 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;
> > +}
> > +
> > +void CameraSensorBasic::initVimcDefaultProperties()
> > +{
> > +     /* Use the largest supported size. */
> > +     pixelArraySize_ = sizes_.back();
> > +     activeArea_ = Rectangle(pixelArraySize_);
> > +}
> > +
> > +void CameraSensorBasic::initStaticProperties()
> > +{
> > +     staticProps_ = CameraSensorProperties::get(model_);
> > +     if (!staticProps_)
> > +             return;
> > +
> > +     /* Register the properties retrieved from the sensor database. */
> > +     properties_.set(properties::UnitCellSize, staticProps_->unitCellSize);
> > +
> > +     initTestPatternModes();
> > +}
> > +
> > +const CameraSensorProperties::SensorDelays &CameraSensorBasic::sensorDelays()
> > +{
> > +     static constexpr CameraSensorProperties::SensorDelays defaultSensorDelays = {
> > +             .exposureDelay = 2,
> > +             .gainDelay = 1,
> > +             .vblankDelay = 2,
> > +             .hblankDelay = 2,
> > +     };
> > +
> > +     if (!staticProps_ ||
> > +         (!staticProps_->sensorDelays.exposureDelay &&
> > +          !staticProps_->sensorDelays.gainDelay &&
> > +          !staticProps_->sensorDelays.vblankDelay &&
> > +          !staticProps_->sensorDelays.hblankDelay)) {
> > +             LOG(CameraSensor, Warning)
> > +                     << "No sensor delays found in static properties. "
> > +                        "Assuming unverified defaults.";
> > +
> > +             return defaultSensorDelays;
> > +     }
> > +
> > +     return staticProps_->sensorDelays;
> > +}
> > +
> > +void CameraSensorBasic::initTestPatternModes()
> > +{
> > +     const auto &v4l2TestPattern = controls().find(V4L2_CID_TEST_PATTERN);
> > +     if (v4l2TestPattern == controls().end()) {
> > +             LOG(CameraSensor, Debug) << "V4L2_CID_TEST_PATTERN is not supported";
> > +             return;
> > +     }
> > +
> > +     const auto &testPatternModes = staticProps_->testPatternModes;
> > +     if (testPatternModes.empty()) {
> > +             /*
> > +              * The camera sensor supports test patterns but we don't know
> > +              * how to map them so this should be fixed.
> > +              */
> > +             LOG(CameraSensor, Debug) << "No static test pattern map for \'"
> > +                                      << model() << "\'";
> > +             return;
> > +     }
> > +
> > +     /*
> > +      * Create a map that associates the V4L2 control index to the test
> > +      * pattern mode by reversing the testPatternModes map provided by the
> > +      * camera sensor properties. This makes it easier to verify if the
> > +      * control index is supported in the below for loop that creates the
> > +      * list of supported test patterns.
> > +      */
> > +     std::map<int32_t, controls::draft::TestPatternModeEnum> indexToTestPatternMode;
> > +     for (const auto &it : testPatternModes)
> > +             indexToTestPatternMode[it.second] = it.first;
> > +
> > +     for (const ControlValue &value : v4l2TestPattern->second.values()) {
> > +             const int32_t index = value.get<int32_t>();
> > +
> > +             const auto it = indexToTestPatternMode.find(index);
> > +             if (it == indexToTestPatternMode.end()) {
> > +                     LOG(CameraSensor, Debug)
> > +                             << "Test pattern mode " << index << " ignored";
> > +                     continue;
> > +             }
> > +
> > +             testPatternModes_.push_back(it->second);
> > +     }
> > +}
> > +
> > +int CameraSensorBasic::initProperties()
> > +{
> > +     model_ = subdev_->model();
> > +     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();
> > +
> > +     const auto &orientation = controls.find(V4L2_CID_CAMERA_ORIENTATION);
> > +     if (orientation != controls.end()) {
> > +             int32_t v4l2Orientation = orientation->second.def().get<int32_t>();
> > +             int32_t propertyValue;
> > +
> > +             switch (v4l2Orientation) {
> > +             default:
> > +                     LOG(CameraSensor, Warning)
> > +                             << "Unsupported camera location "
> > +                             << v4l2Orientation << ", setting to External";
> > +                     [[fallthrough]];
> > +             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()) {
> > +             int32_t propertyValue = rotationControl->second.def().get<int32_t>();
> > +
> > +             /*
> > +              * Cache the Transform associated with the camera mounting
> > +              * rotation for later use in computeTransform().
> > +              */
> > +             bool success;
> > +             mountingOrientation_ = orientationFromRotation(propertyValue, &success);
> > +             if (!success) {
> > +                     LOG(CameraSensor, Warning)
> > +                             << "Invalid rotation of " << propertyValue
> > +                             << " degrees - ignoring";
> > +                     mountingOrientation_ = Orientation::Rotate0;
> > +             }
> > +
> > +             properties_.set(properties::Rotation, propertyValue);
> > +     } else {
> > +             LOG(CameraSensor, Warning)
> > +                     << "Rotation control not available, default to 0 degrees";
> > +             properties_.set(properties::Rotation, 0);
> > +             mountingOrientation_ = Orientation::Rotate0;
> > +     }
> > +
> > +     properties_.set(properties::PixelArraySize, pixelArraySize_);
> > +     properties_.set(properties::PixelArrayActiveAreas, { activeArea_ });
> > +
> > +     return 0;
> > +}
> > +
> > +int CameraSensorBasic::discoverAncillaryDevices()
> > +{
> > +     int ret;
> > +
> > +     for (MediaEntity *ancillary : entity_->ancillaryEntities()) {
> > +             switch (ancillary->function()) {
> > +             case MEDIA_ENT_F_LENS:
> > +                     focusLens_ = std::make_unique<CameraLens>(ancillary);
> > +                     ret = focusLens_->init();
> > +                     if (ret) {
> > +                             LOG(CameraSensor, Error)
> > +                                     << "Lens initialisation failed, lens disabled";
> > +                             focusLens_.reset();
> > +                     }
> > +                     break;
> > +
> > +             default:
> > +                     LOG(CameraSensor, Warning)
> > +                             << "Unsupported ancillary entity function "
> > +                             << ancillary->function();
> > +                     break;
> > +             }
> > +     }
> > +
> > +     return 0;
> > +}
> > +
> > +std::vector<Size> CameraSensorBasic::sizes(unsigned int mbusCode) const
> > +{
> > +     std::vector<Size> sizes;
> > +
> > +     const auto &format = formats_.find(mbusCode);
> > +     if (format == formats_.end())
> > +             return sizes;
> > +
> > +     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());
> > +
> > +     return sizes;
> > +}
> > +
> > +Size CameraSensorBasic::resolution() const
> > +{
> > +     return std::min(sizes_.back(), activeArea_.size());
> > +}
> > +
> > +V4L2SubdeviceFormat
> > +CameraSensorBasic::getFormat(Span<const unsigned int> mbusCodes,
> > +                           const Size &size, Size maxSize) const
> > +{
> > +     unsigned int desiredArea = size.width * size.height;
> > +     unsigned int bestArea = UINT_MAX;
> > +     float desiredRatio = static_cast<float>(size.width) / size.height;
> > +     float bestRatio = FLT_MAX;
> > +     const Size *bestSize = nullptr;
> > +     uint32_t bestCode = 0;
> > +
> > +     for (unsigned int code : mbusCodes) {
> > +             const auto formats = formats_.find(code);
> > +             if (formats == formats_.end())
> > +                     continue;
> > +
> > +             for (const SizeRange &range : formats->second) {
> > +                     const Size &sz = range.max;
> > +
> > +                     if (!maxSize.isNull() &&
> > +                         (sz.width > maxSize.width || sz.height > maxSize.height))
> > +                             continue;
> > +
> > +                     if (sz.width < size.width || sz.height < size.height)
> > +                             continue;
> > +
> > +                     float ratio = static_cast<float>(sz.width) / sz.height;
> > +                     float ratioDiff = std::abs(ratio - desiredRatio);
> > +                     unsigned int area = sz.width * sz.height;
> > +                     unsigned int areaDiff = area - desiredArea;
> > +
> > +                     if (ratioDiff > bestRatio)
> > +                             continue;
> > +
> > +                     if (ratioDiff < bestRatio || areaDiff < bestArea) {
> > +                             bestRatio = ratioDiff;
> > +                             bestArea = areaDiff;
> > +                             bestSize = &sz;
> > +                             bestCode = code;
> > +                     }
> > +             }
> > +     }
> > +
> > +     if (!bestSize) {
> > +             LOG(CameraSensor, Debug) << "No supported format or size found";
> > +             return {};
> > +     }
> > +
> > +     V4L2SubdeviceFormat format{
> > +             .code = bestCode,
> > +             .size = *bestSize,
> > +             .colorSpace = ColorSpace::Raw,
> > +     };
> > +
> > +     return format;
> > +}
> > +
> > +int CameraSensorBasic::setFormat(V4L2SubdeviceFormat *format, Transform transform)
> > +{
> > +     /* Configure flips if the sensor supports that. */
> > +     if (supportFlips_) {
> > +             ControlList flipCtrls(subdev_->controls());
> > +
> > +             flipCtrls.set(V4L2_CID_HFLIP,
> > +                           static_cast<int32_t>(!!(transform & Transform::HFlip)));
> > +             flipCtrls.set(V4L2_CID_VFLIP,
> > +                           static_cast<int32_t>(!!(transform & Transform::VFlip)));
> > +
> > +             int ret = subdev_->setControls(&flipCtrls);
> > +             if (ret)
> > +                     return ret;
> > +     }
> > +
> > +     /* Apply format on the subdev. */
> > +     int ret = subdev_->setFormat(pad_, format);
> > +     if (ret)
> > +             return ret;
> > +
> > +     subdev_->updateControlInfo();
> > +     return 0;
> > +}
> > +
> > +int CameraSensorBasic::tryFormat(V4L2SubdeviceFormat *format) const
> > +{
> > +     return subdev_->setFormat(pad_, format,
> > +                               V4L2Subdevice::Whence::TryFormat);
> > +}
> > +
> > +int CameraSensorBasic::applyConfiguration(const SensorConfiguration &config,
> > +                                        Transform transform,
> > +                                        V4L2SubdeviceFormat *sensorFormat)
> > +{
> > +     if (!config.isValid()) {
> > +             LOG(CameraSensor, Error) << "Invalid sensor configuration";
> > +             return -EINVAL;
> > +     }
> > +
> > +     std::vector<unsigned int> filteredCodes;
> > +     std::copy_if(mbusCodes_.begin(), mbusCodes_.end(),
> > +                  std::back_inserter(filteredCodes),
> > +                  [&config](unsigned int mbusCode) {
> > +                          BayerFormat bayer = BayerFormat::fromMbusCode(mbusCode);
> > +                          if (bayer.bitDepth == config.bitDepth)
> > +                                  return true;
> > +                          return false;
> > +                  });
> > +     if (filteredCodes.empty()) {
> > +             LOG(CameraSensor, Error)
> > +                     << "Cannot find any format with bit depth "
> > +                     << config.bitDepth;
> > +             return -EINVAL;
> > +     }
> > +
> > +     /*
> > +      * Compute the sensor's data frame size by applying the cropping
> > +      * rectangle, subsampling and output crop to the sensor's pixel array
> > +      * size.
> > +      *
> > +      * \todo The actual size computation is for now ignored and only the
> > +      * output size is considered. This implies that resolutions obtained
> > +      * with two different cropping/subsampling will look identical and
> > +      * only the first found one will be considered.
> > +      */
> > +     V4L2SubdeviceFormat subdevFormat = {};
> > +     for (unsigned int code : filteredCodes) {
> > +             for (const Size &size : sizes(code)) {
> > +                     if (size.width != config.outputSize.width ||
> > +                         size.height != config.outputSize.height)
> > +                             continue;
> > +
> > +                     subdevFormat.code = code;
> > +                     subdevFormat.size = size;
> > +                     break;
> > +             }
> > +     }
> > +     if (!subdevFormat.code) {
> > +             LOG(CameraSensor, Error) << "Invalid output size in sensor configuration";
> > +             return -EINVAL;
> > +     }
> > +
> > +     int ret = setFormat(&subdevFormat, transform);
> > +     if (ret)
> > +             return ret;
> > +
> > +     /*
> > +      * Return to the caller the format actually applied to the sensor.
> > +      * This is relevant if transform has changed the bayer pattern order.
> > +      */
> > +     if (sensorFormat)
> > +             *sensorFormat = subdevFormat;
> > +
> > +     /* \todo Handle AnalogCrop. Most sensors do not support set_selection */
> > +     /* \todo Handle scaling in the digital domain. */
> > +
> > +     return 0;
> > +}
> > +
> > +int CameraSensorBasic::sensorInfo(IPACameraSensorInfo *info) const
> > +{
> > +     info->model = model();
> > +
> > +     /*
> > +      * The active area size is a static property, while the crop
> > +      * rectangle needs to be re-read as it depends on the sensor
> > +      * configuration.
> > +      */
> > +     info->activeAreaSize = { activeArea_.width, activeArea_.height };
> > +
> > +     /*
> > +      * \todo Support for retreiving the crop rectangle is scheduled to
> > +      * become mandatory. For the time being use the default value if it has
> > +      * been initialized at sensor driver validation time.
> > +      */
> > +     int ret = subdev_->getSelection(pad_, V4L2_SEL_TGT_CROP, &info->analogCrop);
> > +     if (ret) {
> > +             info->analogCrop = activeArea_;
> > +             LOG(CameraSensor, Warning)
> > +                     << "The analogue crop rectangle has been defaulted to the active area size";
> > +     }
> > +
> > +     /*
> > +      * IPACameraSensorInfo::analogCrop::x and IPACameraSensorInfo::analogCrop::y
> > +      * are defined relatively to the active pixel area, while V4L2's
> > +      * TGT_CROP target is defined in respect to the full pixel array.
> > +      *
> > +      * Compensate it by subtracting the active area offset.
> > +      */
> > +     info->analogCrop.x -= activeArea_.x;
> > +     info->analogCrop.y -= activeArea_.y;
> > +
> > +     /* The bit depth and image size depend on the currently applied format. */
> > +     V4L2SubdeviceFormat format{};
> > +     ret = subdev_->getFormat(pad_, &format);
> > +     if (ret)
> > +             return ret;
> > +     info->bitsPerPixel = MediaBusFormatInfo::info(format.code).bitsPerPixel;
> > +     info->outputSize = format.size;
> > +
> > +     std::optional<int32_t> cfa = properties_.get(properties::draft::ColorFilterArrangement);
> > +     info->cfaPattern = cfa ? *cfa : properties::draft::RGB;
> > +
> > +     /*
> > +      * Retrieve the pixel rate, line length and minimum/maximum frame
> > +      * duration through V4L2 controls. Support for the V4L2_CID_PIXEL_RATE,
> > +      * V4L2_CID_HBLANK and V4L2_CID_VBLANK controls is mandatory.
> > +      */
> > +     static constexpr uint32_t cids[] = {
> > +             V4L2_CID_PIXEL_RATE,
> > +             V4L2_CID_HBLANK,
> > +             V4L2_CID_VBLANK,
> > +     };
> > +
> > +     ControlList ctrls = subdev_->getControls(cids);
> > +     if (ctrls.empty()) {
> > +             LOG(CameraSensor, Error)
> > +                     << "Failed to retrieve camera info controls";
> > +             return -EINVAL;
> > +     }
> > +
> > +     info->pixelRate = ctrls.get(V4L2_CID_PIXEL_RATE).get<int64_t>();
> > +
> > +     const ControlInfo hblank = ctrls.infoMap()->at(V4L2_CID_HBLANK);
> > +     info->minLineLength = info->outputSize.width + hblank.min().get<int32_t>();
> > +     info->maxLineLength = info->outputSize.width + hblank.max().get<int32_t>();
> > +
> > +     const ControlInfo vblank = ctrls.infoMap()->at(V4L2_CID_VBLANK);
> > +     info->minFrameLength = info->outputSize.height + vblank.min().get<int32_t>();
> > +     info->maxFrameLength = info->outputSize.height + vblank.max().get<int32_t>();
> > +
> > +     return 0;
> > +}
> > +
> > +Transform CameraSensorBasic::computeTransform(Orientation *orientation) const
> > +{
> > +     /*
> > +      * If we cannot do any flips we cannot change the native camera mounting
> > +      * orientation.
> > +      */
> > +     if (!supportFlips_) {
> > +             *orientation = mountingOrientation_;
> > +             return Transform::Identity;
> > +     }
> > +
> > +     /*
> > +      * Now compute the required transform to obtain 'orientation' starting
> > +      * from the mounting rotation.
> > +      *
> > +      * As a note:
> > +      *      orientation / mountingOrientation_ = transform
> > +      *      mountingOrientation_ * transform = orientation
> > +      */
> > +     Transform transform = *orientation / mountingOrientation_;
> > +
> > +     /*
> > +      * If transform contains any Transpose we cannot do it, so adjust
> > +      * 'orientation' to report the image native orientation and return Identity.
> > +      */
> > +     if (!!(transform & Transform::Transpose)) {
> > +             *orientation = mountingOrientation_;
> > +             return Transform::Identity;
> > +     }
> > +
> > +     return transform;
> > +}
> > +
> > +BayerFormat::Order CameraSensorBasic::bayerOrder([[maybe_unused]] Transform t) const
> > +{
> > +     return BayerFormat::Order::RGGB;
> > +}
> > +
> > +const ControlInfoMap &CameraSensorBasic::controls() const
> > +{
> > +     return subdev_->controls();
> > +}
> > +
> > +ControlList CameraSensorBasic::getControls(Span<const uint32_t> ids)
> > +{
> > +     return subdev_->getControls(ids);
> > +}
> > +
> > +int CameraSensorBasic::setControls(ControlList *ctrls)
> > +{
> > +     return subdev_->setControls(ctrls);
> > +}
> > +
> > +int CameraSensorBasic::setTestPatternMode(controls::draft::TestPatternModeEnum mode)
> > +{
> > +     if (testPatternMode_ == mode)
> > +             return 0;
> > +
> > +     if (testPatternModes_.empty()) {
> > +             LOG(CameraSensor, Error)
> > +                     << "Camera sensor does not support test pattern modes.";
> > +             return -EINVAL;
> > +     }
> > +
> > +     return applyTestPatternMode(mode);
> > +}
> > +
> > +int CameraSensorBasic::applyTestPatternMode(controls::draft::TestPatternModeEnum mode)
> > +{
> > +     if (testPatternModes_.empty())
> > +             return 0;
> > +
> > +     auto it = std::find(testPatternModes_.begin(), testPatternModes_.end(),
> > +                         mode);
> > +     if (it == testPatternModes_.end()) {
> > +             LOG(CameraSensor, Error) << "Unsupported test pattern mode "
> > +                                      << mode;
> > +             return -EINVAL;
> > +     }
> > +
> > +     LOG(CameraSensor, Debug) << "Apply test pattern mode " << mode;
> > +
> > +     int32_t index = staticProps_->testPatternModes.at(mode);
> > +     ControlList ctrls{ controls() };
> > +     ctrls.set(V4L2_CID_TEST_PATTERN, index);
> > +
> > +     int ret = setControls(&ctrls);
> > +     if (ret)
> > +             return ret;
> > +
> > +     testPatternMode_ = mode;
> > +
> > +     return 0;
> > +}
> > +
> > +std::string CameraSensorBasic::logPrefix() const
> > +{
> > +     return "'" + entity_->name() + "'";
> > +}
> > +
> > +REGISTER_CAMERA_SENSOR(CameraSensorBasic, -100)
> > +
> > +} /* namespace libcamera */
> > diff --git a/src/libcamera/sensor/meson.build b/src/libcamera/sensor/meson.build
> > index dce74ed6a..9fe627713 100644
> > --- a/src/libcamera/sensor/meson.build
> > +++ b/src/libcamera/sensor/meson.build
> > @@ -2,6 +2,7 @@
> >  
> >  libcamera_internal_sources += files([
> >      'camera_sensor.cpp',
> > +    'camera_sensor_basic.cpp',
> >      'camera_sensor_legacy.cpp',
> >      'camera_sensor_properties.cpp',
> >      'camera_sensor_raw.cpp',
> 
> -- 
> Regards,
> 
> Laurent Pinchart