libcamera: include/libcamera/internal/pipeline_handler.h Source File

libcamera v0.7.1 Supporting cameras in Linux since 2019

Loading...
Searching...
No Matches
pipeline_handler.h
Go to the documentation of this file.
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2/*
3 * Copyright (C) 2018, Google Inc.
4 *
5 * Pipeline handler infrastructure
6 */
7
8#pragma once
9
10#include <memory>
11#include <string>
12#include <sys/types.h>
13#include <vector>
14
15#include <libcamera/base/object.h>
16
17#include <libcamera/controls.h>
18#include <libcamera/stream.h>
19
20#include "libcamera/internal/camera_manager.h"
21#include "libcamera/internal/ipa_manager.h"
22
23namespace libcamera {
24
25class Camera;
26class CameraConfiguration;
27class DeviceEnumerator;
28class DeviceMatch;
29class FrameBuffer;
30class MediaDevice;
31class PipelineHandler;
32class Request;
33
34 class PipelineHandler : public std::enable_shared_from_this<PipelineHandler>,
35 public Object
36{
37public:
38 PipelineHandler(CameraManager *manager,
39 unsigned int maxQueuedRequestsDevice = 32);
40 virtual ~PipelineHandler();
41
42 virtual bool match(DeviceEnumerator *enumerator) = 0;
43 std::shared_ptr<MediaDevice> acquireMediaDevice(DeviceEnumerator *enumerator,
44 const DeviceMatch &dm);
45
46 bool acquire(Camera *camera);
47 void release(Camera *camera);
48
49 virtual std::unique_ptr<CameraConfiguration> generateConfiguration(Camera *camera,
50 Span<const StreamRole> roles) = 0;
51 virtual int configure(Camera *camera, CameraConfiguration *config) = 0;
52
53 virtual int exportFrameBuffers(Camera *camera, Stream *stream,
54 std::vector<std::unique_ptr<FrameBuffer>> *buffers) = 0;
55
56 virtual int start(Camera *camera, const ControlList *controls) = 0;
57 void stop(Camera *camera);
58 bool hasPendingRequests(const Camera *camera) const;
59
60 void registerRequest(Request *request);
61 void queueRequest(Request *request);
62
63 bool completeBuffer(Request *request, FrameBuffer *buffer);
64 void completeRequest(Request *request);
65 void cancelRequest(Request *request);
66
67 std::string configurationFile(const std::string &subdir,
68 const std::string &name,
69 bool silent = false) const;
70
71 const char *name() const { return name_; }
72
73 CameraManager *cameraManager() const { return manager_; }
74
75 template<typename T>
76 std::unique_ptr<T> createIPA(uint32_t minVersion, uint32_t maxVersion)
77 {
78 IPAManager *ipaManager = manager_->_d()->ipaManager();
79 return ipaManager->createIPA<T>(this, minVersion, maxVersion);
80 }
81
82protected:
83 void registerCamera(std::shared_ptr<Camera> camera);
84 void hotplugMediaDevice(std::shared_ptr<MediaDevice> media);
85 unsigned int useCount() const { return useCount_; }
86
87 virtual int queueRequestDevice(Camera *camera, Request *request) = 0;
88 virtual void stopDevice(Camera *camera) = 0;
89
90 virtual bool acquireDevice(Camera *camera);
91 virtual void releaseDevice(Camera *camera);
92
93 CameraManager *manager_;
94 const unsigned int maxQueuedRequestsDevice_;
95
96private:
97 void unlockMediaDevices();
98
99 void mediaDeviceDisconnected(std::shared_ptr<MediaDevice> media);
100 virtual void disconnect();
101
102 void doQueueRequest(Request *request);
103 void doQueueRequests(Camera *camera);
104
105 std::vector<std::shared_ptr<MediaDevice>> mediaDevices_;
106 std::vector<std::weak_ptr<Camera>> cameras_;
107
108 const char *name_;
109 unsigned int useCount_;
110
111 friend class PipelineHandlerFactoryBase;
112};
113
114 class PipelineHandlerFactoryBase
115{
116public:
117 PipelineHandlerFactoryBase(const char *name);
118 virtual ~PipelineHandlerFactoryBase() = default;
119
120 std::shared_ptr<PipelineHandler> create(CameraManager *manager) const;
121
122 const std::string &name() const { return name_; }
123
124 static std::vector<PipelineHandlerFactoryBase *> &factories();
125 static const PipelineHandlerFactoryBase *getFactoryByName(const std::string &name);
126
127private:
128 static void registerType(PipelineHandlerFactoryBase *factory);
129
130 virtual std::unique_ptr<PipelineHandler>
131 createInstance(CameraManager *manager) const = 0;
132
133 std::string name_;
134};
135
136template<typename _PipelineHandler>
137 class PipelineHandlerFactory final : public PipelineHandlerFactoryBase
138{
139public:
140 PipelineHandlerFactory(const char *name)
141 : PipelineHandlerFactoryBase(name)
142 {
143 }
144
145 std::unique_ptr<PipelineHandler>
146 createInstance(CameraManager *manager) const override
147 {
148 return std::make_unique<_PipelineHandler>(manager);
149 }
150};
151
152#define REGISTER_PIPELINE_HANDLER(handler, name) \
153 static PipelineHandlerFactory<handler> global_##handler##Factory(name);
154
155} /* namespace libcamera */
libcamera::CameraConfiguration
Hold configuration for streams of the camera.
Definition camera.h:60
libcamera::CameraManager
Provide access and manage all cameras in the system.
Definition camera_manager.h:25
libcamera::Camera
Camera device.
Definition camera.h:115
libcamera::ControlList
Associate a list of ControlId with their values for an object.
Definition controls.h:409
libcamera::DeviceEnumerator
Enumerate, store and search media devices.
Definition device_enumerator.h:38
libcamera::DeviceMatch
Description of a media device search pattern.
Definition device_enumerator.h:22
libcamera::FrameBuffer
Frame buffer data and its associated dynamic metadata.
Definition framebuffer.h:50
libcamera::IPAManager
Manager for IPA modules.
Definition ipa_manager.h:31
libcamera::IPAManager::createIPA
std::unique_ptr< T > createIPA(PipelineHandler *pipe, uint32_t minVersion, uint32_t maxVersion)
Create an IPA proxy that matches a given pipeline handler.
Definition ipa_manager.h:37
libcamera::MediaDevice
The MediaDevice represents a Media Controller device with its full graph of connected objects.
Definition media_device.h:28
libcamera::Object::Object
Object(Object *parent=nullptr)
Construct an Object instance.
Definition object.cpp:69
libcamera::PipelineHandlerFactoryBase
Base class for pipeline handler factories.
Definition pipeline_handler.h:115
libcamera::PipelineHandlerFactoryBase::name
const std::string & name() const
Retrieve the factory name.
Definition pipeline_handler.h:122
libcamera::PipelineHandlerFactoryBase::getFactoryByName
static const PipelineHandlerFactoryBase * getFactoryByName(const std::string &name)
Return the factory for the pipeline handler with name name.
Definition pipeline_handler.cpp:928
libcamera::PipelineHandlerFactoryBase::PipelineHandlerFactoryBase
PipelineHandlerFactoryBase(const char *name)
Construct a pipeline handler factory base.
Definition pipeline_handler.cpp:867
libcamera::PipelineHandlerFactoryBase::factories
static std::vector< PipelineHandlerFactoryBase * > & factories()
Retrieve the list of all pipeline handler factories.
Definition pipeline_handler.cpp:912
libcamera::PipelineHandlerFactoryBase::create
std::shared_ptr< PipelineHandler > create(CameraManager *manager) const
Create an instance of the PipelineHandler corresponding to the factory.
Definition pipeline_handler.cpp:880
libcamera::PipelineHandlerFactory::PipelineHandlerFactory
PipelineHandlerFactory(const char *name)
Construct a pipeline handler factory.
Definition pipeline_handler.h:140
libcamera::PipelineHandlerFactory::createInstance
std::unique_ptr< PipelineHandler > createInstance(CameraManager *manager) const override
Create an instance of the PipelineHandler corresponding to the factory.
Definition pipeline_handler.h:146
libcamera::PipelineHandler
Create and manage cameras based on a set of media devices.
Definition pipeline_handler.h:36
libcamera::PipelineHandler::stopDevice
virtual void stopDevice(Camera *camera)=0
Stop capturing from all running streams.
libcamera::PipelineHandler::hotplugMediaDevice
void hotplugMediaDevice(std::shared_ptr< MediaDevice > media)
Enable hotplug handling for a media device.
Definition pipeline_handler.cpp:739
libcamera::PipelineHandler::cameraManager
CameraManager * cameraManager() const
Retrieve the CameraManager that this pipeline handler belongs to.
Definition pipeline_handler.h:73
libcamera::PipelineHandler::configurationFile
std::string configurationFile(const std::string &subdir, const std::string &name, bool silent=false) const
Retrieve the absolute path to a platform configuration file.
Definition pipeline_handler.cpp:638
libcamera::PipelineHandler::name
const char * name() const
Retrieve the pipeline handler name.
Definition pipeline_handler.h:71
libcamera::PipelineHandler::manager_
CameraManager * manager_
The Camera manager associated with the pipeline handler.
Definition pipeline_handler.h:93
libcamera::PipelineHandler::completeRequest
void completeRequest(Request *request)
Signal request completion.
Definition pipeline_handler.cpp:584
libcamera::PipelineHandler::releaseDevice
virtual void releaseDevice(Camera *camera)
Release resources associated with this camera.
Definition pipeline_handler.cpp:260
libcamera::PipelineHandler::queueRequestDevice
virtual int queueRequestDevice(Camera *camera, Request *request)=0
Queue a request to the device.
libcamera::PipelineHandler::acquire
bool acquire(Camera *camera)
Acquire exclusive access to the pipeline handler for the process.
Definition pipeline_handler.cpp:171
libcamera::PipelineHandler::useCount
unsigned int useCount() const
Retrieve the pipeline handler's used camera count.
Definition pipeline_handler.h:85
libcamera::PipelineHandler::acquireDevice
virtual bool acquireDevice(Camera *camera)
Acquire resources associated with this camera.
Definition pipeline_handler.cpp:239
libcamera::PipelineHandler::match
virtual bool match(DeviceEnumerator *enumerator)=0
Match media devices and create camera instances.
libcamera::PipelineHandler::registerCamera
void registerCamera(std::shared_ptr< Camera > camera)
Register a camera to the camera manager and pipeline handler.
Definition pipeline_handler.cpp:688
libcamera::PipelineHandler::registerRequest
void registerRequest(Request *request)
Register a request for use by the pipeline handler.
Definition pipeline_handler.cpp:435
libcamera::PipelineHandler::start
virtual int start(Camera *camera, const ControlList *controls)=0
Start capturing from a group of streams.
libcamera::PipelineHandler::cancelRequest
void cancelRequest(Request *request)
Cancel request and signal its completion.
Definition pipeline_handler.cpp:613
libcamera::PipelineHandler::createIPA
std::unique_ptr< T > createIPA(uint32_t minVersion, uint32_t maxVersion)
Create an IPA proxy that matches this pipeline handler.
Definition pipeline_handler.h:76
libcamera::PipelineHandler::PipelineHandler
PipelineHandler(CameraManager *manager, unsigned int maxQueuedRequestsDevice=32)
Construct a PipelineHandler instance.
Definition pipeline_handler.cpp:72
libcamera::PipelineHandler::queueRequest
void queueRequest(Request *request)
Queue a request.
Definition pipeline_handler.cpp:469
libcamera::PipelineHandler::hasPendingRequests
bool hasPendingRequests(const Camera *camera) const
Determine if the camera has any requests pending.
Definition pipeline_handler.cpp:422
libcamera::PipelineHandler::stop
void stop(Camera *camera)
Stop capturing from all running streams and cancel pending requests.
Definition pipeline_handler.cpp:367
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::generateConfiguration
virtual std::unique_ptr< CameraConfiguration > generateConfiguration(Camera *camera, Span< const StreamRole > roles)=0
Generate a camera configuration for a specified camera.
libcamera::PipelineHandler::maxQueuedRequestsDevice_
const unsigned int maxQueuedRequestsDevice_
The maximum number of requests the pipeline handler shall queue to the device.
Definition pipeline_handler.h:94
libcamera::PipelineHandler::completeBuffer
bool completeBuffer(Request *request, FrameBuffer *buffer)
Complete a buffer for a request.
Definition pipeline_handler.cpp:563
libcamera::PipelineHandler::acquireMediaDevice
std::shared_ptr< MediaDevice > acquireMediaDevice(DeviceEnumerator *enumerator, const DeviceMatch &dm)
Search and acquire a MediaDevice matching a device pattern.
Definition pipeline_handler.cpp:136
libcamera::PipelineHandler::configure
virtual int configure(Camera *camera, CameraConfiguration *config)=0
Configure a group of streams for capture.
libcamera::PipelineHandler::release
void release(Camera *camera)
Release exclusive access to the pipeline handler.
Definition pipeline_handler.cpp:209
libcamera::Request
A frame capture request.
Definition request.h:30
libcamera::Stream
Video stream for a camera.
Definition stream.h:76
controls.h
Framework to manage controls related to an object.
camera_manager.h
Internal camera manager support.
ipa_manager.h
Image Processing Algorithm module manager.
libcamera::controls
Namespace for libcamera controls.
Definition control_ids.h:22
libcamera
Top-level libcamera namespace.
Definition backtrace.h:17
object.h
Base object to support automatic signal disconnection.
stream.h
Video stream for a Camera.