pipeline_handler.h
Go to the documentation of this file.
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2018, Google Inc.
*
* pipeline_handler.h - Pipeline handler infrastructure
*/
#ifndef __LIBCAMERA_INTERNAL_PIPELINE_HANDLER_H__
#define __LIBCAMERA_INTERNAL_PIPELINE_HANDLER_H__
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <sys/types.h>
#include <vector>
#include <libcamera/controls.h>
#include <libcamera/object.h>
#include <libcamera/stream.h>
#include "libcamera/internal/ipa_proxy.h"
namespace libcamera {
class Camera;
class CameraConfiguration;
class CameraManager;
class DeviceEnumerator;
class DeviceMatch;
class FrameBuffer;
class MediaDevice;
class PipelineHandler;
class Request;
class CameraData
{
public:
explicit CameraData(PipelineHandler *pipe)
: pipe_(pipe)
{
}
virtual ~CameraData() {}
Camera *camera_;
PipelineHandler *pipe_;
std::list<Request *> queuedRequests_;
ControlInfoMap controlInfo_;
ControlList properties_;
std::unique_ptr<IPAProxy> ipa_;
private:
CameraData(const CameraData &) = delete;
CameraData &operator=(const CameraData &) = delete;
};
class PipelineHandler : public std::enable_shared_from_this<PipelineHandler>,
public Object
{
public:
PipelineHandler(CameraManager *manager);
virtual ~PipelineHandler();
virtual bool match(DeviceEnumerator *enumerator) = 0;
MediaDevice *acquireMediaDevice(DeviceEnumerator *enumerator,
const DeviceMatch &dm);
bool lock();
void unlock();
const ControlInfoMap &controls(Camera *camera);
const ControlList &properties(Camera *camera);
virtual CameraConfiguration *generateConfiguration(Camera *camera,
const StreamRoles &roles) = 0;
virtual int configure(Camera *camera, CameraConfiguration *config) = 0;
virtual int exportFrameBuffers(Camera *camera, Stream *stream,
std::vector<std::unique_ptr<FrameBuffer>> *buffers) = 0;
virtual int start(Camera *camera) = 0;
virtual void stop(Camera *camera) = 0;
int queueRequest(Camera *camera, Request *request);
bool completeBuffer(Camera *camera, Request *request,
FrameBuffer *buffer);
void completeRequest(Camera *camera, Request *request);
const char *name() const { return name_; }
protected:
void registerCamera(std::shared_ptr<Camera> camera,
std::unique_ptr<CameraData> data);
void hotplugMediaDevice(MediaDevice *media);
virtual int queueRequestDevice(Camera *camera, Request *request) = 0;
CameraData *cameraData(const Camera *camera);
CameraManager *manager_;
private:
void mediaDeviceDisconnected(MediaDevice *media);
virtual void disconnect();
std::vector<std::shared_ptr<MediaDevice>> mediaDevices_;
std::vector<std::weak_ptr<Camera>> cameras_;
std::map<const Camera *, std::unique_ptr<CameraData>> cameraData_;
const char *name_;
friend class PipelineHandlerFactory;
};
class PipelineHandlerFactory
{
public:
PipelineHandlerFactory(const char *name);
virtual ~PipelineHandlerFactory() {}
std::shared_ptr<PipelineHandler> create(CameraManager *manager);
const std::string &name() const { return name_; }
static void registerType(PipelineHandlerFactory *factory);
static std::vector<PipelineHandlerFactory *> &factories();
private:
virtual PipelineHandler *createInstance(CameraManager *manager) = 0;
std::string name_;
};
#define REGISTER_PIPELINE_HANDLER(handler) \
class handler##Factory final : public PipelineHandlerFactory \
{ \
public: \
handler##Factory() : PipelineHandlerFactory(#handler) {} \
\
private: \
PipelineHandler *createInstance(CameraManager *manager) \
{ \
return new handler(manager); \
} \
}; \
static handler##Factory global_##handler##Factory;
} /* namespace libcamera */
#endif /* __LIBCAMERA_INTERNAL_PIPELINE_HANDLER_H__ */
libcamera::CameraConfiguration
Hold configuration for streams of the camera.
Definition: camera.h:28
libcamera::CameraData
Base class for platform-specific data associated with a camera.
Definition: pipeline_handler.h:37
libcamera::CameraData::pipe_
PipelineHandler * pipe_
The pipeline handler related to this CameraData instance.
Definition: pipeline_handler.h:46
libcamera::CameraData::properties_
ControlList properties_
The list of properties supported by the camera.
Definition: pipeline_handler.h:49
libcamera::CameraData::ipa_
std::unique_ptr< IPAProxy > ipa_
The IPA module used by the camera.
Definition: pipeline_handler.h:50
libcamera::CameraData::queuedRequests_
std::list< Request * > queuedRequests_
The list of queued and not yet completed request.
Definition: pipeline_handler.h:47
libcamera::CameraData::controlInfo_
ControlInfoMap controlInfo_
The set of controls supported by the camera.
Definition: pipeline_handler.h:48
libcamera::CameraData::camera_
Camera * camera_
The camera related to this CameraData instance.
Definition: pipeline_handler.h:45
libcamera::CameraData::CameraData
CameraData(PipelineHandler *pipe)
Construct a CameraData instance for the given pipeline handler.
Definition: pipeline_handler.h:39
libcamera::CameraManager
Provide access and manage all cameras in the system.
Definition: camera_manager.h:24
libcamera::Camera
Camera device.
Definition: camera.h:70
libcamera::ControlInfoMap
A map of ControlId to ControlInfo.
Definition: controls.h:297
libcamera::ControlList
Associate a list of ControlId with their values for an object.
Definition: controls.h:342
libcamera::DeviceEnumerator
Enumerate, store and search media devices.
Definition: device_enumerator.h:37
libcamera::DeviceMatch
Description of a media device search pattern.
Definition: device_enumerator.h:23
libcamera::FrameBuffer
Frame buffer data and its associated dynamic metadata.
Definition: buffer.h:37
libcamera::MediaDevice
The MediaDevice represents a Media Controller device with its full graph of connected objects.
Definition: media_device.h:25
libcamera::Object
Base object to support automatic signal disconnection.
Definition: object.h:25
libcamera::PipelineHandlerFactory
Registration of PipelineHandler classes and creation of instances.
Definition: pipeline_handler.h:117
libcamera::PipelineHandlerFactory::create
std::shared_ptr< PipelineHandler > create(CameraManager *manager)
Create an instance of the PipelineHandler corresponding to the factory.
Definition: pipeline_handler.cpp:650
libcamera::PipelineHandlerFactory::name
const std::string & name() const
Retrieve the factory name.
Definition: pipeline_handler.h:124
libcamera::PipelineHandlerFactory::registerType
static void registerType(PipelineHandlerFactory *factory)
Add a pipeline handler class to the registry.
Definition: pipeline_handler.cpp:670
libcamera::PipelineHandlerFactory::factories
static std::vector< PipelineHandlerFactory * > & factories()
Retrieve the list of all pipeline handler factories.
Definition: pipeline_handler.cpp:688
libcamera::PipelineHandlerFactory::PipelineHandlerFactory
PipelineHandlerFactory(const char *name)
Construct a pipeline handler factory.
Definition: pipeline_handler.cpp:637
libcamera::PipelineHandler
Create and manage cameras based on a set of media devices.
Definition: pipeline_handler.h:59
libcamera::PipelineHandler::queueRequestDevice
virtual int queueRequestDevice(Camera *camera, Request *request)=0
Queue a request to the device.
libcamera::PipelineHandler::hotplugMediaDevice
void hotplugMediaDevice(MediaDevice *media)
Enable hotplug handling for a media device.
Definition: pipeline_handler.cpp:530
libcamera::PipelineHandler::PipelineHandler
PipelineHandler(CameraManager *manager)
Construct a PipelineHandler instance.
Definition: pipeline_handler.cpp:139
libcamera::PipelineHandler::unlock
void unlock()
Unlock all media devices acquired by the pipeline.
Definition: pipeline_handler.cpp:248
libcamera::PipelineHandler::name
const char * name() const
Retrieve the pipeline handler name.
Definition: pipeline_handler.h:90
libcamera::PipelineHandler::exportFrameBuffers
virtual int exportFrameBuffers(Camera *camera, Stream *stream, std::vector< std::unique_ptr< FrameBuffer >> *buffers)=0
Allocate and export buffers for stream.
libcamera::PipelineHandler::cameraData
CameraData * cameraData(const Camera *camera)
Retrieve the pipeline-specific data associated with a Camera.
Definition: pipeline_handler.cpp:594
libcamera::PipelineHandler::completeRequest
void completeRequest(Camera *camera, Request *request)
Signal request completion.
Definition: pipeline_handler.cpp:463
libcamera::PipelineHandler::completeBuffer
bool completeBuffer(Camera *camera, Request *request, FrameBuffer *buffer)
Complete a buffer for a request.
Definition: pipeline_handler.cpp:441
libcamera::PipelineHandler::acquireMediaDevice
MediaDevice * acquireMediaDevice(DeviceEnumerator *enumerator, const DeviceMatch &dm)
Search and acquire a MediaDevice matching a device pattern.
Definition: pipeline_handler.cpp:199
libcamera::PipelineHandler::generateConfiguration
virtual CameraConfiguration * generateConfiguration(Camera *camera, const StreamRoles &roles)=0
Generate a camera configuration for a specified camera.
libcamera::PipelineHandler::match
virtual bool match(DeviceEnumerator *enumerator)=0
Match media devices and create camera instances.
libcamera::PipelineHandler::lock
bool lock()
Lock all media devices acquired by the pipeline.
Definition: pipeline_handler.cpp:226
libcamera::PipelineHandler::properties
const ControlList & properties(Camera *camera)
Retrieve the list of properties for a camera.
Definition: pipeline_handler.cpp:271
libcamera::PipelineHandler::configure
virtual int configure(Camera *camera, CameraConfiguration *config)=0
Configure a group of streams for capture.
libcamera::PipelineHandler::stop
virtual void stop(Camera *camera)=0
Stop capturing from all running streams.
libcamera::PipelineHandler::queueRequest
int queueRequest(Camera *camera, Request *request)
Queue a request to the camera.
Definition: pipeline_handler.cpp:394
libcamera::PipelineHandler::registerCamera
void registerCamera(std::shared_ptr< Camera > camera, std::unique_ptr< CameraData > data)
Register a camera to the camera manager and pipeline handler.
Definition: pipeline_handler.cpp:492
libcamera::PipelineHandler::start
virtual int start(Camera *camera)=0
Start capturing from a group of streams.
libcamera::PipelineHandler::manager_
CameraManager * manager_
The Camera manager associated with the pipeline handler.
Definition: pipeline_handler.h:101
libcamera::PipelineHandler::controls
const ControlInfoMap & controls(Camera *camera)
Retrieve the list of controls for a camera.
Definition: pipeline_handler.cpp:260
libcamera::Request
A frame capture request.
Definition: request.h:26
libcamera::Stream
Video stream for a camera.
Definition: stream.h:70
controls.h
Framework to manage controls related to an object.
ipa_proxy.h
IPA Proxy.
object.h
Base object to support automatic signal disconnection.
stream.h
Video stream for a Camera.
libcamera::StreamRoles
std::vector< StreamRole > StreamRoles
A vector of StreamRole.
Definition: stream.h:67