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
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* request.cpp - Capture request handling
*/
#include <libcamera/request.h>
#include <map>
#include <libcamera/buffer.h>
#include <libcamera/camera.h>
#include <libcamera/control_ids.h>
#include <libcamera/stream.h>
#include "camera_controls.h"
#include "log.h"
/**
* \file request.h
* \brief Describes a frame capture request to be processed by a camera
*/
namespace libcamera {
LOG_DEFINE_CATEGORY(Request)
/**
* \enum Request::Status
* Request completion status
* \var Request::RequestPending
* The request hasn't completed yet
* \var Request::RequestComplete
* The request has completed
* \var Request::RequestCancelled
* The request has been cancelled due to capture stop
*/
/**
* \class Request
* \brief A frame capture request
*
* A Request allows an application to associate buffers and controls on a
* per-frame basis to be queued to the camera device for processing.
*/
/**
* \brief Create a capture request for a camera
* \param[in] camera The camera that creates the request
* \param[in] cookie Opaque cookie for application use
*
* The \a cookie is stored in the request and is accessible through the
* cookie() method at any time. It is typically used by applications to map the
* request to an external resource in the request completion handler, and is
* completely opaque to libcamera.
*
*/
Request::Request(Camera *camera, uint64_t cookie)
: camera_(camera), cookie_(cookie), status_(RequestPending),
cancelled_(false)
{
/**
* \todo Should the Camera expose a validator instance, to avoid
* creating a new instance for each request?
*/
validator_ = new CameraControlValidator(camera);
controls_ = new ControlList(controls::controls, validator_);
/**
* \todo: Add a validator for metadata controls.
*/
metadata_ = new ControlList(controls::controls);
}
Request::~Request()
{
for (auto it : bufferMap_) {
Buffer *buffer = it.second;
delete buffer;
}
delete metadata_;
delete controls_;
delete validator_;
}
/**
* \fn Request::controls()
* \brief Retrieve the request's ControlList
*
* Requests store a list of controls to be applied to all frames captured for
* the request. They are created with an empty list of controls that can be
* accessed through this method and updated with ControlList::operator[]() or
* ControlList::update().
*
* Only controls supported by the camera to which this request will be
* submitted shall be included in the controls list. Attempting to add an
* unsupported control causes undefined behaviour.
*
* \return A reference to the ControlList in this request
*/
/**
* \fn Request::buffers()
* \brief Retrieve the request's streams to buffers map
*
* Return a reference to the map that associates each Stream part of the
* request to the Buffer the Stream output should be directed to.
*
* \return The map of Stream to Buffer
*/
/**
* \brief Store a Buffer with its associated Stream in the Request
* \param[in] buffer The Buffer to store in the request
*
* Ownership of the buffer is passed to the request. It will be deleted when
* the request is destroyed after completing.
*
* A request can only contain one buffer per stream. If a buffer has already
* been added to the request for the same stream, this method returns -EEXIST.
*
* \return 0 on success or a negative error code otherwise
* \retval -EEXIST The request already contains a buffer for the stream
* \retval -EINVAL The buffer does not reference a valid Stream
*/
int Request::addBuffer(std::unique_ptr<Buffer> buffer)
{
Stream *stream = buffer->stream();
if (!stream) {
LOG(Request, Error) << "Invalid stream reference";
return -EINVAL;
}
auto it = bufferMap_.find(stream);
if (it != bufferMap_.end()) {
LOG(Request, Error) << "Buffer already set for stream";
return -EEXIST;
}
buffer->setRequest(this);
pending_.insert(buffer.get());
bufferMap_[stream] = buffer.release();
return 0;
}
/**
* \var Request::bufferMap_
* \brief Mapping of streams to buffers for this request
*
* The bufferMap_ tracks the buffers associated with each stream. If a stream is
* not utilised in this request there will be no buffer for that stream in the
* map.
*/
/**
* \brief Return the buffer associated with a stream
* \param[in] stream The stream the buffer is associated to
* \return The buffer associated with the stream, or nullptr if the stream is
* not part of this request
*/
Buffer *Request::findBuffer(Stream *stream) const
{
auto it = bufferMap_.find(stream);
if (it == bufferMap_.end())
return nullptr;
return it->second;
}
/**
* \fn Request::metadata()
* \brief Retrieve the request's metadata
* \todo Offer a read-only API towards applications while keeping a read/write
* API internally.
* \return The metadata associated with the request
*/
/**
* \fn Request::cookie()
* \brief Retrieve the cookie set when the request was created
* \return The request cookie
*/
/**
* \fn Request::status()
* \brief Retrieve the request completion status
*
* The request status indicates whether the request has completed successfully
* or with an error. When requests are created and before they complete the
* request status is set to RequestPending, and is updated at completion time
* to RequestComplete. If a request is cancelled at capture stop before it has
* completed, its status is set to RequestCancelled.
*
* \return The request completion status
*/
/**
* \fn Request::hasPendingBuffers()
* \brief Check if a request has buffers yet to be completed
*
* \return True if the request has buffers pending for completion, false
* otherwise
*/
/**
* \brief Complete a queued request
*
* Mark the request as complete by updating its status to RequestComplete,
* unless buffers have been cancelled in which case the status is set to
* RequestCancelled.
*/
void Request::complete()
{
ASSERT(!hasPendingBuffers());
status_ = cancelled_ ? RequestCancelled : RequestComplete;
}
/**
* \brief Complete a buffer for the request
* \param[in] buffer The buffer that has completed
*
* A request tracks the status of all buffers it contains through a set of
* pending buffers. This function removes the \a buffer from the set to mark it
* as complete. All buffers associate with the request shall be marked as
* complete by calling this function once and once only before reporting the
* request as complete with the complete() method.
*
* \return True if all buffers contained in the request have completed, false
* otherwise
*/
bool Request::completeBuffer(Buffer *buffer)
{
int ret = pending_.erase(buffer);
ASSERT(ret == 1);
buffer->setRequest(nullptr);
if (buffer->status() == Buffer::BufferCancelled)
cancelled_ = true;
return !hasPendingBuffers();
}
} /* namespace libcamera */
|
