libcamera/vivid.git - libcamera pipeline handler for VIVID

diff options

author	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2022-10-03 22:55:11 +0300
committer	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2022-10-07 18:02:06 +0300
commit	b4a3e6ade7864620e453ad81595407aac1979dee (patch)
tree	5662e02e3a1442708a29642f74082568bce8efac /test/controls/control_value.cpp
parent	c4d39f0c31d968d874b8519af7458cbb34e3abe0 (diff)

ipa: camera_sensor_helper: Make registerType() and createInstance() private

The CameraSensorHelperFactory registerType() and createInstance() functions are called by the CameraSensorHelperFactory class only. Make them private. Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Xavier Roumegue <xavier.roumegue@oss.nxp.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>

Diffstat (limited to 'test/controls/control_value.cpp')

0 files changed, 0 insertions, 0 deletions

/* 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/internal/bayer_format.h" #include "libcamera/internal/formats.h" #include "libcamera/internal/sysfs.h" #include "libcamera/internal/utils.h" /** * \file camera_sensor.h * \brief A camera sensor */ namespace libcamera { LOG_DEFINE_CATEGORY(CameraSensor) /** * \struct CameraSensorInfo * \brief Report the image sensor characteristics * * The structure reports image sensor characteristics used by IPA modules to * tune their algorithms based on the image sensor model currently in use and * its configuration. * * The reported information describes the sensor's intrinsics characteristics, * such as its pixel array size and the sensor model name, as well as * information relative to the currently configured mode, such as the produced * image size and the bit depth of the requested image format. * * Instances of this structure are meant to be assembled by the CameraSensor * class by inspecting the sensor static properties as well as information * relative to the current configuration. */ /** * \var CameraSensorInfo::model * \brief The image sensor model name * * The sensor model name is a free-formed string that uniquely identifies the * sensor model. */ /** * \var CameraSensorInfo::bitsPerPixel * \brief The number of bits per pixel of the image format produced by the * image sensor */ /** * \var CameraSensorInfo::activeAreaSize * \brief The size of the pixel array active area of the sensor */ /** * \var CameraSensorInfo::analogCrop * \brief The portion of the pixel array active area which is read-out and * processed * * The analog crop rectangle top-left corner is defined as the displacement * from the top-left corner of the pixel array active area. The rectangle * horizontal and vertical sizes define the portion of the pixel array which * is read-out and provided to the sensor's internal processing pipeline, before * any pixel sub-sampling method, such as pixel binning, skipping and averaging * take place. */ /** * \var CameraSensorInfo::outputSize * \brief The size of the images produced by the camera sensor * * The output image size defines the horizontal and vertical sizes of the images * produced by the image sensor. The output image size is defined as the end * result of the sensor's internal image processing pipeline stages, applied on * the pixel array portion defined by the analog crop rectangle. Each image * processing stage that performs pixel sub-sampling techniques, such as pixel * binning or skipping, or perform any additional digital scaling concur in the * definition of the output image size. */ /** * \var CameraSensorInfo::pixelRate * \brief The number of pixels produced in a second * * To obtain the read-out time in seconds of a full line: * * \verbatim lineDuration(s) = lineLength(pixels) / pixelRate(pixels per second) \endverbatim */ /** * \var CameraSensorInfo::lineLength * \brief Total line length in pixels * * The total line length in pixel clock periods, including blanking. */ /** * \var CameraSensorInfo::minFrameLength * \brief The minimum allowable frame length in units of lines * * The sensor frame length comprises of active output lines and blanking lines * in a frame. The minimum frame length value dictates the minimum allowable * frame duration of the sensor mode. * * To obtain the minimum frame duration: * * \verbatim frameDuration(s) = minFrameLength(lines) * lineLength(pixels) / pixelRate(pixels per second) \endverbatim */ /** * \var CameraSensorInfo::maxFrameLength * \brief The maximum allowable frame length in units of lines * * The sensor frame length comprises of active output lines and blanking lines * in a frame. The maximum frame length value dictates the maximum allowable * frame duration of the sensor mode. * * To obtain the maximum frame duration: * * \verbatim frameDuration(s) = maxFrameLength(lines) * lineLength(pixels) / pixelRate(pixels per second) \endverbatim */ /** * \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), properties_(properties::properties) { } /** * \brief Destroy a CameraSensor */ CameraSensor::~CameraSensor() { } /** * \brief Initialize the camera sensor instance * * This method 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; } if (entity_->function() != MEDIA_ENT_F_CAM_SENSOR) { 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()); /* * The sizes_ vector is sorted in ascending order, the resolution is * thus the last element of the vector. */ resolution_ = sizes_.back(); /* * 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(); } ret = validateSensorDriver(); if (ret) return ret; ret = initProperties(); if (ret) return ret; return 0; } int CameraSensor::validateSensorDriver() { /* * Make sure the sensor driver supports the mandatory controls * required by the CameraSensor class. */ const std::vector<uint32_t> mandatoryControls{ V4L2_CID_EXPOSURE, V4L2_CID_HBLANK, V4L2_CID_PIXEL_RATE, V4L2_CID_VBLANK, }; ControlList ctrls = subdev_->getControls(mandatoryControls); if (ctrls.empty()) { LOG(CameraSensor, Error) << "Mandatory V4L2 controls not available"; 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 -EINVAL; } /* * Optional controls are used to register optional sensor properties. If * not present, some values will be defaulted. */ const std::vector<uint32_t> optionalControls{ V4L2_CID_CAMERA_ORIENTATION, V4L2_CID_CAMERA_SENSOR_ROTATION, }; ctrls = subdev_->getControls(optionalControls); if (ctrls.empty()) LOG(CameraSensor, Debug) << "Optional V4L2 controls not supported"; /* * 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 * CameraSensorInfo for the IPA module, won't be supported. * * \todo Make support for selection targets mandatory as soon as all * test platforms have been updated. */ int err = 0; Rectangle rect; int ret = subdev_->getSelection(pad_, V4L2_SEL_TGT_CROP_BOUNDS, &rect); if (ret) { rect = Rectangle(resolution()); LOG(CameraSensor, Warning) << "The PixelArraySize property has been defaulted to " << rect.toString(); err = -EINVAL; } pixelArraySize_.width = rect.width; pixelArraySize_.height = rect.height; 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"; } return 0; } /* * \brief Initialize properties that cannot be intialized by the * regular initProperties() function for VIMC */ void CameraSensor::initVimcDefaultProperties() { pixelArraySize_ = resolution(); activeArea_ = Rectangle(pixelArraySize_); } 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; /* Retrieve and store the camera sensor properties. */ 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; } } else { propertyValue = properties::CameraLocationExternal; } properties_.set(properties::Location, propertyValue); 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. */ for (const auto &format : formats_) { unsigned int mbusCode = format.first; BayerFormat bayerFormat = BayerFormat::fromMbusCode(mbusCode); if (!bayerFormat.isValid()) continue; 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:


context:
space:
mode: