Pipeline Handler Writers Guide — libcamera v0.0.5 documentation

# 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:

- 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 described above. Below is a brief overview of each of those:

- MediaDevice: Instances of this class are associated with a kernel media controller device and its connected objects.

- DeviceEnumerator: 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: Describes a media device search pattern using entity names, or other properties.

- V4L2VideoDevice: Models an instance of a V4L2 video device constructed with the path to a V4L2 video device node.

- V4L2SubDevice: Provides an API to the sub-devices that model the hardware components of a V4L2 device.

- CameraSensor: Abstracts camera sensor handling by hiding the details of the V4L2 subdevice kernel API and caching sensor information.

- Camera::Private: Represents device-specific data a pipeline handler associates to each Camera instance.

- StreamConfiguration: Models the current configuration of an image stream produced by the camera by reporting its format and sizes.

- CameraConfiguration: 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: The interface to the Image Processing Algorithm (IPA) module which performs the computation of the image processing pipeline tuning parameters.

- ControlList: 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.

### 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:

    # 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:

    meson build -Dpipelines=ipu3,uvcvideo,vivid

Read the Meson build configuration documentation for more information on configuring a build directory.

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`.

    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 implementations for the overridden class members.

    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.

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.

Add the following before the `PipelineHandlerVivid` class declaration:

    LOG_DEFINE_CATEGORY(VIVID)

At this point you need the following includes for logging and pipeline handler features:

    #include <libcamera/base/log.h>

    #include "libcamera/internal/pipeline_handler.h"

Run the following commands:

    meson build
    ninja -C build

To build the libcamera code base, and confirm that the build system found the new pipeline handler by running:

    LIBCAMERA_LOG_LEVELS=Camera:0 ./build/src/cam/cam -l

And you should see output like the below:

    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() function), 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 function 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()` function on the DeviceMatch.

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` function with the following:

    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 function. If the function attempts to acquire a device it has already matched, it returns `false`.

Add the following below `dm.add("vivid-000-vid-cap");`:

    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:

    #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

    LOG(VIVID, Debug) << "Vivid Device Identified";

before the final closing return statement in the `PipelineHandlerVivid::match` function 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

    ninja -C build
    LIBCAMERA_LOG_LEVELS=Pipeline,VIVID:0 ./build/src/cam/cam -l

And you should see output like the below:

    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 Camera::Private class, which can be extended for the specific needs of the pipeline handler.

To support the Camera we will later register, we need to create a Camera::Private class that we can implement for our specific Pipeline Handler.

Define a new `VividCameraPrivate()` class derived from `Camera::Private` by adding the following code before the PipelineHandlerVivid class definition where it will be used:

    class VividCameraData : public Camera::Private
    {
    public:
           VividCameraData(PipelineHandler *pipe, MediaDevice *media)
                 : Camera::Private(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 `Camera::Private` 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 Camera::Private class does not specify the interface for initialisation and PipelineHandlers can manage this based on their own needs. Derived Camera::Private classes are used only by their respective pipeline handlers.

The Camera::Private 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` function for our example Pipeline Handler to create a new V4L2 video device from the media entity, which we can specify using the MediaDevice::getEntityByName function 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.

    int VividCameraData::init()
    {
           video_ = new V4L2VideoDevice(media_->getEntityByName("vivid-000-vid-cap"));
           if (video_->open())
                 return -ENODEV;

           return 0;
    }

The VividCameraData 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 the instance.

If the camera data initialization fails, return `false` to indicate the failure to the `match()` function and prevent retrying of the pipeline handler.

    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 function, passing the Camera::Private instance, the id of the camera, and the streams available. Then register the camera 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.

    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:

    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_ };
         const std::string &id = data->video_->deviceName();
         std::shared_ptr<Camera> camera = Camera::create(data.release(), id, streams);
         registerCamera(std::move(camera));

         return true;
    }

We will need to use our custom VividCameraData class frequently throughout the pipeline handler, so we add a private convenience helper to our Pipeline handler to obtain and cast the custom VividCameraData instance from a Camera::Private instance.

    private:
        VividCameraData *cameraData(Camera *camera)
        {
                return static_cast<VividCameraData *>(camera->_d());
        }

At this point, you need to add the following new includes to provide the Camera interface, and device interaction interfaces.

    #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.

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 `Camera::Private` base class, which provides two members for this purpose: the Camera::Private::controlInfo_ and the Camera::Private::properties_ fields.

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.

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()` function 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 VividCameraData init:

    /* 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.

At this point you need to add the following includes to the top of the file for handling controls:

    #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 parameters 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.

The derived `CameraConfiguration` class must override the base class `validate()` function, where the stream configuration inspection and adjustment happens.

    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() function.

Configurations are generated by receiving a list of `StreamRole` 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.

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.

    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:

    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 recommended to explore more complex examples.

To generate a `StreamConfiguration`, you need a list of pixel formats and frame sizes which are supported as 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.

    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.

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:

    StreamFormats formats(deviceFormats);
    StreamConfiguration cfg(formats);

As well as a list of supported StreamFormats, the StreamConfiguration is also expected to provide an initialised default configuration. This may be arbitrary, but depending on use case you may wish 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.

    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`:

    config->addConfiguration(cfg);

    config->validate();

    return config;

To validate a camera configuration, a pipeline handler must implement the CameraConfiguration::validate() function in its 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`.

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 implementations for a realistic example.

Add the following function implementation to your file:

    CameraConfiguration::Status VividCameraConfiguration::validate()
    {
            Status status = Valid;

            if (config_.empty())
                   return Invalid;

            if (config_.size() > 1) {
                   config_.resize(1);
                   status = Adjusted;
            }

            StreamConfiguration &cfg = config_[0];

            const std::vector<libcamera::PixelFormat> formats = cfg.formats().pixelformats();
            if (std::find(formats.begin(), formats.end(), cfg.pixelFormat) == formats.end()) {
                   cfg.pixelFormat = cfg.formats().pixelformats()[0];
                   LOG(VIVID, Debug) << "Adjusting format to " << cfg.pixelFormat.toString();
                   status = Adjusted;
            }

            cfg.bufferCount = 4;

            return status;
    }

Now that we are handling the `PixelFormat` type, we also need to add `#include <libcamera/formats.h>` to the include section before we rebuild the codebase, and test:

    ninja -C build
    LIBCAMERA_LOG_LEVELS=Pipeline,VIVID:0 ./build/src/cam/cam -c vivid -I

You should see the following output showing the capabilites of our new pipeline handler, and showing that our configurations have been generated:

    Using camera vivid
    0: 1280x720-BGR888
    * Pixelformat: NV21 (320x180)-(3840x2160)/(+0,+0)
    - 320x180
    - 640x360
    - 640x480
    - 1280x720
    - 1920x1080
    - 3840x2160
    * Pixelformat: NV12 (320x180)-(3840x2160)/(+0,+0)
    - 320x180
    - 640x360
    - 640x480
    - 1280x720
    - 1920x1080
    - 3840x2160
    * Pixelformat: BGRA8888 (320x180)-(3840x2160)/(+0,+0)
    - 320x180
    - 640x360
    - 640x480
    - 1280x720
    - 1920x1080
    - 3840x2160
    * Pixelformat: RGBA8888 (320x180)-(3840x2160)/(+0,+0)
    - 320x180
    - 640x360
    - 640x480
    - 1280x720
    - 1920x1080
    - 3840x2160

### Configuring a device

With the configuration generated, and optionally modified and re-validated, a pipeline handler needs a function that allows an application to apply a configuration to the hardware devices.

The PipelineHandler::configure() function receives a valid CameraConfiguration and applies the settings to hardware devices, using its parameters to prepare a device for a streaming session with the desired properties.

Replace the contents of the stubbed `PipelineHandlerVivid::configure` function with the following to obtain the camera data and stream configuration. This pipeline handler supports only a single stream, so it directly obtains the first `StreamConfiguration` from the camera configuration. A pipeline handler with multiple streams should inspect each StreamConfiguration and configure the system accordingly.

    VividCameraData *data = cameraData(camera);
    StreamConfiguration &cfg = config->at(0);
    int ret;

The Vivid capture device is a V4L2 video device, so we use a V4L2DeviceFormat with the fourcc and size attributes to apply directly to the capture device node. The fourcc attribute is a V4L2PixelFormat and differs from the `libcamera::PixelFormat`. Converting the format requires knowledge of the plane configuration for multiplanar formats, so you must explicitly convert it using the helper `V4L2VideoDevice::toV4L2PixelFormat()` provided by the V4L2VideoDevice instance that the format will be applied on.

Add the following code beneath the code from above:

    V4L2DeviceFormat format = {};
    format.fourcc = data->video_->toV4L2PixelFormat(cfg.pixelFormat);
    format.size = cfg.size;

Set the video device format defined above using the V4L2VideoDevice::setFormat() function. You should check if the kernel driver has adjusted the format, as this shows the pipeline handler has failed to handle the validation stages correctly, and the configure operation shall also fail.

Continue the implementation with the following code:

    ret = data->video_->setFormat(&format);
    if (ret)
           return ret;

    if (format.size != cfg.size ||
           format.fourcc != data->video_->toV4L2PixelFormat(cfg.pixelFormat))
           return -EINVAL;

Finally, store and set stream-specific data reflecting the state of the stream. Associate the configuration with the stream by using the StreamConfiguration::setStream function, and set the values of individual stream configuration members as required.

Complete the configure implementation with the following code:

    cfg.setStream(&data->stream_);
    cfg.stride = format.planes[0].bpl;

    return 0;

### Initializing device controls

Pipeline handlers can optionally initialize the video devices and camera sensor controls at system configuration time, to make sure they are defaulted to sane values. Handling of device controls is again performed using the libcamera controls framework.

This section is particularly specific to Vivid as it sets the initial values of controls to match Vivid Controls defined by the kernel driver. You won’t need any of the code below for your pipeline handler, but it’s included as an example of how to implement functionality your pipeline handler might need.

We need to add some definitions at the top of the file for convenience. These come directly from the kernel sources:

    #define VIVID_CID_VIVID_BASE            (0x00f00000 | 0xf000)
    #define VIVID_CID_VIVID_CLASS           (0x00f00000 | 1)
    #define VIVID_CID_TEST_PATTERN          (VIVID_CID_VIVID_BASE  + 0)
    #define VIVID_CID_OSD_TEXT_MODE         (VIVID_CID_VIVID_BASE  + 1)
    #define VIVID_CID_HOR_MOVEMENT          (VIVID_CID_VIVID_BASE  + 2)

We can now use the V4L2 control IDs to prepare a list of controls with the ControlList class, and set them using the ControlList::set() function.

In our pipeline `configure` function, add the following code after the format has been set and checked to initialise the ControlList and apply it to the device:

    ControlList controls(data->video_->controls());
    controls.set(VIVID_CID_TEST_PATTERN, 0);
    controls.set(VIVID_CID_OSD_TEXT_MODE, 0);

    controls.set(V4L2_CID_BRIGHTNESS, 128);
    controls.set(V4L2_CID_CONTRAST, 128);
    controls.set(V4L2_CID_SATURATION, 128);

    controls.set(VIVID_CID_HOR_MOVEMENT, 5);

    ret = data->video_->setControls(&controls);
    if (ret) {
           LOG(VIVID, Error) << "Failed to set controls: " << ret;
           return ret < 0 ? ret : -EINVAL;
    }

These controls configure VIVID to use a default test pattern, and enable all on-screen display text, while configuring sensible brightness, contrast and saturation values. Use the `controls.set` function to set individual controls.

### Buffer handling and stream control

Once the system has been configured with the requested parameters, it is now possible for applications to start capturing frames from the `Camera` device.

libcamera implements a per-frame request capture model, realized by queueing `Request` instances to a `Camera` object. Before applications can start submitting capture requests the capture pipeline needs to be prepared to deliver frames as soon as they are requested. Memory should be initialized and made available to the devices which have to be started and ready to produce images. At the end of a capture session the `Camera` device needs to be stopped, to gracefully clean up any allocated memory and stop the hardware devices. Pipeline handlers implement two functions for these purposes, the `start()` and `stop()` functions.

The memory initialization phase that happens at `start()` time serves to configure video devices to be able to use memory buffers exported as dma-buf file descriptors. From the pipeline handlers perspective the video devices that provide application facing streams always act as memory importers which use, in V4L2 terminology, buffers of V4L2_MEMORY_DMABUF memory type.

libcamera also provides an API to allocate and export memory to applications realized through the exportFrameBuffers function and the FrameBufferAllocator class which will be presented later.

Please refer to the V4L2VideoDevice API documentation, specifically the allocateBuffers, importBuffers and exportBuffers functions for a detailed description of the video device memory management.

Video memory buffers are represented in libcamera by the FrameBuffer class. A `FrameBuffer` instance has to be associated to each `Stream` which is part of a capture `Request`. Pipeline handlers should prepare the capture devices by importing the dma-buf file descriptors it needs to operate on. This operation is performed by using the `V4L2VideoDevice` API, which provides an `importBuffers()` function that prepares the video device accordingly.

Implement the pipeline handler `start()` function by replacing the stub version with the following code:

    VividCameraData *data = cameraData(camera);
    unsigned int count = data->stream_.configuration().bufferCount;

    int ret = data->video_->importBuffers(count);
    if (ret < 0)
          return ret;

    return 0;

During the startup phase pipeline handlers allocate any internal buffer pool required to transfer data between different components of the image capture pipeline, for example, between the CSI-2 receiver and the ISP input. The example pipeline does not require any internal pool, but examples are available in more complex pipeline handlers in the libcamera code base.

Applications might want to use memory allocated in the video devices instead of allocating it from other parts of the system. libcamera provides an abstraction to assist with this task in the FrameBufferAllocator class. The `FrameBufferAllocator` reserves memory for a `Stream` in the video device and exports it as dma-buf file descriptors. From this point on, the allocated `FrameBuffer` are associated to `Stream` instances in a `Request` and then imported by the pipeline hander in exactly the same fashion as if they were allocated elsewhere.

Pipeline handlers support the `FrameBufferAllocator` operations by implementing the exportFrameBuffers function, which will allocate memory in the video device associated with a stream and export it.

Implement the `exportFrameBuffers` stub function with the following code to handle this:

    unsigned int count = stream->configuration().bufferCount;
    VividCameraData *data = cameraData(camera);

    return data->video_->exportBuffers(count, buffers);

Once memory has been properly setup, the video devices can be started, to prepare for capture operations. Complete the `start` function implementation with the following code:

    ret = data->video_->streamOn();
    if (ret < 0) {
           data->video_->releaseBuffers();
           return ret;
    }

    return 0;

The function starts the video device associated with the stream with the streamOn function. If the call fails, the error value is propagated to the caller and the releaseBuffers function releases any buffers to leave the device in a consistent state. If your pipeline handler uses any image processing algorithms, or other devices you should also stop them.

Of course we also need to handle the corresponding actions to stop streaming on a device, Add the following to the `stop` function, to stop the stream with the streamOff function and release all buffers.

    VividCameraData *data = cameraData(camera);
    data->video_->streamOff();
    data->video_->releaseBuffers();

### Queuing requests between applications and hardware

libcamera implements a streaming model based on capture requests queued by an application to the `Camera` device. Each request contains at least one `Stream` instance with an associated `FrameBuffer` object.

When an application sends a capture request, the pipeline handler identifies which video devices have to be provided with buffers to generate a frame from the enabled streams.

This example pipeline handler identifies the buffer using the findBuffer helper from the only supported stream and queues it to the capture device directly with the queueBuffer function provided by the V4L2VideoDevice.

Replace the stubbed contents of `queueRequestDevice` with the following:

    VividCameraData *data = cameraData(camera);
    FrameBuffer *buffer = request->findBuffer(&data->stream_);
    if (!buffer) {
           LOG(VIVID, Error)
                   << "Attempt to queue request with invalid stream";

           return -ENOENT;
    }

    int ret = data->video_->queueBuffer(buffer);
    if (ret < 0)
           return ret;

    return 0;

### Processing controls

Capture requests not only contain streams and memory buffers, but can optionally contain a list of controls the application has set to modify the streaming parameters.

Applications can set controls registered by the pipeline handler in the initialization phase, as explained in the Registering controls and properties section.

Implement a `processControls` function above the `queueRequestDevice` function to loop through the control list received with each request, and inspect the control values. Controls may need to be converted between the libcamera control range definitions and their corresponding values on the device before being set.

    int PipelineHandlerVivid::processControls(VividCameraData *data, Request *request)
    {
           ControlList controls(data->video_->controls());

           for (auto it : request->controls()) {
                  unsigned int id = it.first;
                  unsigned int offset;
                  uint32_t cid;

                  if (id == controls::Brightness) {
                         cid = V4L2_CID_BRIGHTNESS;
                         offset = 128;
                  } else if (id == controls::Contrast) {
                         cid = V4L2_CID_CONTRAST;
                         offset = 0;
                  } else if (id == controls::Saturation) {
                         cid = V4L2_CID_SATURATION;
                         offset = 0;
                  } else {
                         continue;
                  }

                  int32_t value = lroundf(it.second.get<float>() * 128 + offset);
                  controls.set(cid, std::clamp(value, 0, 255));
           }

           for (const auto &ctrl : controls)
                  LOG(VIVID, Debug)
                         << "Setting control " << utils::hex(ctrl.first)
                         << " to " << ctrl.second.toString();

           int ret = data->video_->setControls(&controls);
           if (ret) {
                  LOG(VIVID, Error) << "Failed to set controls: " << ret;
                  return ret < 0 ? ret : -EINVAL;
           }

           return ret;
    }

Declare the function prototype for the `processControls` function within the private `PipelineHandlerVivid` class members, as it is only used internally as a helper when processing Requests.

    private:
         int processControls(VividCameraData *data, Request *request);

A pipeline handler is responsible for applying controls provided in a Request to the relevant hardware devices. This could be directly on the capture device, or where appropriate by setting controls on V4L2Subdevices directly. Each pipeline handler is responsible for understanding the correct procedure for applying controls to the device they support.

This example pipeline handler applies controls during the queueRequestDevice function for each request, and applies them to the capture device through the capture node.

In the `queueRequestDevice` function, replace the following:

    int ret = data->video_->queueBuffer(buffer);
    if (ret < 0)
         return ret;

With the following code:

    int ret = processControls(data, request);
    if (ret < 0)
         return ret;

    ret = data->video_->queueBuffer(buffer);
    if (ret < 0)
         return ret;

We also need to add the following include directive to support the control value translation operations:

    #include <math.h>

### Frame completion and event handling

libcamera implements a signals and slots mechanism (similar to Qt Signals and Slots) to connect event sources with callbacks to handle them.

As a general summary, a `Slot` can be connected to a `Signal`, which when emitted triggers the execution of the connected slots. A detailed description of the libcamera implementation is available in the libcamera Signal and Slot classes documentation.

In order to notify applications about the availability of new frames and data, the `Camera` device exposes two `Signals` to which applications can connect to be notified of frame completion events. The `bufferComplete` signal serves to report to applications the completion event of a single `Stream` part of a `Request`, while the `requestComplete` signal notifies the completion of all the `Streams` and data submitted as part of a request. This mechanism allows implementation of partial request completion, which allows an application to inspect completed buffers associated with the single streams without waiting for all of them to be ready.

The `bufferComplete` and `requestComplete` signals are emitted by the `Camera` device upon notifications received from the pipeline handler, which tracks the buffers and request completion status.

The single buffer completion notification is implemented by pipeline handlers by connecting the `bufferReady` signal of the capture devices they have queued buffers to, to a member function slot that handles processing of the completed frames. When a buffer is ready, the pipeline handler must propagate the completion of that buffer to the Camera by using the PipelineHandler base class `completeBuffer` function. When all of the buffers referenced by a `Request` have been completed, the pipeline handler must again notify the `Camera` using the PipelineHandler base class `completeRequest` function. The PipelineHandler class implementation makes sure the request completion notifications are delivered to applications in the same order as they have been submitted.

Returning to the `int VividCameraData::init()` function, add the following above the closing `return 0;` to connect the pipeline handler `bufferReady` function to the V4L2 device buffer signal.

    video_->bufferReady.connect(this, &VividCameraData::bufferReady);

Create the matching `VividCameraData::bufferReady` function after your VividCameradata::init() implementation.

The `bufferReady` function obtains the request from the buffer using the `request` function, and notifies the `Camera` that the buffer and request are completed. In this simpler pipeline handler, there is only one stream, so it completes the request immediately. You can find a more complex example of event handling with supporting multiple streams in the libcamera code-base.

    void VividCameraData::bufferReady(FrameBuffer *buffer)
    {
           Request *request = buffer->request();

           pipe_->completeBuffer(request, buffer);
           pipe_->completeRequest(request);
    }

### Testing a pipeline handler

Once you’ve built the pipeline handler, we can rebuild the code base, and test capture through the pipeline through both of the cam and qcam utilities.

    ninja -C build
    ./build/src/cam/cam -c vivid -C5

To test that the pipeline handler can detect a device, and capture input.

Running the command above outputs (a lot of) information about pixel formats, and then starts capturing frame data, and should provide an output such as the following:

    user@dev:/home/libcamera$ ./build/src/cam/cam -c vivid -C5
    [42:34:08.573066847] [186470]  INFO IPAManager ipa_manager.cpp:136 libcamera is not installed. Adding '/home/libcamera/build/src/ipa' to the IPA search path
    [42:34:08.575908115] [186470]  INFO Camera camera_manager.cpp:287 libcamera v0.0.11+876-7b27d262
    [42:34:08.610334268] [186471]  INFO IPAProxy ipa_proxy.cpp:122 libcamera is not installed. Loading IPA configuration from '/home/libcamera/src/ipa/vimc/data'
    Using camera vivid
    [42:34:08.618462130] [186470]  WARN V4L2 v4l2_pixelformat.cpp:176 Unsupported V4L2 pixel format Y10
    ... <remaining Unsupported V4L2 pixel format warnings can be ignored>
    [42:34:08.619901297] [186470]  INFO Camera camera.cpp:793 configuring streams: (0) 1280x720-BGR888
    Capture 5 frames
    fps: 0.00 stream0 seq: 000000 bytesused: 2764800
    fps: 4.98 stream0 seq: 000001 bytesused: 2764800
    fps: 5.00 stream0 seq: 000002 bytesused: 2764800
    fps: 5.03 stream0 seq: 000003 bytesused: 2764800
    fps: 5.03 stream0 seq: 000004 bytesused: 2764800

This demonstrates that the pipeline handler is successfully capturing frames, but it is helpful to see the visual output and validate the images are being processed correctly. The libcamera project also implements a Qt based application which will render the frames in a window for visual inspection:

    ./build/src/qcam/qcam -c vivid