libcamera  v0.0.0+100-debian/0_git20200629+e7aa92a-8-9-g77f5237c-dirty (2021-05-05T16:20:29+01:00)
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/class.h>
19 #include <libcamera/controls.h>
20 #include <libcamera/object.h>
21 #include <libcamera/stream.h>
22 
24 
25 namespace libcamera {
26 
27 class Camera;
28 class CameraConfiguration;
29 class CameraManager;
30 class DeviceEnumerator;
31 class DeviceMatch;
32 class FrameBuffer;
33 class MediaDevice;
34 class PipelineHandler;
35 class Request;
36 
38 {
39 public:
40  explicit CameraData(PipelineHandler *pipe)
41  : pipe_(pipe), requestSequence_(0)
42  {
43  }
44  virtual ~CameraData() = default;
45 
47  std::list<Request *> queuedRequests_;
50 
51  uint32_t requestSequence_;
52 
53 private:
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(const Camera *camera) const;
72  const ControlList &properties(const Camera *camera) const;
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, const ControlList *controls) = 0;
82  virtual void stop(Camera *camera) = 0;
83  bool hasPendingRequests(const Camera *camera) const;
84 
85  void queueRequest(Request *request);
86 
87  bool completeBuffer(Request *request, FrameBuffer *buffer);
88  void completeRequest(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  const CameraData *cameraData(const Camera *camera) const;
101 
103 
104 private:
105  void mediaDeviceDisconnected(MediaDevice *media);
106  virtual void disconnect();
107 
108  std::vector<std::shared_ptr<MediaDevice>> mediaDevices_;
109  std::vector<std::weak_ptr<Camera>> cameras_;
110  std::map<const Camera *, std::unique_ptr<CameraData>> cameraData_;
111 
112  const char *name_;
113 
114  friend class PipelineHandlerFactory;
115 };
116 
118 {
119 public:
120  PipelineHandlerFactory(const char *name);
121  virtual ~PipelineHandlerFactory() = default;
122 
123  std::shared_ptr<PipelineHandler> create(CameraManager *manager);
124 
125  const std::string &name() const { return name_; }
126 
127  static void registerType(PipelineHandlerFactory *factory);
128  static std::vector<PipelineHandlerFactory *> &factories();
129 
130 private:
131  virtual PipelineHandler *createInstance(CameraManager *manager) = 0;
132 
133  std::string name_;
134 };
135 
136 #define REGISTER_PIPELINE_HANDLER(handler) \
137 class handler##Factory final : public PipelineHandlerFactory \
138 { \
139 public: \
140  handler##Factory() : PipelineHandlerFactory(#handler) {} \
141  \
142 private: \
143  PipelineHandler *createInstance(CameraManager *manager) \
144  { \
145  return new handler(manager); \
146  } \
147 }; \
148 static handler##Factory global_##handler##Factory;
149 
150 } /* namespace libcamera */
151 
152 #endif /* __LIBCAMERA_INTERNAL_PIPELINE_HANDLER_H__ */
Utilities to help constructing class interfaces.
The MediaDevice represents a Media Controller device with its full graph of connected objects...
Definition: media_device.h:24
std::vector< StreamRole > StreamRoles
A vector of StreamRole.
Definition: stream.h:68
ControlList properties_
The list of properties supported by the camera.
Definition: pipeline_handler.h:49
Video stream for a camera.
Definition: stream.h:70
Top-level libcamera namespace.
Definition: bound_method.h:15
CameraManager * manager_
The Camera manager associated with the pipeline handler.
Definition: pipeline_handler.h:102
Frame buffer data and its associated dynamic metadata.
Definition: buffer.h:37
const std::string & name() const
Retrieve the factory name.
Definition: pipeline_handler.h:125
Video stream for a Camera.
Hold configuration for streams of the camera.
Definition: camera.h:30
IPA Proxy.
A map of ControlId to ControlInfo.
Definition: controls.h:301
ControlInfoMap controlInfo_
The set of controls supported by the camera.
Definition: pipeline_handler.h:48
A frame capture request.
Definition: request.h:27
#define LIBCAMERA_DISABLE_COPY(klass)
Disable copy construction and assignment of the klass.
CameraData(PipelineHandler *pipe)
Construct a CameraData instance for the given pipeline handler.
Definition: pipeline_handler.h:40
Create and manage cameras based on a set of media devices.
Definition: pipeline_handler.h:57
Camera device.
Definition: camera.h:74
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:784
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
Base object to support automatic signal disconnection.
uint32_t requestSequence_
The queuing sequence of the request.
Definition: pipeline_handler.h:51
const ControlIdMap controls
List of all supported libcamera controls.
Definition: control_ids.cpp:893
Associate a list of ControlId with their values for an object.
Definition: controls.h:346
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:37
Registration of PipelineHandler classes and creation of instances.
Definition: pipeline_handler.h:117