blob: 169eb82d43e09377c438120cfb294ac8245c4d38 [file] [log] [blame]
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -08001/*
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-OutputStream"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080021#include <utils/Log.h>
22#include <utils/Trace.h>
23#include "Camera3OutputStream.h"
24
25#ifndef container_of
26#define container_of(ptr, type, member) \
27 (type *)((char*)(ptr) - offsetof(type, member))
28#endif
29
30namespace android {
31
32namespace camera3 {
33
34Camera3OutputStream::Camera3OutputStream(int id,
35 sp<ANativeWindow> consumer,
36 uint32_t width, uint32_t height, int format) :
Igor Murashkine3a9f962013-05-08 18:03:15 -070037 Camera3IOStreamBase(id, CAMERA3_STREAM_OUTPUT, width, height,
38 /*maxSize*/0, format),
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080039 mConsumer(consumer),
Igor Murashkine3a9f962013-05-08 18:03:15 -070040 mTransform(0) {
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080041
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080042 if (mConsumer == NULL) {
43 ALOGE("%s: Consumer is NULL!", __FUNCTION__);
44 mState = STATE_ERROR;
45 }
46}
47
48Camera3OutputStream::Camera3OutputStream(int id,
49 sp<ANativeWindow> consumer,
50 uint32_t width, uint32_t height, size_t maxSize, int format) :
Igor Murashkine3a9f962013-05-08 18:03:15 -070051 Camera3IOStreamBase(id, CAMERA3_STREAM_OUTPUT, width, height, maxSize,
52 format),
Igor Murashkina55b5452013-04-02 16:36:33 -070053 mConsumer(consumer),
Igor Murashkine3a9f962013-05-08 18:03:15 -070054 mTransform(0) {
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080055
56 if (format != HAL_PIXEL_FORMAT_BLOB) {
57 ALOGE("%s: Bad format for size-only stream: %d", __FUNCTION__,
58 format);
59 mState = STATE_ERROR;
60 }
61
62 if (mConsumer == NULL) {
63 ALOGE("%s: Consumer is NULL!", __FUNCTION__);
64 mState = STATE_ERROR;
65 }
66}
67
Igor Murashkine3a9f962013-05-08 18:03:15 -070068Camera3OutputStream::Camera3OutputStream(int id, camera3_stream_type_t type,
69 uint32_t width, uint32_t height,
70 int format) :
71 Camera3IOStreamBase(id, type, width, height,
72 /*maxSize*/0,
73 format),
74 mTransform(0) {
75
76 // Subclasses expected to initialize mConsumer themselves
77}
78
79
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080080Camera3OutputStream::~Camera3OutputStream() {
81 disconnectLocked();
82}
83
84status_t Camera3OutputStream::getBufferLocked(camera3_stream_buffer *buffer) {
85 ATRACE_CALL();
86 status_t res;
87
Igor Murashkine3a9f962013-05-08 18:03:15 -070088 if ((res = getBufferPreconditionCheckLocked()) != OK) {
89 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080090 }
91
92 ANativeWindowBuffer* anb;
93 int fenceFd;
94
Zhijun He15ad2472013-10-11 16:21:11 -070095 /**
96 * Release the lock briefly to avoid deadlock for below scenario:
97 * Thread 1: StreamingProcessor::startStream -> Camera3Stream::isConfiguring().
98 * This thread acquired StreamingProcessor lock and try to lock Camera3Stream lock.
99 * Thread 2: Camera3Stream::returnBuffer->StreamingProcessor::onFrameAvailable().
100 * This thread acquired Camera3Stream lock and bufferQueue lock, and try to lock
101 * StreamingProcessor lock.
102 * Thread 3: Camera3Stream::getBuffer(). This thread acquired Camera3Stream lock
103 * and try to lock bufferQueue lock.
104 * Then there is circular locking dependency.
105 */
106 sp<ANativeWindow> currentConsumer = mConsumer;
107 mLock.unlock();
108
109 res = currentConsumer->dequeueBuffer(currentConsumer.get(), &anb, &fenceFd);
110 mLock.lock();
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800111 if (res != OK) {
112 ALOGE("%s: Stream %d: Can't dequeue next output buffer: %s (%d)",
113 __FUNCTION__, mId, strerror(-res), res);
114 return res;
115 }
116
Igor Murashkine3a9f962013-05-08 18:03:15 -0700117 /**
118 * FenceFD now owned by HAL except in case of error,
119 * in which case we reassign it to acquire_fence
120 */
121 handoutBufferLocked(*buffer, &(anb->handle), /*acquireFence*/fenceFd,
Zhijun He6adc9cc2014-04-15 14:09:55 -0700122 /*releaseFence*/-1, CAMERA3_BUFFER_STATUS_OK, /*output*/true);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800123
124 return OK;
125}
126
127status_t Camera3OutputStream::returnBufferLocked(
128 const camera3_stream_buffer &buffer,
129 nsecs_t timestamp) {
130 ATRACE_CALL();
Igor Murashkine3a9f962013-05-08 18:03:15 -0700131
132 status_t res = returnAnyBufferLocked(buffer, timestamp, /*output*/true);
133
134 if (res != OK) {
135 return res;
136 }
137
138 mLastTimestamp = timestamp;
139
140 return OK;
141}
142
143status_t Camera3OutputStream::returnBufferCheckedLocked(
144 const camera3_stream_buffer &buffer,
145 nsecs_t timestamp,
146 bool output,
147 /*out*/
148 sp<Fence> *releaseFenceOut) {
149
150 (void)output;
151 ALOG_ASSERT(output, "Expected output to be true");
152
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800153 status_t res;
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700154 sp<Fence> releaseFence;
155
156 /**
157 * Fence management - calculate Release Fence
158 */
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800159 if (buffer.status == CAMERA3_BUFFER_STATUS_ERROR) {
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700160 if (buffer.release_fence != -1) {
161 ALOGE("%s: Stream %d: HAL should not set release_fence(%d) when "
162 "there is an error", __FUNCTION__, mId, buffer.release_fence);
163 close(buffer.release_fence);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800164 }
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700165
166 /**
167 * Reassign release fence as the acquire fence in case of error
168 */
169 releaseFence = new Fence(buffer.acquire_fence);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800170 } else {
171 res = native_window_set_buffers_timestamp(mConsumer.get(), timestamp);
172 if (res != OK) {
173 ALOGE("%s: Stream %d: Error setting timestamp: %s (%d)",
Igor Murashkine3a9f962013-05-08 18:03:15 -0700174 __FUNCTION__, mId, strerror(-res), res);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800175 return res;
176 }
177
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700178 releaseFence = new Fence(buffer.release_fence);
179 }
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800180
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700181 int anwReleaseFence = releaseFence->dup();
182
183 /**
Zhijun He124ccf42013-05-22 14:01:30 -0700184 * Release the lock briefly to avoid deadlock with
185 * StreamingProcessor::startStream -> Camera3Stream::isConfiguring (this
186 * thread will go into StreamingProcessor::onFrameAvailable) during
187 * queueBuffer
188 */
189 sp<ANativeWindow> currentConsumer = mConsumer;
190 mLock.unlock();
191
192 /**
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700193 * Return buffer back to ANativeWindow
194 */
195 if (buffer.status == CAMERA3_BUFFER_STATUS_ERROR) {
196 // Cancel buffer
Zhijun He124ccf42013-05-22 14:01:30 -0700197 res = currentConsumer->cancelBuffer(currentConsumer.get(),
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700198 container_of(buffer.buffer, ANativeWindowBuffer, handle),
199 anwReleaseFence);
200 if (res != OK) {
201 ALOGE("%s: Stream %d: Error cancelling buffer to native window:"
Igor Murashkine3a9f962013-05-08 18:03:15 -0700202 " %s (%d)", __FUNCTION__, mId, strerror(-res), res);
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700203 }
204 } else {
Zhijun He124ccf42013-05-22 14:01:30 -0700205 res = currentConsumer->queueBuffer(currentConsumer.get(),
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800206 container_of(buffer.buffer, ANativeWindowBuffer, handle),
207 anwReleaseFence);
208 if (res != OK) {
Igor Murashkine3a9f962013-05-08 18:03:15 -0700209 ALOGE("%s: Stream %d: Error queueing buffer to native window: "
210 "%s (%d)", __FUNCTION__, mId, strerror(-res), res);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800211 }
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800212 }
Zhijun He124ccf42013-05-22 14:01:30 -0700213 mLock.lock();
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700214 if (res != OK) {
215 close(anwReleaseFence);
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700216 }
217
Igor Murashkine3a9f962013-05-08 18:03:15 -0700218 *releaseFenceOut = releaseFence;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800219
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700220 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800221}
222
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800223void Camera3OutputStream::dump(int fd, const Vector<String16> &args) const {
224 (void) args;
225 String8 lines;
226 lines.appendFormat(" Stream[%d]: Output\n", mId);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800227 write(fd, lines.string(), lines.size());
Igor Murashkine3a9f962013-05-08 18:03:15 -0700228
229 Camera3IOStreamBase::dump(fd, args);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800230}
231
232status_t Camera3OutputStream::setTransform(int transform) {
233 ATRACE_CALL();
234 Mutex::Autolock l(mLock);
235 return setTransformLocked(transform);
236}
237
238status_t Camera3OutputStream::setTransformLocked(int transform) {
239 status_t res = OK;
240 if (mState == STATE_ERROR) {
241 ALOGE("%s: Stream in error state", __FUNCTION__);
242 return INVALID_OPERATION;
243 }
244
245 mTransform = transform;
246 if (mState == STATE_CONFIGURED) {
247 res = native_window_set_buffers_transform(mConsumer.get(),
248 transform);
249 if (res != OK) {
250 ALOGE("%s: Unable to configure stream transform to %x: %s (%d)",
251 __FUNCTION__, transform, strerror(-res), res);
252 }
253 }
254 return res;
255}
256
257status_t Camera3OutputStream::configureQueueLocked() {
258 status_t res;
259
Igor Murashkine3a9f962013-05-08 18:03:15 -0700260 if ((res = Camera3IOStreamBase::configureQueueLocked()) != OK) {
261 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800262 }
263
Igor Murashkine3a9f962013-05-08 18:03:15 -0700264 ALOG_ASSERT(mConsumer != 0, "mConsumer should never be NULL");
265
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800266 // Configure consumer-side ANativeWindow interface
267 res = native_window_api_connect(mConsumer.get(),
268 NATIVE_WINDOW_API_CAMERA);
269 if (res != OK) {
270 ALOGE("%s: Unable to connect to native window for stream %d",
271 __FUNCTION__, mId);
272 return res;
273 }
274
275 res = native_window_set_usage(mConsumer.get(), camera3_stream::usage);
276 if (res != OK) {
277 ALOGE("%s: Unable to configure usage %08x for stream %d",
278 __FUNCTION__, camera3_stream::usage, mId);
279 return res;
280 }
281
282 res = native_window_set_scaling_mode(mConsumer.get(),
283 NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
284 if (res != OK) {
285 ALOGE("%s: Unable to configure stream scaling: %s (%d)",
286 __FUNCTION__, strerror(-res), res);
287 return res;
288 }
289
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800290 if (mMaxSize == 0) {
291 // For buffers of known size
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700292 res = native_window_set_buffers_dimensions(mConsumer.get(),
293 camera3_stream::width, camera3_stream::height);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800294 } else {
295 // For buffers with bounded size
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700296 res = native_window_set_buffers_dimensions(mConsumer.get(),
297 mMaxSize, 1);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800298 }
299 if (res != OK) {
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700300 ALOGE("%s: Unable to configure stream buffer dimensions"
301 " %d x %d (maxSize %zu) for stream %d",
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800302 __FUNCTION__, camera3_stream::width, camera3_stream::height,
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700303 mMaxSize, mId);
304 return res;
305 }
306 res = native_window_set_buffers_format(mConsumer.get(),
307 camera3_stream::format);
308 if (res != OK) {
309 ALOGE("%s: Unable to configure stream buffer format %#x for stream %d",
310 __FUNCTION__, camera3_stream::format, mId);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800311 return res;
312 }
313
314 int maxConsumerBuffers;
315 res = mConsumer->query(mConsumer.get(),
316 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
317 if (res != OK) {
318 ALOGE("%s: Unable to query consumer undequeued"
319 " buffer count for stream %d", __FUNCTION__, mId);
320 return res;
321 }
322
Alex Ray20cb3002013-05-28 20:18:22 -0700323 ALOGV("%s: Consumer wants %d buffers, HAL wants %d", __FUNCTION__,
324 maxConsumerBuffers, camera3_stream::max_buffers);
325 if (camera3_stream::max_buffers == 0) {
Zhijun He2ab500c2013-07-23 08:02:53 -0700326 ALOGE("%s: Camera HAL requested max_buffer count: %d, requires at least 1",
Alex Ray20cb3002013-05-28 20:18:22 -0700327 __FUNCTION__, camera3_stream::max_buffers);
328 return INVALID_OPERATION;
329 }
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800330
331 mTotalBufferCount = maxConsumerBuffers + camera3_stream::max_buffers;
Zhijun He6adc9cc2014-04-15 14:09:55 -0700332 mHandoutTotalBufferCount = 0;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800333 mFrameCount = 0;
334 mLastTimestamp = 0;
335
336 res = native_window_set_buffer_count(mConsumer.get(),
337 mTotalBufferCount);
338 if (res != OK) {
339 ALOGE("%s: Unable to set buffer count for stream %d",
340 __FUNCTION__, mId);
341 return res;
342 }
343
344 res = native_window_set_buffers_transform(mConsumer.get(),
345 mTransform);
346 if (res != OK) {
347 ALOGE("%s: Unable to configure stream transform to %x: %s (%d)",
348 __FUNCTION__, mTransform, strerror(-res), res);
349 }
350
351 return OK;
352}
353
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800354status_t Camera3OutputStream::disconnectLocked() {
355 status_t res;
356
Igor Murashkine3a9f962013-05-08 18:03:15 -0700357 if ((res = Camera3IOStreamBase::disconnectLocked()) != OK) {
358 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800359 }
360
Igor Murashkine3a9f962013-05-08 18:03:15 -0700361 res = native_window_api_disconnect(mConsumer.get(),
362 NATIVE_WINDOW_API_CAMERA);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800363
364 /**
365 * This is not an error. if client calling process dies, the window will
366 * also die and all calls to it will return DEAD_OBJECT, thus it's already
367 * "disconnected"
368 */
369 if (res == DEAD_OBJECT) {
370 ALOGW("%s: While disconnecting stream %d from native window, the"
371 " native window died from under us", __FUNCTION__, mId);
372 }
373 else if (res != OK) {
Igor Murashkine3a9f962013-05-08 18:03:15 -0700374 ALOGE("%s: Unable to disconnect stream %d from native window "
375 "(error %d %s)",
376 __FUNCTION__, mId, res, strerror(-res));
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800377 mState = STATE_ERROR;
378 return res;
379 }
380
Igor Murashkine3a9f962013-05-08 18:03:15 -0700381 mState = (mState == STATE_IN_RECONFIG) ? STATE_IN_CONFIG
382 : STATE_CONSTRUCTED;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800383 return OK;
384}
385
Eino-Ville Talvalab2f5b192013-07-30 14:36:03 -0700386status_t Camera3OutputStream::getEndpointUsage(uint32_t *usage) {
387
388 status_t res;
389 int32_t u = 0;
390 res = mConsumer->query(mConsumer.get(),
391 NATIVE_WINDOW_CONSUMER_USAGE_BITS, &u);
392 *usage = u;
393
394 return res;
395}
396
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800397}; // namespace camera3
398
399}; // namespace android