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;
65  MediaDevice *acquireMediaDevice(DeviceEnumerator *enumerator,
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 
74  virtual CameraConfiguration *generateConfiguration(Camera *camera,
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__ */
The MediaDevice represents a Media Controller device with its full graph of connected objects...
Definition: media_device.h:24
ControlList properties_
The list of properties supported by the camera.
Definition: pipeline_handler.h:49
Video stream for a camera.
Definition: stream.h:69
Definition: bound_method.h:15
CameraManager * manager_
The Camera manager associated with the pipeline handler.
Definition: pipeline_handler.h:101
Frame buffer data and its associated dynamic metadata.
Definition: buffer.h:36
const std::string & name() const
Retrieve the factory name.
Definition: pipeline_handler.h:124
Video stream for a Camera.
Hold configuration for streams of the camera.
Definition: camera.h:27
IPA Proxy.
A map of ControlId to ControlInfo.
Definition: controls.h:296
ControlInfoMap controlInfo_
The set of controls supported by the camera.
Definition: pipeline_handler.h:48
A frame capture request.
Definition: request.h:25
std::unique_ptr< IPAProxy > ipa_
The IPA module used by the camera.
Definition: pipeline_handler.h:50
CameraData(PipelineHandler *pipe)
Construct a CameraData instance for the given pipeline handler.
Definition: pipeline_handler.h:39
Create and manage cameras based on a set of media devices.
Definition: pipeline_handler.h:57
Camera device.
Definition: camera.h:69
const char * name() const
Retrieve the pipeline handler name.
Definition: pipeline_handler.h:90
PipelineHandler * pipe_
The pipeline handler related to this CameraData instance.
Definition: pipeline_handler.h:46
std::list< Request * > queuedRequests_
The list of queued and not yet completed request.
Definition: pipeline_handler.h:47
const ControlIdMap properties
List of all supported libcamera properties.
Definition: property_ids.cpp:419
Description of a media device search pattern.
Definition: device_enumerator.h:22
Provide access and manage all cameras in the system.
Definition: camera_manager.h:23
Enumerate, store and search media devices.
Definition: device_enumerator.h:36
std::vector< StreamRole > StreamRoles
A vector of StreamRole.
Definition: stream.h:67
Base object to support automatic signal disconnection.
Camera * camera_
The camera related to this CameraData instance.
Definition: pipeline_handler.h:45
const ControlIdMap controls
List of all supported libcamera controls.
Definition: control_ids.cpp:291
Associate a list of ControlId with their values for an object.
Definition: controls.h:341
Framework to manage controls related to an object.
Base object to support automatic signal disconnection.
Definition: object.h:24
Base class for platform-specific data associated with a camera.
Definition: pipeline_handler.h:36
Registration of PipelineHandler classes and creation of instances.
Definition: pipeline_handler.h:116