libcamera/libcamera.git - libcamera official repository

diff options

author	Naushir Patuck <naush@raspberrypi.com>	2020-04-24 11:46:57 +0100
committer	Laurent Pinchart <laurent.pinchart@ideasonboard.com>	2020-04-27 20:18:08 +0300
commit	fa77a02c0a099ad02ed55935bdbe8cd441a8d893 (patch)
tree	8290bd44507f8ed45ab9cc465a86941c39b1f68a /src/qcam/assets/feathericons/log-in.svg
parent	47d09a13b3acead2cd6007d6b6022931756c9ae7 (diff)

libcamera: controls: Updates to gain and exposure controls

Rename: ManualExposure -> ExposureTime ManualGain -> AnalogueGain Use micro-seconds units for ExposureTime. This is changed from milli- seconds. The latter would not allow very low exposure times. AnalogueGain switch to use a float to allow fractional gain adjustments. Update the uvcvideo pipeline handler to use the new exposure and gain units. For ExposureTime, UVC uses units of 100 micro-seconds, so map the values before setting V4L2_CID_EXPOSURE_ABSOLUTE. For AnalogueGain, UVC has no explicit gain units, so map the default gain value to 1.0 and linearly scale to the requested value. Signed-off-by: Naushir Patuck <naush@raspberrypi.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>

Diffstat (limited to 'src/qcam/assets/feathericons/log-in.svg')

0 files changed, 0 insertions, 0 deletions

.. SPDX-License-Identifier: CC-BY-SA-4.0 Pipeline Handler Writers Guide ============================== Pipeline handlers are the abstraction layer for device-specific hardware configuration. They access and control hardware through the V4L2 and Media Controller kernel interfaces, and implement an internal API to control the ISP and capture components of a pipeline directly. Prerequisite knowledge: system architecture ------------------------------------------- A pipeline handler configures and manages the image acquisition and transformation pipeline realized by specialized system peripherals combined with an image source connected to the system through a data and control bus. The presence, number and characteristics of them vary depending on the system design and the product integration of the target platform. System components can be classified in three macro-categories: .. TODO: Insert references to the open CSI-2 (and other) specification. - Input ports: Interfaces to external devices, usually image sensors, which transfer data from the physical bus to locations accessible by other system peripherals. An input port needs to be configured according to the input image format and size and could optionally apply basic transformations on the received images, most typically cropping/scaling and some formats conversion. The industry standard for the system typically targeted by libcamera is to have receivers compliant with the MIPI CSI-2 specifications, implemented on a compatible physical layer such as MIPI D-PHY or MIPI C-PHY. Other design are possible but less common, such as LVDS or the legacy BT.601 and BT.656 parallel protocols. - Image Signal Processor (ISP): A specialized media processor which applies digital transformations on image streams. ISPs can be integrated as part of the SoC as a memory interfaced system peripheral or packaged as stand-alone chips connected to the application processor through a bus. Most hardware used by libcamera makes use of in-system ISP designs but pipelines can equally support external ISP chips or be instrumented to use other system resources such as a GPU or an FPGA IP block. ISPs expose a software programming interface that allows the configuration of multiple processing blocks which form an "Image Transformation Pipeline". An ISP usually produces 'processed' image streams along with the metadata describing the processing steps which have been applied to generate the output frames. - Camera Sensor: Digital components that integrate an image sensor with control electronics and usually a lens. It interfaces to the SoC image receiver ports and is programmed to produce images in a format and size suitable for the current system configuration. Complex camera modules can integrate on-board ISP or DSP chips and process images before delivering them to the system. Most systems with a dedicated ISP processor will usually integrate camera sensors which produce images in Raw Bayer format and defer processing to it. It is the responsibility of the pipeline handler to interface with these (and possibly other) components of the system and implement the following functionalities: - Detect and register camera devices available in the system with an associated set of image streams. - Configure the image acquisition and processing pipeline by assigning the system resources (memory, shared components, etc.) to satisfy the configuration requested by the application. - Start and stop the image acquisition and processing sessions. - Apply configuration settings requested by applications and computed by image processing algorithms integrated in libcamera to the hardware devices. - Notify applications of the availability of new images and deliver them to the correct locations. Prerequisite knowledge: libcamera architecture ---------------------------------------------- A pipeline handler makes use of the following libcamera classes to realize the functionalities descibed above. Below is a brief overview of each of those: .. TODO: (All) Convert to sphinx refs .. TODO: (MediaDevice) Reference to the Media Device API (possibly with versioning requirements) .. TODO: (IPAInterface) refer to the IPA guide - `MediaDevice <http://libcamera.org/api-html/classlibcamera_1_1MediaDevice.html>`_: Instances of this class are associated with a kernel media controller device and its connected objects. - `DeviceEnumerator <http://libcamera.org/api-html/classlibcamera_1_1DeviceEnumerator.html>`_: Enumerates all media devices attached to the system and the media entities registered with it, by creating instances of the ``MediaDevice`` class and storing them. - `DeviceMatch <http://libcamera.org/api-html/classlibcamera_1_1DeviceMatch.html>`_: Describes a media device search pattern using entity names, or other properties. - `V4L2VideoDevice <http://libcamera.org/api-html/classlibcamera_1_1V4L2VideoDevice.html>`_: Models an instance of a V4L2 video device constructed with the path to a V4L2 video device node. - `V4L2SubDevice <http://libcamera.org/api-html/classlibcamera_1_1V4L2Subdevice.html>`_: Provides an API to the sub-devices that model the hardware components of a V4L2 device. - `CameraSensor <http://libcamera.org/api-html/classlibcamera_1_1CameraSensor.html>`_: Abstracts camera sensor handling by hiding the details of the V4L2 subdevice kernel API and caching sensor information. - `CameraData <http://libcamera.org/api-html/classlibcamera_1_1CameraData.html>`_: Represents device-specific data a pipeline handler associates to each Camera instance. - `StreamConfiguration <http://libcamera.org/api-html/structlibcamera_1_1StreamConfiguration.html>`_: Models the current configuration of an image stream produced by the camera by reporting its format and sizes. - `CameraConfiguration <http://libcamera.org/api-html/classlibcamera_1_1CameraConfiguration.html>`_: Represents the current configuration of a camera, which includes a list of stream configurations for each active stream in a capture session. When validated, it is applied to the camera. - `IPAInterface <http://libcamera.org/api-html/classlibcamera_1_1IPAInterface.html>`_: The interface to the Image Processing Algorithm (IPA) module which performs the computation of the image processing pipeline tuning parameters. - `ControlList <http://libcamera.org/api-html/classlibcamera_1_1ControlList.html>`_: A list of control items, indexed by Control<> instances or by numerical index which contains values used by application and IPA to change parameters of image streams, used to return to applications and share with IPA the metadata associated with the captured images, and to advertise the immutable camera characteristics enumerated at system initialization time. Creating a PipelineHandler -------------------------- This guide walks through the steps to create a simple pipeline handler called “Vivid” that supports the `V4L2 Virtual Video Test Driver`_ (vivid). To use the vivid test driver, you first need to check that the vivid kernel module is loaded, for example with the ``modprobe vivid`` command. .. _V4L2 Virtual Video Test Driver: https://www.kernel.org/doc/html/latest/admin-guide/media/vivid.html Create the skeleton file structure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To add a new pipeline handler, create a directory to hold the pipeline code in the *src/libcamera/pipeline/* directory that matches the name of the pipeline (in this case *vivid*). Inside the new directory add a *meson.build* file that integrates with the libcamera build system, and a *vivid.cpp* file that matches the name of the pipeline. In the *meson.build* file, add the *vivid.cpp* file as a build source for libcamera by adding it to the global meson ``libcamera_sources`` variable: .. code-block:: none # SPDX-License-Identifier: CC0-1.0 libcamera_sources += files([ 'vivid.cpp', ]) Users of libcamera can selectively enable pipelines while building libcamera using the ``pipelines`` option. For example, to enable only the IPU3, UVC, and VIVID pipelines, specify them as a comma separated list with ``-Dpipelines`` when generating a build directory: .. code-block:: shell meson build -Dpipelines=ipu3,uvcvideo,vivid Read the `Meson build configuration`_ documentation for more information on configuring a build directory. .. _Meson build configuration: https://mesonbuild.com/Configuring-a-build-directory.html To add the new pipeline handler to this list of options, add its directory name to the libcamera build options in the top level ``meson_options.txt``. .. code-block:: none option('pipelines', type : 'array', choices : ['ipu3', 'raspberrypi', 'rkisp1', 'simple', 'uvcvideo', 'vimc', 'vivid'], description : 'Select which pipeline handlers to include') In *vivid.cpp* add the pipeline handler to the ``libcamera`` namespace, defining a `PipelineHandler`_ derived class named PipelineHandlerVivid, and add stub methods for the overridden class members. .. _PipelineHandler: http://libcamera.org/api-html/classlibcamera_1_1PipelineHandler.html .. code-block:: cpp namespace libcamera { class PipelineHandlerVivid : public PipelineHandler { public: PipelineHandlerVivid(CameraManager *manager); CameraConfiguration *generateConfiguration(Camera *camera, const StreamRoles &roles) override; int configure(Camera *camera, CameraConfiguration *config) override; int exportFrameBuffers(Camera *camera, Stream *stream, std::vector<std::unique_ptr<FrameBuffer>> *buffers) override; int start(Camera *camera, const ControlList *controls) override; void stop(Camera *camera) override; int queueRequestDevice(Camera *camera, Request *request) override; bool match(DeviceEnumerator *enumerator) override; }; PipelineHandlerVivid::PipelineHandlerVivid(CameraManager *manager) : PipelineHandler(manager) { } CameraConfiguration *PipelineHandlerVivid::generateConfiguration(Camera *camera, const StreamRoles &roles) { return nullptr; } int PipelineHandlerVivid::configure(Camera *camera, CameraConfiguration *config) { return -1; } int PipelineHandlerVivid::exportFrameBuffers(Camera *camera, Stream *stream, std::vector<std::unique_ptr<FrameBuffer>> *buffers) { return -1; } int PipelineHandlerVivid::start(Camera *camera, const ControlList *controls) { return -1; } void PipelineHandlerVivid::stop(Camera *camera) { } int PipelineHandlerVivid::queueRequestDevice(Camera *camera, Request *request) { return -1; } bool PipelineHandlerVivid::match(DeviceEnumerator *enumerator) { return false; } REGISTER_PIPELINE_HANDLER(PipelineHandlerVivid) } /* namespace libcamera */ Note that you must register the ``PipelineHandler`` subclass with the pipeline handler factory using the `REGISTER_PIPELINE_HANDLER`_ macro which registers it and creates a global symbol to reference the class and make it available to try and match devices. .. _REGISTER_PIPELINE_HANDLER: http://libcamera.org/api-html/pipeline__handler_8h.html For debugging and testing a pipeline handler during development, you can define a log message category for the pipeline handler. The ``LOG_DEFINE_CATEGORY`` macro and ``LIBCAMERA_LOG_LEVELS`` environment variable help you use the inbuilt libcamera `logging infrastructure`_ that allow for the inspection of internal operations in a user-configurable way. .. _logging infrastructure: http://libcamera.org/api-html/log_8h.html Add the following before the ``PipelineHandlerVivid`` class declaration: .. code-block:: cpp LOG_DEFINE_CATEGORY(VIVID) At this point you need the following includes for logging and pipeline handler features: .. code-block:: cpp #include "libcamera/internal/log.h" #include "libcamera/internal/pipeline_handler.h" Run the following commands: .. code-block:: shell meson build ninja -C build To build the libcamera code base, and confirm that the build system found the new pipeline handler by running: .. code-block:: shell LIBCAMERA_LOG_LEVELS=Camera:0 ./build/src/cam/cam -l And you should see output like the below: .. code-block:: shell DEBUG Camera camera_manager.cpp:148 Found registered pipeline handler 'PipelineHandlerVivid' Matching devices ~~~~~~~~~~~~~~~~ Each pipeline handler registered in libcamera gets tested against the current system configuration, by matching a ``DeviceMatch`` with the system ``DeviceEnumerator``. A successful match makes sure all the requested components have been registered in the system and allows the pipeline handler to be initialized. The main entry point of a pipeline handler is the `match()`_ class member function. When the ``CameraManager`` is started (using the `start()`_ method), all the registered pipeline handlers are iterated and their ``match`` function called with an enumerator of all devices it found on a system. The match method should identify if there are suitable devices available in the ``DeviceEnumerator`` which the pipeline supports, returning ``true`` if it matches a device, and ``false`` if it does not. To do this, construct a `DeviceMatch`_ class with the name of the ``MediaController`` device to match. You can specify the search further by adding specific media entities to the search using the ``.add()`` method on the DeviceMatch. .. _match(): https://www.libcamera.org/api-html/classlibcamera_1_1PipelineHandler.html#a7cd5b652a2414b543ec20ba9dabf61b6 .. _start(): http://libcamera.org/api-html/classlibcamera_1_1CameraManager.html#a49e322880a2a26013bb0076788b298c5 .. _DeviceMatch: http://libcamera.org/api-html/classlibcamera_1_1DeviceMatch.html This example uses search patterns that match vivid, but when developing a new pipeline handler, you should change this value to suit your device identifier. Replace the contents of the ``PipelineHandlerVivid::match`` method with the following: .. code-block:: cpp DeviceMatch dm("vivid"); dm.add("vivid-000-vid-cap"); return false; // Prevent infinite loops for now With the device matching criteria defined, attempt to acquire exclusive access to the matching media controller device with the `acquireMediaDevice`_ method. If the method attempts to acquire a device it has already matched, it returns ``false``. .. _acquireMediaDevice: http://libcamera.org/api-html/classlibcamera_1_1PipelineHandler.html#a77e424fe704e7b26094164b9189e0f84 Add the following below ``dm.add("vivid-000-vid-cap");``: .. code-block:: cpp MediaDevice *media = acquireMediaDevice(enumerator, dm); if (!media) return false; The pipeline handler now needs an additional include. Add the following to the existing include block for device enumeration functionality: .. code-block:: cpp #include "libcamera/internal/device_enumerator.h" At this stage, you should test that the pipeline handler can successfully match the devices, but have not yet added any code to create a Camera which libcamera reports to applications. As a temporary validation step, add a debug print with .. code-block:: cpp LOG(VIVID, Debug) << "Vivid Device Identified"; before the final closing return statement in the ``PipelineHandlerVivid::match`` method for when when the pipeline handler successfully matches the ``MediaDevice`` and ``MediaEntity`` names. Test that the pipeline handler matches and finds a device by rebuilding, and running .. code-block:: shell ninja -C build LIBCAMERA_LOG_LEVELS=Pipeline,VIVID:0 ./build/src/cam/cam -l And you should see output like the below: .. code-block:: shell DEBUG VIVID vivid.cpp:74 Vivid Device Identified Creating camera devices ~~~~~~~~~~~~~~~~~~~~~~~ If the pipeline handler successfully matches with the system it is running on, it can proceed to initialization, by creating all the required instances of the ``V4L2VideoDevice``, ``V4L2Subdevice`` and ``CameraSensor`` hardware abstraction classes. If the Pipeline handler supports an ISP, it can then also Initialise the IPA module before proceeding to the creation of the Camera devices. An image ``Stream`` represents a sequence of images and data of known size and format, stored in application-accessible memory locations. Typical examples of streams are the ISP processed outputs and the raw images captured at the receivers port output. The Pipeline Handler is responsible for defining the set of Streams associated with the Camera. Each Camera has instance-specific data represented using the `CameraData`_ class, which can be extended for the specific needs of the pipeline handler. .. _CameraData: http://libcamera.org/api-html/classlibcamera_1_1CameraData.html To support the Camera we will later register, we need to create a CameraData class that we can implement for our specific Pipeline Handler. Define a new ``VividCameraData()`` class derived from ``CameraData`` by adding the following code before the PipelineHandlerVivid class definition where it will be used: .. code-block:: cpp class VividCameraData : public CameraData { public: VividCameraData(PipelineHandler *pipe, MediaDevice *media) : CameraData(pipe), media_(media), video_(nullptr) { } ~VividCameraData() { delete video_; } int init(); void bufferReady(FrameBuffer *buffer); MediaDevice *media_; V4L2VideoDevice *video_; Stream stream_; }; This example pipeline handler handles a single video device and supports a single stream, represented by the ``VividCameraData`` class members. More complex pipeline handlers might register cameras composed of several video devices and sub-devices, or multiple streams per camera that represent the several components of the image capture pipeline. You should represent all these components in the ``CameraData`` derived class when developing a custom PipelineHandler. In our example VividCameraData we implement an ``init()`` function to prepare the object from our PipelineHandler, however the CameraData class does not specify the interface for initialisation and PipelineHandlers can manage this based on their own needs. Derived CameraData classes are used only by their respective pipeline handlers. The CameraData class stores the context required for each camera instance and is usually responsible for opening all Devices used in the capture pipeline. We can now implement the ``init`` method for our example Pipeline Handler to create a new V4L2 video device from the media entity, which we can specify using the `MediaDevice::getEntityByName`_ method from the MediaDevice. As our example is based upon the simplistic Vivid test device, we only need to open a single capture device named 'vivid-000-vid-cap' by the device. .. _MediaDevice::getEntityByName: http://libcamera.org/api-html/classlibcamera_1_1MediaDevice.html#ad5d9279329ef4987ceece2694b33e230 .. code-block:: cpp int VividCameraData::init() { video_ = new V4L2VideoDevice(media_->getEntityByName("vivid-000-vid-cap")); if (video_->open()) return -ENODEV; return 0; } The CameraData should be created and initialised before we move on to register a new Camera device so we need to construct and initialise our VividCameraData after we have identified our device within PipelineHandlerVivid::match(). The VividCameraData is wrapped by a std::unique_ptr to help manage the lifetime of our CameraData instance. If the camera data initialization fails, return ``false`` to indicate the failure to the ``match()`` method and prevent retrying of the pipeline handler. .. code-block:: cpp std::unique_ptr<VividCameraData> data = std::make_unique<VividCameraData>(this, media); if (data->init()) return false; Once the camera data has been initialized, the Camera device instances and the associated streams have to be registered. Create a set of streams for the camera, which for this device is only one. You create a camera using the static `Camera::create`_ method, passing the pipeline handler, the id of the camera, and the streams available. Then register the camera and its data with the pipeline handler and camera manager using `registerCamera`_. Finally with a successful construction, we return 'true' indicating that the PipelineHandler successfully matched and constructed a device. .. _Camera::create: http://libcamera.org/api-html/classlibcamera_1_1Camera.html#a453740e0d2a2f495048ae307a85a2574 .. _registerCamera: http://libcamera.org/api-html/classlibcamera_1_1PipelineHandler.html#adf02a7f1bbd87aca73c0e8d8e0e6c98b .. code-block:: cpp std::set<Stream *> streams{ &data->stream_ }; std::shared_ptr<Camera> camera = Camera::create(this, data->video_->deviceName(), streams); registerCamera(std::move(camera), std::move(data)); return true; Our match function should now look like the following: .. code-block:: cpp bool PipelineHandlerVivid::match(DeviceEnumerator *enumerator) { DeviceMatch dm("vivid"); dm.add("vivid-000-vid-cap"); MediaDevice *media = acquireMediaDevice(enumerator, dm); if (!media) return false; std::unique_ptr<VividCameraData> data = std::make_unique<VividCameraData>(this, media); /* Locate and open the capture video node. */ if (data->init()) return false; /* Create and register the camera. */ std::set<Stream *> streams{ &data->stream_ }; std::shared_ptr<Camera> camera = Camera::create(this, data->video_->deviceName(), streams); registerCamera(std::move(camera), std::move(data)); return true; } We will need to use our custom CameraData class frequently throughout the pipeline handler, so we add a private convenience helper to our Pipeline handler to obtain and cast the custom CameraData instance from a Camera instance. .. code-block:: cpp private: VividCameraData *cameraData(const Camera *camera) { return static_cast<VividCameraData *>( PipelineHandler::cameraData(camera)); } At this point, you need to add the following new includes to provide the Camera interface, and device interaction interfaces. .. code-block:: cpp #include <libcamera/camera.h> #include "libcamera/internal/media_device.h" #include "libcamera/internal/v4l2_videodevice.h" Registering controls and properties ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The libcamera `controls framework`_ allows an application to configure the streams capture parameters on a per-frame basis and is also used to advertise immutable properties of the ``Camera`` device. The libcamera controls and properties are defined in YAML form which is processed to automatically generate documentation and interfaces. Controls are defined by the src/libcamera/`control_ids.yaml`_ file and camera properties are defined by src/libcamera/`properties_ids.yaml`_. .. _controls framework: http://libcamera.org/api-html/controls_8h.html .. _control_ids.yaml: http://libcamera.org/api-html/control__ids_8h.html .. _properties_ids.yaml: http://libcamera.org/api-html/property__ids_8h.html Pipeline handlers can optionally register the list of controls an application can set as well as a list of immutable camera properties. Being both Camera-specific values, they are represented in the ``CameraData`` base class, which provides two members for this purpose: the `CameraData::controlInfo_`_ and the `CameraData::properties_`_ fields. .. _CameraData::controlInfo_: http://libcamera.org/api-html/classlibcamera_1_1CameraData.html#ab9fecd05c655df6084a2233872144a52 .. _CameraData::properties_: http://libcamera.org/api-html/classlibcamera_1_1CameraData.html#a84002c29f45bd35566c172bb65e7ec0b The ``controlInfo_`` field represents a map of ``ControlId`` instances associated with the limits of valid values supported for the control. More information can be found in the `ControlInfoMap`_ class documentation. .. _ControlInfoMap: http://libcamera.org/api-html/classlibcamera_1_1ControlInfoMap.html Pipeline handlers register controls to expose the tunable device and IPA parameters to applications. Our example pipeline handler only exposes trivial controls of the video device, by registering a ``ControlId`` instance with associated values for each supported V4L2 control but demonstrates the mapping of V4L2 Controls to libcamera ControlIDs. Complete the initialization of the ``VividCameraData`` class by adding the following code to the ``VividCameraData::init()`` method to initialise the controls. For more complex control configurations, this could of course be broken out to a separate function, but for now we just initialise the small set inline in our CameraData init: .. code-block:: cpp /* Initialise the supported controls. */ const ControlInfoMap &controls = video_->controls(); ControlInfoMap::Map ctrls; for (const auto &ctrl : controls) { const ControlId *id; ControlInfo info; switch (ctrl.first->id()) { case V4L2_CID_BRIGHTNESS: id = &controls::Brightness; info = ControlInfo{ { -1.0f }, { 1.0f }, { 0.0f } }; break; case V4L2_CID_CONTRAST: id = &controls::Contrast; info = ControlInfo{ { 0.0f }, { 2.0f }, { 1.0f } }; break; case V4L2_CID_SATURATION: id = &controls::Saturation; info = ControlInfo{ { 0.0f }, { 2.0f }, { 1.0f } }; break; default: continue; } ctrls.emplace(id, info); } controlInfo_ = std::move(ctrls); The ``properties_`` field is a list of ``ControlId`` instances associated with immutable values, which represent static characteristics that can be used by applications to identify camera devices in the system. Properties can be registered by inspecting the values of V4L2 controls from the video devices and camera sensor (for example to retrieve the position and orientation of a camera) or to express other immutable characteristics. The example pipeline handler does not register any property, but examples are available in the libcamera code base. .. TODO: Add a property example to the pipeline handler. At least the model. At this point you need to add the following includes to the top of the file for handling controls: .. code-block:: cpp #include <libcamera/controls.h> #include <libcamera/control_ids.h> Generating a default configuration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Once ``Camera`` devices and the associated ``Streams`` have been registered, an application can proceed to acquire and configure the camera to prepare it for a frame capture session. Applications specify the requested configuration by assigning a ``StreamConfiguration`` instance to each stream they want to enable which expresses the desired image size and pixel format. The stream configurations are grouped in a ``CameraConfiguration`` which is inspected by the pipeline handler and validated to adjust it to a supported configuration. This may involve adjusting the formats or image sizes or alignments for example to match the capabilities of the device. Applications may choose to repeat validation stages, adjusting paramters until a set of validated StreamConfigurations are returned that is acceptable for the applications needs. When the pipeline handler receives a valid camera configuration it can use the image stream configurations to apply settings to the hardware devices. This configuration and validation process is managed with another Pipeline specific class derived from a common base implementation and interface. To support validation in our example pipeline handler, Create a new class called ``VividCameraConfiguration`` derived from the base `CameraConfiguration`_ class which we can implement and use within our ``PipelineHandlerVivid`` class. .. _CameraConfiguration: http://libcamera.org/api-html/classlibcamera_1_1CameraConfiguration.html The derived ``CameraConfiguration`` class must override the base class ``validate()`` function, where the stream configuration inspection and adjustment happens. .. code-block:: cpp class VividCameraConfiguration : public CameraConfiguration { public: VividCameraConfiguration(); Status validate() override; }; VividCameraConfiguration::VividCameraConfiguration() : CameraConfiguration() { } Applications generate a ``CameraConfiguration`` instance by calling the `Camera::generateConfiguration()`_ function, which calls into the pipeline implementation of the overridden `PipelineHandler::generateConfiguration()`_ method. .. _Camera::generateConfiguration(): http://libcamera.org/api-html/classlibcamera_1_1Camera.html#a25c80eb7fc9b1cf32692ce0c7f09991d .. _PipelineHandler::generateConfiguration(): http://libcamera.org/api-html/classlibcamera_1_1PipelineHandler.html#a7932e87735695500ce1f8c7ae449b65b Configurations are generated by receiving a list of ``StreamRoles`` instances, which libcamera uses as predefined ways an application intends to use a camera (You can read the full list in the `StreamRole API`_ documentation). These are optional hints on how an application intends to use a stream, and a pipeline handler should return an ideal configuration for each role that is requested. .. _StreamRole API: http://libcamera.org/api-html/stream_8h.html#file_a295d1f5e7828d95c0b0aabc0a8baac03 In the pipeline handler ``generateConfiguration`` implementation, remove the ``return nullptr;``, create a new instance of the ``CameraConfiguration`` derived class, and assign it to a base class pointer. .. code-block:: cpp VividCameraData *data = cameraData(camera); CameraConfiguration *config = new VividCameraConfiguration(); A ``CameraConfiguration`` is specific to each pipeline, so you can only create it from the pipeline handler code path. Applications can also generate an empty configuration and add desired stream configurations manually. Pipelines must allow for this by returning an empty configuration if no roles are requested. To support this in our PipelineHandlerVivid, next add the following check in ``generateConfiguration`` after the Cameraconfiguration has been constructed: .. code-block:: cpp if (roles.empty()) return config; A production pipeline handler should generate the ``StreamConfiguration`` for all the appropriate stream roles a camera device supports. For this simpler example (with only one stream), the pipeline handler always returns the same configuration, inferred from the underlying V4L2VideoDevice. How it does this is shown below, but examination of the more full-featured pipelines for IPU3, RKISP1 and RaspberryPi are recommend to explore more complex examples. To generate a ``StreamConfiguration``, you need a list of pixel formats and frame sizes which supported outputs of the stream. You can fetch a map of the ``V4LPixelFormat`` and ``SizeRange`` supported by the underlying output device, but the pipeline handler needs to convert this to a ``libcamera::PixelFormat`` type to pass to applications. We do this here using ``std::transform`` to convert the formats and populate a new ``PixelFormat`` map as shown below. Continue adding the following code example to our ``generateConfiguration`` implementation. .. code-block:: cpp std::map<V4L2PixelFormat, std::vector<SizeRange>> v4l2Formats = data->video_->formats(); std::map<PixelFormat, std::vector<SizeRange>> deviceFormats; std::transform(v4l2Formats.begin(), v4l2Formats.end(), std::inserter(deviceFormats, deviceFormats.begin()), [&](const decltype(v4l2Formats)::value_type &format) { return decltype(deviceFormats)::value_type{ format.first.toPixelFormat(), format.second }; }); The `StreamFormats`_ class holds information about the pixel formats and frame sizes that a stream can support. The class groups size information by the pixel format, which can produce it. .. _StreamFormats: http://libcamera.org/api-html/classlibcamera_1_1StreamFormats.html The code below uses the ``StreamFormats`` class to represent all of the supported pixel formats, associated with a list of frame sizes. It then generates a supported StreamConfiguration to model the information an application can use to configure a single stream. Continue adding the following code to support this: .. code-block:: cpp StreamFormats formats(deviceFormats); StreamConfiguration cfg(formats); As well as a list of supported StreamFormats, the StreamConfiguration is also expected to provide an initialsed default configuration. This may be arbitrary, but depending on use case you may which to select an output that matches the Sensor output, or prefer a pixelformat which might provide higher performance on the hardware. The bufferCount represents the number of buffers required to support functional continuous processing on this stream. .. code-block:: cpp cfg.pixelFormat = formats::BGR888; cfg.size = { 1280, 720 }; cfg.bufferCount = 4; Finally add each ``StreamConfiguration`` generated to the ``CameraConfiguration``, and ensure that it has been validated before returning it to the application. With only a single supported stream, this code adds only a single StreamConfiguration however a StreamConfiguration should be added for each supported role in a device that can handle more streams. Add the following code to complete the implementation of ``generateConfiguration``: .. code-block:: cpp config->addConfiguration(cfg); config->validate(); return config; To validate a camera configuration, a pipeline handler must implement the `CameraConfiguration::validate()`_ method in it's derived class to inspect all the stream configuration associated to it, make any adjustments required to make the configuration valid, and return the validation status. If changes are made, it marks the configuration as ``Adjusted``, however if the requested configuration is not supported and cannot be adjusted it shall be refused and marked as ``Invalid``. .. _CameraConfiguration::validate(): http://libcamera.org/api-html/classlibcamera_1_1CameraConfiguration.html#a29f8f263384c6149775b6011c7397093 The validation phase makes sure all the platform-specific constraints are respected by the requested configuration. The most trivial examples being making sure the requested image formats are supported and the image alignment restrictions adhered to. The pipeline handler specific implementation of ``validate()`` shall inspect all the configuration parameters received and never assume they are correct, as applications are free to change the requested stream parameters after the configuration has been generated. Again, this example pipeline handler is simpler, look at the more complex


context:
space:
mode: