libcamera  v0.0.0
Supporting cameras in Linux since 2019
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.h - Pipeline handler infrastructure
6  */
7 #ifndef __LIBCAMERA_INTERNAL_PIPELINE_HANDLER_H__
8 #define __LIBCAMERA_INTERNAL_PIPELINE_HANDLER_H__
9 
10 #include <list>
11 #include <map>
12 #include <memory>
13 #include <set>
14 #include <string>
15 #include <sys/types.h>
16 #include <vector>
17 
18 #include <libcamera/controls.h>
19 #include <libcamera/object.h>
20 #include <libcamera/stream.h>
21 
23 
24 namespace libcamera {
25 
26 class Camera;
27 class CameraConfiguration;
28 class CameraManager;
29 class DeviceEnumerator;
30 class DeviceMatch;
31 class FrameBuffer;
32 class MediaDevice;
33 class PipelineHandler;
34 class Request;
35 
37 {
38 public:
39  explicit CameraData(PipelineHandler *pipe)
40  : pipe_(pipe)
41  {
42  }
43  virtual ~CameraData() {}
44 
47  std::list<Request *> queuedRequests_;
50  std::unique_ptr<IPAProxy> ipa_;
51 
52 private:
53  CameraData(const CameraData &) = delete;
54  CameraData &operator=(const CameraData &) = delete;
55 };
56 
57 class PipelineHandler : public std::enable_shared_from_this<PipelineHandler>,
58  public Object
59 {
60 public:
62  virtual ~PipelineHandler();
63 
64  virtual bool match(DeviceEnumerator *enumerator) = 0;
66  const DeviceMatch &dm);
67 
68  bool lock();
69  void unlock();
70 
71  const ControlInfoMap &controls(Camera *camera);
72  const ControlList &properties(Camera *camera);
73 
75  const StreamRoles &roles) = 0;
76  virtual int configure(Camera *camera, CameraConfiguration *config) = 0;
77 
78  virtual int exportFrameBuffers(Camera *camera, Stream *stream,
79  std::vector<std::unique_ptr<FrameBuffer>> *buffers) = 0;
80 
81  virtual int start(Camera *camera) = 0;
82  virtual void stop(Camera *camera) = 0;
83 
84  int queueRequest(Camera *camera, Request *request);
85 
86  bool completeBuffer(Camera *camera, Request *request,
87  FrameBuffer *buffer);
88  void completeRequest(Camera *camera, Request *request);
89 
90  const char *name() const { return name_; }
91 
92 protected:
93  void registerCamera(std::shared_ptr<Camera> camera,
94  std::unique_ptr<CameraData> data);
95  void hotplugMediaDevice(MediaDevice *media);
96 
97  virtual int queueRequestDevice(Camera *camera, Request *request) = 0;
98 
99  CameraData *cameraData(const Camera *camera);
100 
102 
103 private:
104  void mediaDeviceDisconnected(MediaDevice *media);
105  virtual void disconnect();
106 
107  std::vector<std::shared_ptr<MediaDevice>> mediaDevices_;
108  std::vector<std::weak_ptr<Camera>> cameras_;
109  std::map<const Camera *, std::unique_ptr<CameraData>> cameraData_;
110 
111  const char *name_;
112 
113  friend class PipelineHandlerFactory;
114 };
115 
117 {
118 public:
119  PipelineHandlerFactory(const char *name);
120  virtual ~PipelineHandlerFactory() {}
121 
122  std::shared_ptr<PipelineHandler> create(CameraManager *manager);
123 
124  const std::string &name() const { return name_; }
125 
126  static void registerType(PipelineHandlerFactory *factory);
127  static std::vector<PipelineHandlerFactory *> &factories();
128 
129 private:
130  virtual PipelineHandler *createInstance(CameraManager *manager) = 0;
131 
132  std::string name_;
133 };
134 
135 #define REGISTER_PIPELINE_HANDLER(handler) \
136 class handler##Factory final : public PipelineHandlerFactory \
137 { \
138 public: \
139  handler##Factory() : PipelineHandlerFactory(#handler) {} \
140  \
141 private: \
142  PipelineHandler *createInstance(CameraManager *manager) \
143  { \
144  return new handler(manager); \
145  } \
146 }; \
147 static handler##Factory global_##handler##Factory;
148 
149 } /* namespace libcamera */
150 
151 #endif /* __LIBCAMERA_INTERNAL_PIPELINE_HANDLER_H__ */
Hold configuration for streams of the camera.
Definition: camera.h:28
Base class for platform-specific data associated with a camera.
Definition: pipeline_handler.h:37
PipelineHandler * pipe_
The pipeline handler related to this CameraData instance.
Definition: pipeline_handler.h:46
ControlList properties_
The list of properties supported by the camera.
Definition: pipeline_handler.h:49
std::unique_ptr< IPAProxy > ipa_
The IPA module used by the camera.
Definition: pipeline_handler.h:50
std::list< Request * > queuedRequests_
The list of queued and not yet completed request.
Definition: pipeline_handler.h:47
ControlInfoMap controlInfo_
The set of controls supported by the camera.
Definition: pipeline_handler.h:48
Camera * camera_
The camera related to this CameraData instance.
Definition: pipeline_handler.h:45
CameraData(PipelineHandler *pipe)
Construct a CameraData instance for the given pipeline handler.
Definition: pipeline_handler.h:39
Provide access and manage all cameras in the system.
Definition: camera_manager.h:24
Camera device.
Definition: camera.h:70
A map of ControlId to ControlInfo.
Definition: controls.h:297
Associate a list of ControlId with their values for an object.
Definition: controls.h:342
Enumerate, store and search media devices.
Definition: device_enumerator.h:37
Description of a media device search pattern.
Definition: device_enumerator.h:23
Frame buffer data and its associated dynamic metadata.
Definition: buffer.h:37
The MediaDevice represents a Media Controller device with its full graph of connected objects.
Definition: media_device.h:25
Base object to support automatic signal disconnection.
Definition: object.h:25
Registration of PipelineHandler classes and creation of instances.
Definition: pipeline_handler.h:117
std::shared_ptr< PipelineHandler > create(CameraManager *manager)
Create an instance of the PipelineHandler corresponding to the factory.
Definition: pipeline_handler.cpp:650
const std::string & name() const
Retrieve the factory name.
Definition: pipeline_handler.h:124
static void registerType(PipelineHandlerFactory *factory)
Add a pipeline handler class to the registry.
Definition: pipeline_handler.cpp:670
static std::vector< PipelineHandlerFactory * > & factories()
Retrieve the list of all pipeline handler factories.
Definition: pipeline_handler.cpp:688
PipelineHandlerFactory(const char *name)
Construct a pipeline handler factory.
Definition: pipeline_handler.cpp:637
Create and manage cameras based on a set of media devices.
Definition: pipeline_handler.h:59
virtual int queueRequestDevice(Camera *camera, Request *request)=0
Queue a request to the device.
void hotplugMediaDevice(MediaDevice *media)
Enable hotplug handling for a media device.
Definition: pipeline_handler.cpp:530
PipelineHandler(CameraManager *manager)
Construct a PipelineHandler instance.
Definition: pipeline_handler.cpp:139
void unlock()
Unlock all media devices acquired by the pipeline.
Definition: pipeline_handler.cpp:248
const char * name() const
Retrieve the pipeline handler name.
Definition: pipeline_handler.h:90
virtual int exportFrameBuffers(Camera *camera, Stream *stream, std::vector< std::unique_ptr< FrameBuffer >> *buffers)=0
Allocate and export buffers for stream.
CameraData * cameraData(const Camera *camera)
Retrieve the pipeline-specific data associated with a Camera.
Definition: pipeline_handler.cpp:594
void completeRequest(Camera *camera, Request *request)
Signal request completion.
Definition: pipeline_handler.cpp:463
bool completeBuffer(Camera *camera, Request *request, FrameBuffer *buffer)
Complete a buffer for a request.
Definition: pipeline_handler.cpp:441
MediaDevice * acquireMediaDevice(DeviceEnumerator *enumerator, const DeviceMatch &dm)
Search and acquire a MediaDevice matching a device pattern.
Definition: pipeline_handler.cpp:199
virtual CameraConfiguration * generateConfiguration(Camera *camera, const StreamRoles &roles)=0
Generate a camera configuration for a specified camera.
virtual bool match(DeviceEnumerator *enumerator)=0
Match media devices and create camera instances.
bool lock()
Lock all media devices acquired by the pipeline.
Definition: pipeline_handler.cpp:226
const ControlList & properties(Camera *camera)
Retrieve the list of properties for a camera.
Definition: pipeline_handler.cpp:271
virtual int configure(Camera *camera, CameraConfiguration *config)=0
Configure a group of streams for capture.
virtual void stop(Camera *camera)=0
Stop capturing from all running streams.
int queueRequest(Camera *camera, Request *request)
Queue a request to the camera.
Definition: pipeline_handler.cpp:394
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
virtual int start(Camera *camera)=0
Start capturing from a group of streams.
CameraManager * manager_
The Camera manager associated with the pipeline handler.
Definition: pipeline_handler.h:101
const ControlInfoMap & controls(Camera *camera)
Retrieve the list of controls for a camera.
Definition: pipeline_handler.cpp:260
A frame capture request.
Definition: request.h:26
Video stream for a camera.
Definition: stream.h:70
Framework to manage controls related to an object.
IPA Proxy.
Base object to support automatic signal disconnection.
Video stream for a Camera.
std::vector< StreamRole > StreamRoles
A vector of StreamRole.
Definition: stream.h:67