libcamera/vivid.git - libcamera pipeline handler for VIVID

diff options

Diffstat (limited to 'src/gstreamer/meson.build')

0 files changed, 0 insertions, 0 deletions

/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2018, Google Inc. * * pipeline_handler.cpp - Pipeline handler infrastructure */ #include "libcamera/internal/pipeline_handler.h" #include <sys/sysmacros.h> #include <libcamera/buffer.h> #include <libcamera/camera.h> #include <libcamera/camera_manager.h> #include <libcamera/base/utils.h> #include "libcamera/internal/device_enumerator.h" #include "libcamera/internal/log.h" #include "libcamera/internal/media_device.h" #include "libcamera/internal/tracepoints.h" /** * \file pipeline_handler.h * \brief Create pipelines and cameras from a set of media devices * * Each pipeline supported by libcamera needs to be backed by a pipeline * handler implementation that operate on a set of media devices. The pipeline * handler is responsible for matching the media devices it requires with the * devices present in the system, and once all those devices can be acquired, * create corresponding Camera instances. * * Every subclass of PipelineHandler shall be registered with libcamera using * the REGISTER_PIPELINE_HANDLER() macro. */ namespace libcamera { LOG_DEFINE_CATEGORY(Pipeline) /** * \class CameraData * \brief Base class for platform-specific data associated with a camera * * The CameraData base abstract class represents platform specific-data * a pipeline handler might want to associate with a Camera to access them * at a later time. * * Pipeline handlers are expected to extend this base class with platform * specific implementation, associate instances of the derived classes * using the registerCamera() method, and access them at a later time * with cameraData(). */ /** * \fn CameraData::CameraData(PipelineHandler *pipe) * \brief Construct a CameraData instance for the given pipeline handler * \param[in] pipe The pipeline handler * * The reference to the pipeline handler is stored internally, the caller shall * guarantee that the pointer remains valid as long as the CameraData instance * exists. */ /** * \var CameraData::pipe_ * \brief The pipeline handler related to this CameraData instance * * The pipe_ pointer provides access to the PipelineHandler object that this * instance is related to. It is set when the CameraData instance is created * and remains valid until the instance is destroyed. */ /** * \var CameraData::queuedRequests_ * \brief The list of queued and not yet completed request * * The list of queued request is used to track requests queued in order to * ensure completion of all requests when the pipeline handler is stopped. * * \sa PipelineHandler::queueRequest(), PipelineHandler::stop(), * PipelineHandler::completeRequest() */ /** * \var CameraData::controlInfo_ * \brief The set of controls supported by the camera * * The control information shall be initialised by the pipeline handler when * creating the camera, and shall not be modified afterwards. */ /** * \var CameraData::properties_ * \brief The list of properties supported by the camera * * The list of camera properties shall be initialised by the pipeline handler * when creating the camera, and shall not be modified afterwards. */ /** * \var CameraData::requestSequence_ * \brief The queuing sequence of the request * * When requests are queued, they are given a per-camera sequence number to * facilitate debugging of internal request usage. * * The requestSequence_ tracks the number of requests queued to a camera * over its lifetime. */ /** * \class PipelineHandler * \brief Create and manage cameras based on a set of media devices * * The PipelineHandler matches the media devices provided by a DeviceEnumerator * with the pipelines it supports and creates corresponding Camera devices. * * Pipeline handler instances are reference-counted through std::shared_ptr<>. * They implement std::enable_shared_from_this<> in order to create new * std::shared_ptr<> in code paths originating from member functions of the * PipelineHandler class where only the 'this' pointer is available. */ /** * \brief Construct a PipelineHandler instance * \param[in] manager The camera manager * * In order to honour the std::enable_shared_from_this<> contract, * PipelineHandler instances shall never be constructed manually, but always * through the PipelineHandlerFactory::create() method implemented by the * respective factories. */ PipelineHandler::PipelineHandler(CameraManager *manager) : manager_(manager) { } PipelineHandler::~PipelineHandler() { for (std::shared_ptr<MediaDevice> media : mediaDevices_) media->release(); } /** * \fn PipelineHandler::match(DeviceEnumerator *enumerator) * \brief Match media devices and create camera instances * \param[in] enumerator The enumerator providing all media devices found in the * system * * This function is the main entry point of the pipeline handler. It is called * by the camera manager with the \a enumerator passed as an argument. It shall * acquire from the \a enumerator all the media devices it needs for a single * pipeline, create one or multiple Camera instances and register them with the * camera manager. * * If all media devices needed by the pipeline handler are found, they must all * be acquired by a call to MediaDevice::acquire(). This function shall then * create the corresponding Camera instances, store them internally, and return * true. Otherwise it shall not acquire any media device (or shall release all * the media devices is has acquired by calling MediaDevice::release()) and * return false. * * If multiple instances of a pipeline are available in the system, the * PipelineHandler class will be instantiated once per instance, and its match() * function called for every instance. Each call shall acquire media devices for * one pipeline instance, until all compatible media devices are exhausted. * * If this function returns true, a new instance of the pipeline handler will * be created and its match() function called. * * \context This function is called from the CameraManager thread. * * \return true if media devices have been acquired and camera instances * created, or false otherwise */ /** * \brief Search and acquire a MediaDevice matching a device pattern * \param[in] enumerator Enumerator containing all media devices in the system * \param[in] dm Device match pattern * * Search the device \a enumerator for an available media device matching the * device match pattern \a dm. Matching media device that have previously been * acquired by MediaDevice::acquire() are not considered. If a match is found, * the media device is acquired and returned. The caller shall not release the * device explicitly, it will be automatically released when the pipeline * handler is destroyed. * * \context This function shall be called from the CameraManager thread. * * \return A pointer to the matching MediaDevice, or nullptr if no match is found */ MediaDevice *PipelineHandler::acquireMediaDevice(DeviceEnumerator *enumerator, const DeviceMatch &dm) { std::shared_ptr<MediaDevice> media = enumerator->search(dm); if (!media) return nullptr; if (!media->acquire()) return nullptr; mediaDevices_.push_back(media); return media.get(); } /** * \brief Lock all media devices acquired by the pipeline * * This method shall not be called from pipeline handler implementation, as the * Camera class handles locking directly. * * \context This function is \threadsafe. * * \return True if the devices could be locked, false otherwise * \sa unlock() * \sa MediaDevice::lock() */ bool PipelineHandler::lock() { for (std::shared_ptr<MediaDevice> &media : mediaDevices_) { if (!media->lock()) { unlock(); return false; } } return true; } /** * \brief Unlock all media devices acquired by the pipeline * * This method shall not be called from pipeline handler implementation, as the * Camera class handles locking directly. * * \context This function is \threadsafe. * * \sa lock() */ void PipelineHandler::unlock() { for (std::shared_ptr<MediaDevice> &media : mediaDevices_) media->unlock(); } /** * \brief Retrieve the list of controls for a camera * \param[in] camera The camera * \context This function is \threadsafe. * \return A ControlInfoMap listing the controls support by \a camera */ const ControlInfoMap &PipelineHandler::controls(const Camera *camera) const { const CameraData *data = cameraData(camera); return data->controlInfo_; } /** * \brief Retrieve the list of properties for a camera * \param[in] camera The camera * \return A ControlList of properties supported by \a camera */ const ControlList &PipelineHandler::properties(const Camera *camera) const { const CameraData *data = cameraData(camera); return data->properties_; } /** * \fn PipelineHandler::generateConfiguration() * \brief Generate a camera configuration for a specified camera * \param[in] camera The camera to generate a default configuration for * \param[in] roles A list of stream roles * * Generate a default configuration for the \a camera for a specified list of * stream roles. The caller shall populate the \a roles with the use-cases it * wishes to fetch the default configuration for. The returned configuration * can then be examined by the caller to learn about the selected streams and * their default parameters. * * The intended companion to this is \a configure() which can be used to change * the group of streams parameters. * * \context This function may be called from any thread and shall be * \threadsafe. It shall not modify the state of the \a camera in the pipeline * handler. * * \return A valid CameraConfiguration if the requested roles can be satisfied, * or a null pointer otherwise. The ownership of the returned configuration is * passed to the caller. */ /** * \fn PipelineHandler::configure() * \brief Configure a group of streams for capture * \param[in] camera The camera to configure * \param[in] config The camera configurations to setup * * Configure the specified group of streams for \a camera according to the * configuration specified in \a config. The intended caller of this interface * is the Camera class which will receive configuration to apply from the * application. * * The configuration is guaranteed to have been validated with * CameraConfiguration::validate(). The pipeline handler implementation shall * not perform further validation and may rely on any custom field stored in its * custom CameraConfiguration derived class. * * When configuring the camera the pipeline handler shall associate a Stream * instance to each StreamConfiguration entry in the CameraConfiguration using * the StreamConfiguration::setStream() method. * * \context This function is called from the CameraManager thread. * * \return 0 on success or a negative error code otherwise */ /**


context:
space:
mode: