1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2018, Google Inc.
*
* pipeline_handler.h - Pipeline handler infrastructure
*/
#ifndef __LIBCAMERA_PIPELINE_HANDLER_H__
#define __LIBCAMERA_PIPELINE_HANDLER_H__
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include <ipa/ipa_interface.h>
#include <libcamera/controls.h>
#include <libcamera/stream.h>
namespace libcamera {
class Buffer;
class BufferPool;
class Camera;
class CameraConfiguration;
class CameraManager;
class DeviceEnumerator;
class DeviceMatch;
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_;
std::unique_ptr<IPAInterface> ipa_;
private:
CameraData(const CameraData &) = delete;
CameraData &operator=(const CameraData &) = delete;
};
class PipelineHandler : public std::enable_shared_from_this<PipelineHandler>
{
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);
virtual CameraConfiguration *generateConfiguration(Camera *camera,
const StreamRoles &roles) = 0;
virtual int configure(Camera *camera, CameraConfiguration *config) = 0;
virtual int allocateBuffers(Camera *camera,
const std::set<Stream *> &streams) = 0;
virtual int freeBuffers(Camera *camera,
const std::set<Stream *> &streams) = 0;
virtual int start(Camera *camera) = 0;
virtual void stop(Camera *camera) = 0;
virtual int queueRequest(Camera *camera, Request *request);
bool completeBuffer(Camera *camera, Request *request, Buffer *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);
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_PIPELINE_HANDLER_H__ */
|
