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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* ipa_context_wrapper.cpp - Image Processing Algorithm context wrapper
*/
#include "libcamera/internal/ipa_context_wrapper.h"
#include <vector>
#include <libcamera/controls.h>
#include "libcamera/internal/byte_stream_buffer.h"
#include "libcamera/internal/camera_sensor.h"
#include "libcamera/internal/utils.h"
/**
* \file ipa_context_wrapper.h
* \brief Image Processing Algorithm context wrapper
*/
namespace libcamera {
/**
* \class IPAContextWrapper
* \brief Wrap an ipa_context and expose it as an IPAInterface
*
* The IPAContextWrapper class wraps an ipa_context, provided by an IPA module, and
* exposes an IPAInterface. This mechanism is used for IPAs that are not
* isolated in a separate process to allow direct calls from pipeline handler
* using the IPAInterface API instead of the lower-level ipa_context API.
*
* The IPAInterface methods are converted to the ipa_context API by translating
* all C++ arguments into plain C structures or byte arrays that contain no
* pointer, as required by the ipa_context API.
*/
/**
* \brief Construct an IPAContextWrapper instance that wraps the \a context
* \param[in] context The IPA module context
*
* Ownership of the \a context is passed to the IPAContextWrapper. The context remains
* valid for the whole lifetime of the wrapper and is destroyed automatically
* with it.
*/
IPAContextWrapper::IPAContextWrapper(struct ipa_context *context)
: ctx_(context), intf_(nullptr)
{
if (!ctx_)
return;
bool forceCApi = !!utils::secure_getenv("LIBCAMERA_IPA_FORCE_C_API");
if (!forceCApi && ctx_ && ctx_->ops->get_interface) {
intf_ = reinterpret_cast<IPAInterface *>(ctx_->ops->get_interface(ctx_));
intf_->queueFrameAction.connect(this, &IPAContextWrapper::doQueueFrameAction);
return;
}
ctx_->ops->register_callbacks(ctx_, &IPAContextWrapper::callbacks_,
this);
}
IPAContextWrapper::~IPAContextWrapper()
{
if (!ctx_)
return;
ctx_->ops->destroy(ctx_);
}
int IPAContextWrapper::init(const IPASettings &settings)
{
if (intf_)
return intf_->init(settings);
if (!ctx_)
return 0;
struct ipa_settings c_settings;
c_settings.configuration_file = settings.configurationFile.c_str();
ctx_->ops->init(ctx_, &c_settings);
return 0;
}
int IPAContextWrapper::start()
{
if (intf_)
return intf_->start();
if (!ctx_)
return 0;
return ctx_->ops->start(ctx_);
}
void IPAContextWrapper::stop()
{
if (intf_)
return intf_->stop();
if (!ctx_)
return;
ctx_->ops->stop(ctx_);
}
void IPAContextWrapper::configure(const CameraSensorInfo &sensorInfo,
const std::map<unsigned int, IPAStream> &streamConfig,
const std::map<unsigned int, const ControlInfoMap &> &entityControls)
{
if (intf_)
return intf_->configure(sensorInfo, streamConfig, entityControls);
if (!ctx_)
return;
serializer_.reset();
/* Translate the camera sensor info. */
struct ipa_sensor_info sensor_info = {};
sensor_info.model = sensorInfo.model.c_str();
sensor_info.bits_per_pixel = sensorInfo.bitsPerPixel;
sensor_info.active_area.width = sensorInfo.activeAreaSize.width;
sensor_info.active_area.height = sensorInfo.activeAreaSize.height;
sensor_info.analog_crop.left = sensorInfo.analogCrop.x;
sensor_info.analog_crop.top = sensorInfo.analogCrop.y;
sensor_info.analog_crop.width = sensorInfo.analogCrop.width;
sensor_info.analog_crop.height = sensorInfo.analogCrop.height;
sensor_info.output_size.width = sensorInfo.outputSize.width;
sensor_info.output_size.height = sensorInfo.outputSize.height;
sensor_info.pixel_rate = sensorInfo.pixelRate;
sensor_info.line_length = sensorInfo.lineLength;
/* Translate the IPA stream configurations map. */
struct ipa_stream c_streams[streamConfig.size()];
unsigned int i = 0;
for (const auto &stream : streamConfig) {
struct ipa_stream *c_stream = &c_streams[i];
unsigned int id = stream.first;
const IPAStream &ipaStream = stream.second;
c_stream->id = id;
c_stream->pixel_format = ipaStream.pixelFormat;
c_stream->width = ipaStream.size.width;
c_stream->height = ipaStream.size.height;
++i;
}
/* Translate the IPA entity controls map. */
struct ipa_control_info_map c_info_maps[entityControls.size()];
std::vector<std::vector<uint8_t>> data(entityControls.size());
i = 0;
for (const auto &info : entityControls) {
struct ipa_control_info_map &c_info_map = c_info_maps[i];
unsigned int id = info.first;
const ControlInfoMap &infoMap = info.second;
size_t infoMapSize = serializer_.binarySize(infoMap);
data[i].resize(infoMapSize);
ByteStreamBuffer byteStream(data[i].data(), data[i].size());
serializer_.serialize(infoMap, byteStream);
c_info_map.id = id;
c_info_map.data = byteStream.base();
c_info_map.size = byteStream.size();
++i;
}
ctx_->ops->configure(ctx_, &sensor_info, c_streams, streamConfig.size(),
c_info_maps, entityControls.size());
}
void IPAContextWrapper::mapBuffers(const std::vector<IPABuffer> &buffers)
{
if (intf_)
return intf_->mapBuffers(buffers);
if (!ctx_)
return;
struct ipa_buffer c_buffers[buffers.size()];
for (unsigned int i = 0; i < buffers.size(); ++i) {
struct ipa_buffer &c_buffer = c_buffers[i];
const IPABuffer &buffer = buffers[i];
const std::vector<FrameBuffer::Plane> &planes = buffer.planes;
c_buffer.id = buffer.id;
c_buffer.num_planes = planes.size();
for (unsigned int j = 0; j < planes.size(); ++j) {
const FrameBuffer::Plane &plane = planes[j];
c_buffer.planes[j].dmabuf = plane.fd.fd();
c_buffer.planes[j].length = plane.length;
}
}
ctx_->ops->map_buffers(ctx_, c_buffers, buffers.size());
}
void IPAContextWrapper::unmapBuffers(const std::vector<unsigned int> &ids)
{
if (intf_)
return intf_->unmapBuffers(ids);
if (!ctx_)
return;
ctx_->ops->unmap_buffers(ctx_, ids.data(), ids.size());
}
void IPAContextWrapper::processEvent(const IPAOperationData &data)
{
if (intf_)
return intf_->processEvent(data);
if (!ctx_)
return;
struct ipa_operation_data c_data;
c_data.operation = data.operation;
c_data.data = data.data.data();
c_data.num_data = data.data.size();
struct ipa_control_list control_lists[data.controls.size()];
c_data.lists = control_lists;
c_data.num_lists = data.controls.size();
std::size_t listsSize = 0;
for (const auto &list : data.controls)
listsSize += serializer_.binarySize(list);
std::vector<uint8_t> binaryData(listsSize);
ByteStreamBuffer byteStreamBuffer(binaryData.data(), listsSize);
unsigned int i = 0;
for (const auto &list : data.controls) {
struct ipa_control_list &c_list = control_lists[i];
c_list.size = serializer_.binarySize(list);
ByteStreamBuffer b = byteStreamBuffer.carveOut(c_list.size);
serializer_.serialize(list, b);
c_list.data = b.base();
}
ctx_->ops->process_event(ctx_, &c_data);
}
void IPAContextWrapper::doQueueFrameAction(unsigned int frame,
const IPAOperationData &data)
{
IPAInterface::queueFrameAction.emit(frame, data);
}
void IPAContextWrapper::queue_frame_action(void *ctx, unsigned int frame,
struct ipa_operation_data &data)
{
IPAContextWrapper *_this = static_cast<IPAContextWrapper *>(ctx);
IPAOperationData opData;
opData.operation = data.operation;
for (unsigned int i = 0; i < data.num_data; ++i)
opData.data.push_back(data.data[i]);
for (unsigned int i = 0; i < data.num_lists; ++i) {
const struct ipa_control_list &c_list = data.lists[i];
ByteStreamBuffer b(c_list.data, c_list.size);
opData.controls.push_back(_this->serializer_.deserialize<ControlList>(b));
}
_this->doQueueFrameAction(frame, opData);
}
#ifndef __DOXYGEN__
/*
* This construct confuses Doxygen and makes it believe that all members of the
|
