1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "Camera3-ZslStream"
18 #define ATRACE_TAG ATRACE_TAG_CAMERA
19 //#define LOG_NDEBUG 0
20
21 #include <inttypes.h>
22
23 #include <utils/Log.h>
24 #include <utils/Trace.h>
25 #include "Camera3ZslStream.h"
26
27 typedef android::RingBufferConsumer::PinnedBufferItem PinnedBufferItem;
28
29 namespace android {
30
31 namespace camera3 {
32
33 namespace {
34 struct TimestampFinder : public RingBufferConsumer::RingBufferComparator {
35 typedef RingBufferConsumer::BufferInfo BufferInfo;
36
37 enum {
38 SELECT_I1 = -1,
39 SELECT_I2 = 1,
40 SELECT_NEITHER = 0,
41 };
42
TimestampFinderandroid::camera3::__anon6a6c66840111::TimestampFinder43 TimestampFinder(nsecs_t timestamp) : mTimestamp(timestamp) {}
~TimestampFinderandroid::camera3::__anon6a6c66840111::TimestampFinder44 ~TimestampFinder() {}
45
46 template <typename T>
swapandroid::camera3::__anon6a6c66840111::TimestampFinder47 static void swap(T& a, T& b) {
48 T tmp = a;
49 a = b;
50 b = tmp;
51 }
52
53 /**
54 * Try to find the best candidate for a ZSL buffer.
55 * Match priority from best to worst:
56 * 1) Timestamps match.
57 * 2) Timestamp is closest to the needle (and lower).
58 * 3) Timestamp is closest to the needle (and higher).
59 *
60 */
compareandroid::camera3::__anon6a6c66840111::TimestampFinder61 virtual int compare(const BufferInfo *i1,
62 const BufferInfo *i2) const {
63 // Try to select non-null object first.
64 if (i1 == NULL) {
65 return SELECT_I2;
66 } else if (i2 == NULL) {
67 return SELECT_I1;
68 }
69
70 // Best result: timestamp is identical
71 if (i1->mTimestamp == mTimestamp) {
72 return SELECT_I1;
73 } else if (i2->mTimestamp == mTimestamp) {
74 return SELECT_I2;
75 }
76
77 const BufferInfo* infoPtrs[2] = {
78 i1,
79 i2
80 };
81 int infoSelectors[2] = {
82 SELECT_I1,
83 SELECT_I2
84 };
85
86 // Order i1,i2 so that always i1.timestamp < i2.timestamp
87 if (i1->mTimestamp > i2->mTimestamp) {
88 swap(infoPtrs[0], infoPtrs[1]);
89 swap(infoSelectors[0], infoSelectors[1]);
90 }
91
92 // Second best: closest (lower) timestamp
93 if (infoPtrs[1]->mTimestamp < mTimestamp) {
94 return infoSelectors[1];
95 } else if (infoPtrs[0]->mTimestamp < mTimestamp) {
96 return infoSelectors[0];
97 }
98
99 // Worst: closest (higher) timestamp
100 return infoSelectors[0];
101
102 /**
103 * The above cases should cover all the possibilities,
104 * and we get an 'empty' result only if the ring buffer
105 * was empty itself
106 */
107 }
108
109 const nsecs_t mTimestamp;
110 }; // struct TimestampFinder
111 } // namespace anonymous
112
Camera3ZslStream(int id,uint32_t width,uint32_t height,int bufferCount)113 Camera3ZslStream::Camera3ZslStream(int id, uint32_t width, uint32_t height,
114 int bufferCount) :
115 Camera3OutputStream(id, CAMERA3_STREAM_BIDIRECTIONAL,
116 width, height,
117 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
118 HAL_DATASPACE_UNKNOWN, CAMERA3_STREAM_ROTATION_0),
119 mDepth(bufferCount) {
120
121 sp<IGraphicBufferProducer> producer;
122 sp<IGraphicBufferConsumer> consumer;
123 BufferQueue::createBufferQueue(&producer, &consumer);
124 mProducer = new RingBufferConsumer(consumer, GRALLOC_USAGE_HW_CAMERA_ZSL, bufferCount);
125 mProducer->setName(String8("Camera2-ZslRingBufferConsumer"));
126 mConsumer = new Surface(producer);
127 }
128
~Camera3ZslStream()129 Camera3ZslStream::~Camera3ZslStream() {
130 }
131
getInputBufferLocked(camera3_stream_buffer * buffer)132 status_t Camera3ZslStream::getInputBufferLocked(camera3_stream_buffer *buffer) {
133 ATRACE_CALL();
134
135 status_t res;
136
137 // TODO: potentially register from inputBufferLocked
138 // this should be ok, registerBuffersLocked only calls getBuffer for now
139 // register in output mode instead of input mode for ZSL streams.
140 if (mState == STATE_IN_CONFIG || mState == STATE_IN_RECONFIG) {
141 ALOGE("%s: Stream %d: Buffer registration for input streams"
142 " not implemented (state %d)",
143 __FUNCTION__, mId, mState);
144 return INVALID_OPERATION;
145 }
146
147 if ((res = getBufferPreconditionCheckLocked()) != OK) {
148 return res;
149 }
150
151 ANativeWindowBuffer* anb;
152 int fenceFd;
153
154 assert(mProducer != 0);
155
156 sp<PinnedBufferItem> bufferItem;
157 {
158 List<sp<RingBufferConsumer::PinnedBufferItem> >::iterator it, end;
159 it = mInputBufferQueue.begin();
160 end = mInputBufferQueue.end();
161
162 // Need to call enqueueInputBufferByTimestamp as a prerequisite
163 if (it == end) {
164 ALOGE("%s: Stream %d: No input buffer was queued",
165 __FUNCTION__, mId);
166 return INVALID_OPERATION;
167 }
168 bufferItem = *it;
169 mInputBufferQueue.erase(it);
170 }
171
172 anb = bufferItem->getBufferItem().mGraphicBuffer->getNativeBuffer();
173 assert(anb != NULL);
174 fenceFd = bufferItem->getBufferItem().mFence->dup();
175
176 /**
177 * FenceFD now owned by HAL except in case of error,
178 * in which case we reassign it to acquire_fence
179 */
180 handoutBufferLocked(*buffer, &(anb->handle), /*acquireFence*/fenceFd,
181 /*releaseFence*/-1, CAMERA3_BUFFER_STATUS_OK, /*output*/false);
182
183 mBuffersInFlight.push_back(bufferItem);
184
185 return OK;
186 }
187
returnBufferCheckedLocked(const camera3_stream_buffer & buffer,nsecs_t timestamp,bool output,sp<Fence> * releaseFenceOut)188 status_t Camera3ZslStream::returnBufferCheckedLocked(
189 const camera3_stream_buffer &buffer,
190 nsecs_t timestamp,
191 bool output,
192 /*out*/
193 sp<Fence> *releaseFenceOut) {
194
195 if (output) {
196 // Output stream path
197 return Camera3OutputStream::returnBufferCheckedLocked(buffer,
198 timestamp,
199 output,
200 releaseFenceOut);
201 }
202
203 /**
204 * Input stream path
205 */
206 bool bufferFound = false;
207 sp<PinnedBufferItem> bufferItem;
208 {
209 // Find the buffer we are returning
210 Vector<sp<PinnedBufferItem> >::iterator it, end;
211 for (it = mBuffersInFlight.begin(), end = mBuffersInFlight.end();
212 it != end;
213 ++it) {
214
215 const sp<PinnedBufferItem>& tmp = *it;
216 ANativeWindowBuffer *anb =
217 tmp->getBufferItem().mGraphicBuffer->getNativeBuffer();
218 if (anb != NULL && &(anb->handle) == buffer.buffer) {
219 bufferFound = true;
220 bufferItem = tmp;
221 mBuffersInFlight.erase(it);
222 break;
223 }
224 }
225 }
226 if (!bufferFound) {
227 ALOGE("%s: Stream %d: Can't return buffer that wasn't sent to HAL",
228 __FUNCTION__, mId);
229 return INVALID_OPERATION;
230 }
231
232 int releaseFenceFd = buffer.release_fence;
233
234 if (buffer.status == CAMERA3_BUFFER_STATUS_ERROR) {
235 if (buffer.release_fence != -1) {
236 ALOGE("%s: Stream %d: HAL should not set release_fence(%d) when "
237 "there is an error", __FUNCTION__, mId, buffer.release_fence);
238 close(buffer.release_fence);
239 }
240
241 /**
242 * Reassign release fence as the acquire fence incase of error
243 */
244 releaseFenceFd = buffer.acquire_fence;
245 }
246
247 /**
248 * Unconditionally return buffer to the buffer queue.
249 * - Fwk takes over the release_fence ownership
250 */
251 sp<Fence> releaseFence = new Fence(releaseFenceFd);
252 bufferItem->getBufferItem().mFence = releaseFence;
253 bufferItem.clear(); // dropping last reference unpins buffer
254
255 *releaseFenceOut = releaseFence;
256
257 return OK;
258 }
259
returnInputBufferLocked(const camera3_stream_buffer & buffer)260 status_t Camera3ZslStream::returnInputBufferLocked(
261 const camera3_stream_buffer &buffer) {
262 ATRACE_CALL();
263
264 status_t res = returnAnyBufferLocked(buffer, /*timestamp*/0,
265 /*output*/false);
266
267 return res;
268 }
269
dump(int fd,const Vector<String16> & args) const270 void Camera3ZslStream::dump(int fd, const Vector<String16> &args) const {
271 (void) args;
272
273 String8 lines;
274 lines.appendFormat(" Stream[%d]: ZSL\n", mId);
275 write(fd, lines.string(), lines.size());
276
277 Camera3IOStreamBase::dump(fd, args);
278
279 lines = String8();
280 lines.appendFormat(" Input buffers pending: %zu, in flight %zu\n",
281 mInputBufferQueue.size(), mBuffersInFlight.size());
282 write(fd, lines.string(), lines.size());
283 }
284
enqueueInputBufferByTimestamp(nsecs_t timestamp,nsecs_t * actualTimestamp)285 status_t Camera3ZslStream::enqueueInputBufferByTimestamp(
286 nsecs_t timestamp,
287 nsecs_t* actualTimestamp) {
288
289 Mutex::Autolock l(mLock);
290
291 TimestampFinder timestampFinder = TimestampFinder(timestamp);
292
293 sp<RingBufferConsumer::PinnedBufferItem> pinnedBuffer =
294 mProducer->pinSelectedBuffer(timestampFinder,
295 /*waitForFence*/false);
296
297 if (pinnedBuffer == 0) {
298 ALOGE("%s: No ZSL buffers were available yet", __FUNCTION__);
299 return NO_BUFFER_AVAILABLE;
300 }
301
302 nsecs_t actual = pinnedBuffer->getBufferItem().mTimestamp;
303
304 if (actual != timestamp) {
305 // TODO: this is problematic, we'll end up with using wrong result for this pinned buffer.
306 ALOGW("%s: ZSL buffer candidate search didn't find an exact match --"
307 " requested timestamp = %" PRId64 ", actual timestamp = %" PRId64,
308 __FUNCTION__, timestamp, actual);
309 }
310
311 mInputBufferQueue.push_back(pinnedBuffer);
312
313 if (actualTimestamp != NULL) {
314 *actualTimestamp = actual;
315 }
316
317 return OK;
318 }
319
clearInputRingBuffer(nsecs_t * latestTimestamp)320 status_t Camera3ZslStream::clearInputRingBuffer(nsecs_t* latestTimestamp) {
321 Mutex::Autolock l(mLock);
322
323 return clearInputRingBufferLocked(latestTimestamp);
324 }
325
clearInputRingBufferLocked(nsecs_t * latestTimestamp)326 status_t Camera3ZslStream::clearInputRingBufferLocked(nsecs_t* latestTimestamp) {
327
328 if (latestTimestamp) {
329 *latestTimestamp = mProducer->getLatestTimestamp();
330 }
331 mInputBufferQueue.clear();
332
333 return mProducer->clear();
334 }
335
disconnectLocked()336 status_t Camera3ZslStream::disconnectLocked() {
337 clearInputRingBufferLocked(NULL);
338
339 return Camera3OutputStream::disconnectLocked();
340 }
341
setTransform(int)342 status_t Camera3ZslStream::setTransform(int /*transform*/) {
343 ALOGV("%s: Not implemented", __FUNCTION__);
344 return INVALID_OPERATION;
345 }
346
347 }; // namespace camera3
348
349 }; // namespace android
350