blob: b8221782030b1d12ee56f63ac9df3fd22a39b099 [file] [log] [blame]
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -08001/*
Shuzhen Wangc28189a2017-11-27 23:05:10 -08002 * Copyright (C) 2013-2018 The Android Open Source Project
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -08003 *
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
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -080021#include <ctime>
22#include <fstream>
23
24#include <android-base/unique_fd.h>
Shuzhen Wange4adddb2021-09-21 15:24:44 -070025#include <cutils/properties.h>
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -080026#include <ui/GraphicBuffer.h>
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080027#include <utils/Log.h>
28#include <utils/Trace.h>
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -080029
30#include "api1/client2/JpegProcessor.h"
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080031#include "Camera3OutputStream.h"
Jayant Chowdharyd4776262020-06-23 23:45:57 -070032#include "utils/TraceHFR.h"
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080033
34#ifndef container_of
35#define container_of(ptr, type, member) \
36 (type *)((char*)(ptr) - offsetof(type, member))
37#endif
38
39namespace android {
40
41namespace camera3 {
42
43Camera3OutputStream::Camera3OutputStream(int id,
Eino-Ville Talvala727d1722015-06-09 13:44:19 -070044 sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -080045 uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -070046 android_dataspace dataSpace, camera_stream_rotation_t rotation,
Shuzhen Wangc28189a2017-11-27 23:05:10 -080047 nsecs_t timestampOffset, const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -080048 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peevc81a7592022-02-14 17:38:18 -080049 int setId, bool isMultiResolution, int64_t dynamicRangeProfile,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -080050 int64_t streamUseCase, bool deviceTimeBaseIsRealtime, int timestampBase,
Shuzhen Wang610d7b82022-02-08 14:37:22 -080051 int mirrorMode) :
Emilian Peevf4816702020-04-03 15:44:51 -070052 Camera3IOStreamBase(id, CAMERA_STREAM_OUTPUT, width, height,
Shuzhen Wangc28189a2017-11-27 23:05:10 -080053 /*maxSize*/0, format, dataSpace, rotation,
Emilian Peev2295df72021-11-12 18:14:10 -080054 physicalCameraId, sensorPixelModesUsed, setId, isMultiResolution,
Shuzhen Wange4208922022-02-01 16:52:48 -080055 dynamicRangeProfile, streamUseCase, deviceTimeBaseIsRealtime,
56 timestampBase),
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080057 mConsumer(consumer),
Ruchit Sharmae0711f22014-08-18 13:48:24 -040058 mTransform(0),
Zhijun He125684a2015-12-26 15:07:30 -080059 mTraceFirstBuffer(true),
Shuzhen Wangc28dccc2016-02-11 23:48:46 -080060 mUseBufferManager(false),
Zhijun He5d677d12016-05-29 16:52:39 -070061 mTimestampOffset(timestampOffset),
Shuzhen Wang686f6442017-06-20 16:16:04 -070062 mConsumerUsage(0),
Chien-Yu Chena936ac22017-10-23 15:59:49 -070063 mDropBuffers(false),
Shuzhen Wang610d7b82022-02-08 14:37:22 -080064 mMirrorMode(mirrorMode),
Shuzhen Wang686f6442017-06-20 16:16:04 -070065 mDequeueBufferLatency(kDequeueLatencyBinSize) {
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080066
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080067 if (mConsumer == NULL) {
68 ALOGE("%s: Consumer is NULL!", __FUNCTION__);
69 mState = STATE_ERROR;
70 }
Zhijun He125684a2015-12-26 15:07:30 -080071
Shuzhen Wang0160ddd2019-08-15 09:11:56 -070072 bool needsReleaseNotify = setId > CAMERA3_STREAM_SET_ID_INVALID;
73 mBufferProducerListener = new BufferProducerListener(this, needsReleaseNotify);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080074}
75
76Camera3OutputStream::Camera3OutputStream(int id,
Eino-Ville Talvala727d1722015-06-09 13:44:19 -070077 sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -080078 uint32_t width, uint32_t height, size_t maxSize, int format,
Emilian Peevf4816702020-04-03 15:44:51 -070079 android_dataspace dataSpace, camera_stream_rotation_t rotation,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -080080 nsecs_t timestampOffset, const String8& physicalCameraId,
81 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peevc81a7592022-02-14 17:38:18 -080082 int setId, bool isMultiResolution, int64_t dynamicRangeProfile,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -080083 int64_t streamUseCase, bool deviceTimeBaseIsRealtime, int timestampBase,
Shuzhen Wang610d7b82022-02-08 14:37:22 -080084 int mirrorMode) :
Emilian Peevf4816702020-04-03 15:44:51 -070085 Camera3IOStreamBase(id, CAMERA_STREAM_OUTPUT, width, height, maxSize,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -080086 format, dataSpace, rotation, physicalCameraId, sensorPixelModesUsed,
Shuzhen Wange4208922022-02-01 16:52:48 -080087 setId, isMultiResolution, dynamicRangeProfile, streamUseCase,
88 deviceTimeBaseIsRealtime, timestampBase),
Igor Murashkina55b5452013-04-02 16:36:33 -070089 mConsumer(consumer),
Ruchit Sharmae0711f22014-08-18 13:48:24 -040090 mTransform(0),
Zhijun He125684a2015-12-26 15:07:30 -080091 mTraceFirstBuffer(true),
Shuzhen Wangc28dccc2016-02-11 23:48:46 -080092 mUseBufferManager(false),
Zhijun He5d677d12016-05-29 16:52:39 -070093 mTimestampOffset(timestampOffset),
Shuzhen Wang686f6442017-06-20 16:16:04 -070094 mConsumerUsage(0),
Chien-Yu Chena936ac22017-10-23 15:59:49 -070095 mDropBuffers(false),
Shuzhen Wang610d7b82022-02-08 14:37:22 -080096 mMirrorMode(mirrorMode),
Shuzhen Wang686f6442017-06-20 16:16:04 -070097 mDequeueBufferLatency(kDequeueLatencyBinSize) {
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080098
Yin-Chia Yehe9154ce2015-12-07 14:38:04 -080099 if (format != HAL_PIXEL_FORMAT_BLOB && format != HAL_PIXEL_FORMAT_RAW_OPAQUE) {
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800100 ALOGE("%s: Bad format for size-only stream: %d", __FUNCTION__,
101 format);
102 mState = STATE_ERROR;
103 }
104
105 if (mConsumer == NULL) {
106 ALOGE("%s: Consumer is NULL!", __FUNCTION__);
107 mState = STATE_ERROR;
108 }
Zhijun He125684a2015-12-26 15:07:30 -0800109
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700110 bool needsReleaseNotify = setId > CAMERA3_STREAM_SET_ID_INVALID;
111 mBufferProducerListener = new BufferProducerListener(this, needsReleaseNotify);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800112}
113
Zhijun He5d677d12016-05-29 16:52:39 -0700114Camera3OutputStream::Camera3OutputStream(int id,
115 uint32_t width, uint32_t height, int format,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100116 uint64_t consumerUsage, android_dataspace dataSpace,
Emilian Peevf4816702020-04-03 15:44:51 -0700117 camera_stream_rotation_t rotation, nsecs_t timestampOffset,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800118 const String8& physicalCameraId,
119 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peevc81a7592022-02-14 17:38:18 -0800120 int setId, bool isMultiResolution, int64_t dynamicRangeProfile,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800121 int64_t streamUseCase, bool deviceTimeBaseIsRealtime, int timestampBase,
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800122 int mirrorMode) :
Emilian Peevf4816702020-04-03 15:44:51 -0700123 Camera3IOStreamBase(id, CAMERA_STREAM_OUTPUT, width, height,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800124 /*maxSize*/0, format, dataSpace, rotation,
Emilian Peev2295df72021-11-12 18:14:10 -0800125 physicalCameraId, sensorPixelModesUsed, setId, isMultiResolution,
Shuzhen Wange4208922022-02-01 16:52:48 -0800126 dynamicRangeProfile, streamUseCase, deviceTimeBaseIsRealtime,
127 timestampBase),
Zhijun He5d677d12016-05-29 16:52:39 -0700128 mConsumer(nullptr),
129 mTransform(0),
130 mTraceFirstBuffer(true),
131 mUseBufferManager(false),
132 mTimestampOffset(timestampOffset),
Shuzhen Wang686f6442017-06-20 16:16:04 -0700133 mConsumerUsage(consumerUsage),
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700134 mDropBuffers(false),
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800135 mMirrorMode(mirrorMode),
Shuzhen Wang686f6442017-06-20 16:16:04 -0700136 mDequeueBufferLatency(kDequeueLatencyBinSize) {
Zhijun He5d677d12016-05-29 16:52:39 -0700137 // Deferred consumer only support preview surface format now.
138 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
139 ALOGE("%s: Deferred consumer only supports IMPLEMENTATION_DEFINED format now!",
140 __FUNCTION__);
141 mState = STATE_ERROR;
142 }
143
Ivan Lozanoc0ad82f2020-07-30 09:32:57 -0400144 // Validation check for the consumer usage flag.
Zhijun He5d677d12016-05-29 16:52:39 -0700145 if ((consumerUsage & GraphicBuffer::USAGE_HW_TEXTURE) == 0 &&
146 (consumerUsage & GraphicBuffer::USAGE_HW_COMPOSER) == 0) {
Emilian Peev050f5dc2017-05-18 14:43:56 +0100147 ALOGE("%s: Deferred consumer usage flag is illegal %" PRIu64 "!",
148 __FUNCTION__, consumerUsage);
Zhijun He5d677d12016-05-29 16:52:39 -0700149 mState = STATE_ERROR;
150 }
151
152 mConsumerName = String8("Deferred");
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700153 bool needsReleaseNotify = setId > CAMERA3_STREAM_SET_ID_INVALID;
154 mBufferProducerListener = new BufferProducerListener(this, needsReleaseNotify);
Zhijun He5d677d12016-05-29 16:52:39 -0700155}
156
Emilian Peevf4816702020-04-03 15:44:51 -0700157Camera3OutputStream::Camera3OutputStream(int id, camera_stream_type_t type,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700158 uint32_t width, uint32_t height,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800159 int format,
Yin-Chia Yehb97babb2015-03-12 13:42:44 -0700160 android_dataspace dataSpace,
Emilian Peevf4816702020-04-03 15:44:51 -0700161 camera_stream_rotation_t rotation,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800162 const String8& physicalCameraId,
Shuzhen Wange4208922022-02-01 16:52:48 -0800163 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100164 uint64_t consumerUsage, nsecs_t timestampOffset,
Emilian Peev2295df72021-11-12 18:14:10 -0800165 int setId, bool isMultiResolution,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800166 int64_t dynamicRangeProfile, int64_t streamUseCase,
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800167 bool deviceTimeBaseIsRealtime, int timestampBase,
168 int mirrorMode) :
Igor Murashkine3a9f962013-05-08 18:03:15 -0700169 Camera3IOStreamBase(id, type, width, height,
170 /*maxSize*/0,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800171 format, dataSpace, rotation,
Emilian Peev2295df72021-11-12 18:14:10 -0800172 physicalCameraId, sensorPixelModesUsed, setId, isMultiResolution,
Shuzhen Wange4208922022-02-01 16:52:48 -0800173 dynamicRangeProfile, streamUseCase, deviceTimeBaseIsRealtime,
174 timestampBase),
Zhijun He125684a2015-12-26 15:07:30 -0800175 mTransform(0),
176 mTraceFirstBuffer(true),
Zhijun He5d677d12016-05-29 16:52:39 -0700177 mUseBufferManager(false),
Shuzhen Wang0129d522016-10-30 22:43:41 -0700178 mTimestampOffset(timestampOffset),
Shuzhen Wang686f6442017-06-20 16:16:04 -0700179 mConsumerUsage(consumerUsage),
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700180 mDropBuffers(false),
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800181 mMirrorMode(mirrorMode),
Shuzhen Wang686f6442017-06-20 16:16:04 -0700182 mDequeueBufferLatency(kDequeueLatencyBinSize) {
Zhijun He125684a2015-12-26 15:07:30 -0800183
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700184 bool needsReleaseNotify = setId > CAMERA3_STREAM_SET_ID_INVALID;
185 mBufferProducerListener = new BufferProducerListener(this, needsReleaseNotify);
Igor Murashkine3a9f962013-05-08 18:03:15 -0700186
187 // Subclasses expected to initialize mConsumer themselves
188}
189
190
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800191Camera3OutputStream::~Camera3OutputStream() {
192 disconnectLocked();
193}
194
Emilian Peevf4816702020-04-03 15:44:51 -0700195status_t Camera3OutputStream::getBufferLocked(camera_stream_buffer *buffer,
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800196 const std::vector<size_t>&) {
Jayant Chowdharyd4776262020-06-23 23:45:57 -0700197 ATRACE_HFR_CALL();
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800198
199 ANativeWindowBuffer* anb;
Zhijun He125684a2015-12-26 15:07:30 -0800200 int fenceFd = -1;
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -0700201
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800202 status_t res;
203 res = getBufferLockedCommon(&anb, &fenceFd);
204 if (res != OK) {
205 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800206 }
207
Igor Murashkine3a9f962013-05-08 18:03:15 -0700208 /**
209 * FenceFD now owned by HAL except in case of error,
210 * in which case we reassign it to acquire_fence
211 */
212 handoutBufferLocked(*buffer, &(anb->handle), /*acquireFence*/fenceFd,
Emilian Peevf4816702020-04-03 15:44:51 -0700213 /*releaseFence*/-1, CAMERA_BUFFER_STATUS_OK, /*output*/true);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800214
215 return OK;
216}
217
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800218status_t Camera3OutputStream::getBuffersLocked(std::vector<OutstandingBuffer>* outBuffers) {
219 status_t res;
220
221 if ((res = getBufferPreconditionCheckLocked()) != OK) {
222 return res;
223 }
224
225 if (mUseBufferManager) {
226 ALOGE("%s: stream %d is managed by buffer manager and does not support batch operation",
227 __FUNCTION__, mId);
228 return INVALID_OPERATION;
229 }
230
231 sp<Surface> consumer = mConsumer;
232 /**
233 * Release the lock briefly to avoid deadlock for below scenario:
234 * Thread 1: StreamingProcessor::startStream -> Camera3Stream::isConfiguring().
235 * This thread acquired StreamingProcessor lock and try to lock Camera3Stream lock.
236 * Thread 2: Camera3Stream::returnBuffer->StreamingProcessor::onFrameAvailable().
237 * This thread acquired Camera3Stream lock and bufferQueue lock, and try to lock
238 * StreamingProcessor lock.
239 * Thread 3: Camera3Stream::getBuffer(). This thread acquired Camera3Stream lock
240 * and try to lock bufferQueue lock.
241 * Then there is circular locking dependency.
242 */
243 mLock.unlock();
244
245 size_t numBuffersRequested = outBuffers->size();
246 std::vector<Surface::BatchBuffer> buffers(numBuffersRequested);
247
248 nsecs_t dequeueStart = systemTime(SYSTEM_TIME_MONOTONIC);
249 res = consumer->dequeueBuffers(&buffers);
250 nsecs_t dequeueEnd = systemTime(SYSTEM_TIME_MONOTONIC);
251 mDequeueBufferLatency.add(dequeueStart, dequeueEnd);
252
253 mLock.lock();
254
255 if (res != OK) {
256 if (shouldLogError(res, mState)) {
257 ALOGE("%s: Stream %d: Can't dequeue %zu output buffers: %s (%d)",
258 __FUNCTION__, mId, numBuffersRequested, strerror(-res), res);
259 }
260 checkRetAndSetAbandonedLocked(res);
261 return res;
262 }
263 checkRemovedBuffersLocked();
264
265 /**
266 * FenceFD now owned by HAL except in case of error,
267 * in which case we reassign it to acquire_fence
268 */
269 for (size_t i = 0; i < numBuffersRequested; i++) {
270 handoutBufferLocked(*(outBuffers->at(i).outBuffer),
271 &(buffers[i].buffer->handle), /*acquireFence*/buffers[i].fenceFd,
272 /*releaseFence*/-1, CAMERA_BUFFER_STATUS_OK, /*output*/true);
273 }
274 return OK;
275}
276
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800277status_t Camera3OutputStream::queueBufferToConsumer(sp<ANativeWindow>& consumer,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700278 ANativeWindowBuffer* buffer, int anwReleaseFence,
279 const std::vector<size_t>&) {
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800280 return consumer->queueBuffer(consumer.get(), buffer, anwReleaseFence);
281}
282
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800283status_t Camera3OutputStream::returnBufferLocked(
Emilian Peevf4816702020-04-03 15:44:51 -0700284 const camera_stream_buffer &buffer,
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700285 nsecs_t timestamp, nsecs_t readoutTimestamp,
286 int32_t transform, const std::vector<size_t>& surface_ids) {
Jayant Chowdharyd4776262020-06-23 23:45:57 -0700287 ATRACE_HFR_CALL();
Igor Murashkine3a9f962013-05-08 18:03:15 -0700288
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800289 if (mHandoutTotalBufferCount == 1) {
290 returnPrefetchedBuffersLocked();
291 }
292
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700293 status_t res = returnAnyBufferLocked(buffer, timestamp, readoutTimestamp,
294 /*output*/true, transform, surface_ids);
Igor Murashkine3a9f962013-05-08 18:03:15 -0700295
296 if (res != OK) {
297 return res;
298 }
299
300 mLastTimestamp = timestamp;
Eino-Ville Talvalac31dc7e2017-01-31 17:35:41 -0800301 mFrameCount++;
Igor Murashkine3a9f962013-05-08 18:03:15 -0700302
303 return OK;
304}
305
306status_t Camera3OutputStream::returnBufferCheckedLocked(
Emilian Peevf4816702020-04-03 15:44:51 -0700307 const camera_stream_buffer &buffer,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700308 nsecs_t timestamp,
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700309 nsecs_t readoutTimestamp,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700310 bool output,
Emilian Peev5104fe92021-10-21 14:27:09 -0700311 int32_t transform,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700312 const std::vector<size_t>& surface_ids,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700313 /*out*/
314 sp<Fence> *releaseFenceOut) {
315
316 (void)output;
317 ALOG_ASSERT(output, "Expected output to be true");
318
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800319 status_t res;
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700320
Yin-Chia Yeh4c9736f2015-03-05 15:01:36 -0800321 // Fence management - always honor release fence from HAL
322 sp<Fence> releaseFence = new Fence(buffer.release_fence);
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700323 int anwReleaseFence = releaseFence->dup();
324
325 /**
Zhijun He124ccf42013-05-22 14:01:30 -0700326 * Release the lock briefly to avoid deadlock with
327 * StreamingProcessor::startStream -> Camera3Stream::isConfiguring (this
328 * thread will go into StreamingProcessor::onFrameAvailable) during
329 * queueBuffer
330 */
331 sp<ANativeWindow> currentConsumer = mConsumer;
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700332 StreamState state = mState;
Zhijun He124ccf42013-05-22 14:01:30 -0700333 mLock.unlock();
334
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800335 ANativeWindowBuffer *anwBuffer = container_of(buffer.buffer, ANativeWindowBuffer, handle);
Zhijun He124ccf42013-05-22 14:01:30 -0700336 /**
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700337 * Return buffer back to ANativeWindow
338 */
Emilian Peevf4816702020-04-03 15:44:51 -0700339 if (buffer.status == CAMERA_BUFFER_STATUS_ERROR || mDropBuffers || timestamp == 0) {
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700340 // Cancel buffer
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700341 if (mDropBuffers) {
342 ALOGV("%s: Dropping a frame for stream %d.", __FUNCTION__, mId);
Emilian Peevf4816702020-04-03 15:44:51 -0700343 } else if (buffer.status == CAMERA_BUFFER_STATUS_ERROR) {
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700344 ALOGV("%s: A frame is dropped for stream %d due to buffer error.", __FUNCTION__, mId);
Shuzhen Wangf0c4a6b2018-09-05 09:36:14 -0700345 } else {
346 ALOGE("%s: Stream %d: timestamp shouldn't be 0", __FUNCTION__, mId);
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700347 }
348
Zhijun He124ccf42013-05-22 14:01:30 -0700349 res = currentConsumer->cancelBuffer(currentConsumer.get(),
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800350 anwBuffer,
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700351 anwReleaseFence);
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700352 if (shouldLogError(res, state)) {
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700353 ALOGE("%s: Stream %d: Error cancelling buffer to native window:"
Igor Murashkine3a9f962013-05-08 18:03:15 -0700354 " %s (%d)", __FUNCTION__, mId, strerror(-res), res);
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700355 }
Zhijun He1ff811b2016-01-26 14:39:51 -0800356
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800357 notifyBufferReleased(anwBuffer);
Zhijun He1ff811b2016-01-26 14:39:51 -0800358 if (mUseBufferManager) {
359 // Return this buffer back to buffer manager.
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700360 mBufferProducerListener->onBufferReleased();
Zhijun He1ff811b2016-01-26 14:39:51 -0800361 }
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700362 } else {
Emilian Peevf4816702020-04-03 15:44:51 -0700363 if (mTraceFirstBuffer && (stream_type == CAMERA_STREAM_OUTPUT)) {
Ruchit Sharmae0711f22014-08-18 13:48:24 -0400364 {
365 char traceLog[48];
366 snprintf(traceLog, sizeof(traceLog), "Stream %d: first full buffer\n", mId);
367 ATRACE_NAME(traceLog);
368 }
369 mTraceFirstBuffer = false;
370 }
371
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800372 // If this is a JPEG output, and image dump mask is set, save image to
373 // disk.
374 if (getFormat() == HAL_PIXEL_FORMAT_BLOB && getDataSpace() == HAL_DATASPACE_V0_JFIF &&
375 mImageDumpMask) {
376 dumpImageToDisk(timestamp, anwBuffer, anwReleaseFence);
377 }
Yin-Chia Yeh4c9736f2015-03-05 15:01:36 -0800378
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800379 nsecs_t captureTime = (mSyncToDisplay ? readoutTimestamp : timestamp) - mTimestampOffset;
380 nsecs_t presentTime = mSyncToDisplay ?
381 syncTimestampToDisplayLocked(captureTime) : captureTime;
382 mLastCaptureTime = captureTime;
383 mLastPresentTime = presentTime;
Emilian Peev2295df72021-11-12 18:14:10 -0800384
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800385 setTransform(transform, true/*mayChangeMirror*/);
386 res = native_window_set_buffers_timestamp(mConsumer.get(), presentTime);
387 if (res != OK) {
388 ALOGE("%s: Stream %d: Error setting timestamp: %s (%d)",
389 __FUNCTION__, mId, strerror(-res), res);
390 return res;
391 }
Emilian Peev2295df72021-11-12 18:14:10 -0800392
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800393 queueHDRMetadata(anwBuffer->handle, currentConsumer, dynamic_range_profile);
394
395 res = queueBufferToConsumer(currentConsumer, anwBuffer, anwReleaseFence, surface_ids);
396 if (shouldLogError(res, state)) {
397 ALOGE("%s: Stream %d: Error queueing buffer to native window:"
398 " %s (%d)", __FUNCTION__, mId, strerror(-res), res);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800399 }
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800400 }
Zhijun He124ccf42013-05-22 14:01:30 -0700401 mLock.lock();
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700402
403 // Once a valid buffer has been returned to the queue, can no longer
404 // dequeue all buffers for preallocation.
Emilian Peevf4816702020-04-03 15:44:51 -0700405 if (buffer.status != CAMERA_BUFFER_STATUS_ERROR) {
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700406 mStreamUnpreparable = true;
407 }
408
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700409 if (res != OK) {
410 close(anwReleaseFence);
Igor Murashkin5a1798a2013-05-07 10:58:13 -0700411 }
412
Igor Murashkine3a9f962013-05-08 18:03:15 -0700413 *releaseFenceOut = releaseFence;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800414
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700415 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800416}
417
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800418void Camera3OutputStream::dump(int fd, const Vector<String16> &args) const {
419 (void) args;
420 String8 lines;
421 lines.appendFormat(" Stream[%d]: Output\n", mId);
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700422 lines.appendFormat(" Consumer name: %s\n", mConsumerName.string());
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800423 write(fd, lines.string(), lines.size());
Igor Murashkine3a9f962013-05-08 18:03:15 -0700424
425 Camera3IOStreamBase::dump(fd, args);
Shuzhen Wang686f6442017-06-20 16:16:04 -0700426
427 mDequeueBufferLatency.dump(fd,
428 " DequeueBuffer latency histogram:");
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800429}
430
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800431status_t Camera3OutputStream::setTransform(int transform, bool mayChangeMirror) {
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800432 ATRACE_CALL();
433 Mutex::Autolock l(mLock);
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800434 if (mMirrorMode != OutputConfiguration::MIRROR_MODE_AUTO && mayChangeMirror) {
435 // If the mirroring mode is not AUTO, do not allow transform update
436 // which may change mirror.
437 return OK;
438 }
439
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800440 return setTransformLocked(transform);
441}
442
443status_t Camera3OutputStream::setTransformLocked(int transform) {
444 status_t res = OK;
Shuzhen Wange4adddb2021-09-21 15:24:44 -0700445
446 if (transform == -1) return res;
447
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800448 if (mState == STATE_ERROR) {
449 ALOGE("%s: Stream in error state", __FUNCTION__);
450 return INVALID_OPERATION;
451 }
452
453 mTransform = transform;
454 if (mState == STATE_CONFIGURED) {
455 res = native_window_set_buffers_transform(mConsumer.get(),
456 transform);
457 if (res != OK) {
458 ALOGE("%s: Unable to configure stream transform to %x: %s (%d)",
459 __FUNCTION__, transform, strerror(-res), res);
460 }
461 }
462 return res;
463}
464
465status_t Camera3OutputStream::configureQueueLocked() {
466 status_t res;
467
Ruchit Sharmae0711f22014-08-18 13:48:24 -0400468 mTraceFirstBuffer = true;
Igor Murashkine3a9f962013-05-08 18:03:15 -0700469 if ((res = Camera3IOStreamBase::configureQueueLocked()) != OK) {
470 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800471 }
472
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800473 if ((res = configureConsumerQueueLocked(true /*allowDisplaySync*/)) != OK) {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700474 return res;
475 }
476
477 // Set dequeueBuffer/attachBuffer timeout if the consumer is not hw composer or hw texture.
478 // We need skip these cases as timeout will disable the non-blocking (async) mode.
479 if (!(isConsumedByHWComposer() || isConsumedByHWTexture())) {
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800480 if (mUseBufferManager) {
481 // When buffer manager is handling the buffer, we should have available buffers in
482 // buffer queue before we calls into dequeueBuffer because buffer manager is tracking
483 // free buffers.
484 // There are however some consumer side feature (ImageReader::discardFreeBuffers) that
485 // can discard free buffers without notifying buffer manager. We want the timeout to
486 // happen immediately here so buffer manager can try to update its internal state and
487 // try to allocate a buffer instead of waiting.
488 mConsumer->setDequeueTimeout(0);
489 } else {
490 mConsumer->setDequeueTimeout(kDequeueBufferTimeout);
491 }
Shuzhen Wang0129d522016-10-30 22:43:41 -0700492 }
493
494 return OK;
495}
496
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800497status_t Camera3OutputStream::configureConsumerQueueLocked(bool allowDisplaySync) {
Shuzhen Wang0129d522016-10-30 22:43:41 -0700498 status_t res;
499
500 mTraceFirstBuffer = true;
501
Igor Murashkine3a9f962013-05-08 18:03:15 -0700502 ALOG_ASSERT(mConsumer != 0, "mConsumer should never be NULL");
503
Zhijun He125684a2015-12-26 15:07:30 -0800504 // Configure consumer-side ANativeWindow interface. The listener may be used
505 // to notify buffer manager (if it is used) of the returned buffers.
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -0700506 res = mConsumer->connect(NATIVE_WINDOW_API_CAMERA,
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700507 /*reportBufferRemoval*/true,
508 /*listener*/mBufferProducerListener);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800509 if (res != OK) {
510 ALOGE("%s: Unable to connect to native window for stream %d",
511 __FUNCTION__, mId);
512 return res;
513 }
514
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700515 mConsumerName = mConsumer->getConsumerName();
516
Emilian Peev050f5dc2017-05-18 14:43:56 +0100517 res = native_window_set_usage(mConsumer.get(), mUsage);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800518 if (res != OK) {
Emilian Peev050f5dc2017-05-18 14:43:56 +0100519 ALOGE("%s: Unable to configure usage %" PRIu64 " for stream %d",
520 __FUNCTION__, mUsage, mId);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800521 return res;
522 }
523
524 res = native_window_set_scaling_mode(mConsumer.get(),
525 NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
526 if (res != OK) {
527 ALOGE("%s: Unable to configure stream scaling: %s (%d)",
528 __FUNCTION__, strerror(-res), res);
529 return res;
530 }
531
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800532 if (mMaxSize == 0) {
533 // For buffers of known size
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700534 res = native_window_set_buffers_dimensions(mConsumer.get(),
Emilian Peevf4816702020-04-03 15:44:51 -0700535 camera_stream::width, camera_stream::height);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800536 } else {
537 // For buffers with bounded size
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700538 res = native_window_set_buffers_dimensions(mConsumer.get(),
539 mMaxSize, 1);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800540 }
541 if (res != OK) {
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700542 ALOGE("%s: Unable to configure stream buffer dimensions"
543 " %d x %d (maxSize %zu) for stream %d",
Emilian Peevf4816702020-04-03 15:44:51 -0700544 __FUNCTION__, camera_stream::width, camera_stream::height,
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700545 mMaxSize, mId);
546 return res;
547 }
548 res = native_window_set_buffers_format(mConsumer.get(),
Emilian Peevf4816702020-04-03 15:44:51 -0700549 camera_stream::format);
Eino-Ville Talvala7d70c5e2014-07-24 18:10:23 -0700550 if (res != OK) {
551 ALOGE("%s: Unable to configure stream buffer format %#x for stream %d",
Emilian Peevf4816702020-04-03 15:44:51 -0700552 __FUNCTION__, camera_stream::format, mId);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800553 return res;
554 }
555
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800556 res = native_window_set_buffers_data_space(mConsumer.get(),
Emilian Peevf4816702020-04-03 15:44:51 -0700557 camera_stream::data_space);
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800558 if (res != OK) {
559 ALOGE("%s: Unable to configure stream dataspace %#x for stream %d",
Emilian Peevf4816702020-04-03 15:44:51 -0700560 __FUNCTION__, camera_stream::data_space, mId);
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800561 return res;
562 }
563
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800564 int maxConsumerBuffers;
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700565 res = static_cast<ANativeWindow*>(mConsumer.get())->query(
566 mConsumer.get(),
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800567 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
568 if (res != OK) {
569 ALOGE("%s: Unable to query consumer undequeued"
570 " buffer count for stream %d", __FUNCTION__, mId);
571 return res;
572 }
573
Alex Ray20cb3002013-05-28 20:18:22 -0700574 ALOGV("%s: Consumer wants %d buffers, HAL wants %d", __FUNCTION__,
Emilian Peevf4816702020-04-03 15:44:51 -0700575 maxConsumerBuffers, camera_stream::max_buffers);
576 if (camera_stream::max_buffers == 0) {
Zhijun He2ab500c2013-07-23 08:02:53 -0700577 ALOGE("%s: Camera HAL requested max_buffer count: %d, requires at least 1",
Emilian Peevf4816702020-04-03 15:44:51 -0700578 __FUNCTION__, camera_stream::max_buffers);
Alex Ray20cb3002013-05-28 20:18:22 -0700579 return INVALID_OPERATION;
580 }
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800581
Emilian Peevf4816702020-04-03 15:44:51 -0700582 mTotalBufferCount = maxConsumerBuffers + camera_stream::max_buffers;
Shuzhen Wange4208922022-02-01 16:52:48 -0800583
584 int timestampBase = getTimestampBase();
585 bool isDefaultTimeBase = (timestampBase ==
586 OutputConfiguration::TIMESTAMP_BASE_DEFAULT);
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800587 if (allowDisplaySync) {
Shuzhen Wange4adddb2021-09-21 15:24:44 -0700588 // We cannot distinguish between a SurfaceView and an ImageReader of
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800589 // preview buffer format. Frames are synchronized to display in both
590 // cases.
Shuzhen Wange4208922022-02-01 16:52:48 -0800591 bool forceChoreographer = (timestampBase ==
592 OutputConfiguration::TIMESTAMP_BASE_CHOREOGRAPHER_SYNCED);
593 bool defaultToChoreographer = (isDefaultTimeBase && isConsumedByHWComposer() &&
594 !property_get_bool("camera.disable_preview_scheduler", false));
595 if (forceChoreographer || defaultToChoreographer) {
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800596 mSyncToDisplay = true;
597 mTotalBufferCount += kDisplaySyncExtraBuffer;
Shuzhen Wange4adddb2021-09-21 15:24:44 -0700598 }
599 }
600
Zhijun He6adc9cc2014-04-15 14:09:55 -0700601 mHandoutTotalBufferCount = 0;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800602 mFrameCount = 0;
603 mLastTimestamp = 0;
Shuzhen Wange4208922022-02-01 16:52:48 -0800604
605 if (isDeviceTimeBaseRealtime()) {
606 if (isDefaultTimeBase && !isConsumedByHWComposer() && !isVideoStream()) {
607 // Default time base, but not hardware composer or video encoder
608 mTimestampOffset = 0;
609 } else if (timestampBase == OutputConfiguration::TIMESTAMP_BASE_REALTIME ||
610 timestampBase == OutputConfiguration::TIMESTAMP_BASE_SENSOR) {
611 mTimestampOffset = 0;
612 }
613 // If timestampBase is CHOREOGRAPHER SYNCED or MONOTONIC, leave
614 // timestamp offset as bootTime - monotonicTime.
615 } else {
616 if (timestampBase == OutputConfiguration::TIMESTAMP_BASE_REALTIME) {
617 // Reverse offset for monotonicTime -> bootTime
618 mTimestampOffset = -mTimestampOffset;
619 } else {
620 // If timestampBase is DEFAULT, MONOTONIC, SENSOR, or
621 // CHOREOGRAPHER_SYNCED, timestamp offset is 0.
622 mTimestampOffset = 0;
623 }
624 }
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800625
626 res = native_window_set_buffer_count(mConsumer.get(),
627 mTotalBufferCount);
628 if (res != OK) {
629 ALOGE("%s: Unable to set buffer count for stream %d",
630 __FUNCTION__, mId);
631 return res;
632 }
633
634 res = native_window_set_buffers_transform(mConsumer.get(),
635 mTransform);
636 if (res != OK) {
637 ALOGE("%s: Unable to configure stream transform to %x: %s (%d)",
638 __FUNCTION__, mTransform, strerror(-res), res);
Shuzhen Wang0129d522016-10-30 22:43:41 -0700639 return res;
Zhijun Hef0645c12016-08-02 00:58:11 -0700640 }
641
Zhijun He125684a2015-12-26 15:07:30 -0800642 /**
Zhijun Heedd41ae2016-02-03 14:45:53 -0800643 * Camera3 Buffer manager is only supported by HAL3.3 onwards, as the older HALs requires
Zhijun He125684a2015-12-26 15:07:30 -0800644 * buffers to be statically allocated for internal static buffer registration, while the
645 * buffers provided by buffer manager are really dynamically allocated. Camera3Device only
Zhijun Heedd41ae2016-02-03 14:45:53 -0800646 * sets the mBufferManager if device version is > HAL3.2, which guarantees that the buffer
647 * manager setup is skipped in below code. Note that HAL3.2 is also excluded here, as some
648 * HAL3.2 devices may not support the dynamic buffer registeration.
Yin-Chia Yehb6578902019-04-16 13:36:16 -0700649 * Also Camera3BufferManager does not support display/texture streams as they have its own
650 * buffer management logic.
Zhijun He125684a2015-12-26 15:07:30 -0800651 */
Yin-Chia Yehb6578902019-04-16 13:36:16 -0700652 if (mBufferManager != 0 && mSetId > CAMERA3_STREAM_SET_ID_INVALID &&
653 !(isConsumedByHWComposer() || isConsumedByHWTexture())) {
Emilian Peev050f5dc2017-05-18 14:43:56 +0100654 uint64_t consumerUsage = 0;
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -0700655 getEndpointUsage(&consumerUsage);
Shuzhen Wang83bff122020-11-20 15:51:39 -0800656 uint32_t width = (mMaxSize == 0) ? getWidth() : mMaxSize;
657 uint32_t height = (mMaxSize == 0) ? getHeight() : 1;
Zhijun He125684a2015-12-26 15:07:30 -0800658 StreamInfo streamInfo(
Shuzhen Wang83bff122020-11-20 15:51:39 -0800659 getId(), getStreamSetId(), width, height, getFormat(), getDataSpace(),
Emilian Peev050f5dc2017-05-18 14:43:56 +0100660 mUsage | consumerUsage, mTotalBufferCount,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800661 /*isConfigured*/true, isMultiResolution());
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -0700662 wp<Camera3OutputStream> weakThis(this);
663 res = mBufferManager->registerStream(weakThis,
664 streamInfo);
Zhijun He125684a2015-12-26 15:07:30 -0800665 if (res == OK) {
666 // Disable buffer allocation for this BufferQueue, buffer manager will take over
667 // the buffer allocation responsibility.
668 mConsumer->getIGraphicBufferProducer()->allowAllocation(false);
669 mUseBufferManager = true;
670 } else {
671 ALOGE("%s: Unable to register stream %d to camera3 buffer manager, "
672 "(error %d %s), fall back to BufferQueue for buffer management!",
673 __FUNCTION__, mId, res, strerror(-res));
674 }
675 }
676
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800677 return OK;
678}
679
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800680status_t Camera3OutputStream::getBufferLockedCommon(ANativeWindowBuffer** anb, int* fenceFd) {
Jayant Chowdharyd4776262020-06-23 23:45:57 -0700681 ATRACE_HFR_CALL();
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800682 status_t res;
683
684 if ((res = getBufferPreconditionCheckLocked()) != OK) {
685 return res;
686 }
687
688 bool gotBufferFromManager = false;
689
690 if (mUseBufferManager) {
691 sp<GraphicBuffer> gb;
Shuzhen Wang83bff122020-11-20 15:51:39 -0800692 res = mBufferManager->getBufferForStream(getId(), getStreamSetId(),
693 isMultiResolution(), &gb, fenceFd);
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800694 if (res == OK) {
695 // Attach this buffer to the bufferQueue: the buffer will be in dequeue state after a
696 // successful return.
697 *anb = gb.get();
698 res = mConsumer->attachBuffer(*anb);
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700699 if (shouldLogError(res, mState)) {
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800700 ALOGE("%s: Stream %d: Can't attach the output buffer to this surface: %s (%d)",
701 __FUNCTION__, mId, strerror(-res), res);
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700702 }
703 if (res != OK) {
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800704 checkRetAndSetAbandonedLocked(res);
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800705 return res;
706 }
707 gotBufferFromManager = true;
708 ALOGV("Stream %d: Attached new buffer", getId());
709 } else if (res == ALREADY_EXISTS) {
710 // Have sufficient free buffers already attached, can just
711 // dequeue from buffer queue
712 ALOGV("Stream %d: Reusing attached buffer", getId());
713 gotBufferFromManager = false;
714 } else if (res != OK) {
715 ALOGE("%s: Stream %d: Can't get next output buffer from buffer manager: %s (%d)",
716 __FUNCTION__, mId, strerror(-res), res);
717 return res;
718 }
719 }
720 if (!gotBufferFromManager) {
721 /**
722 * Release the lock briefly to avoid deadlock for below scenario:
723 * Thread 1: StreamingProcessor::startStream -> Camera3Stream::isConfiguring().
724 * This thread acquired StreamingProcessor lock and try to lock Camera3Stream lock.
725 * Thread 2: Camera3Stream::returnBuffer->StreamingProcessor::onFrameAvailable().
726 * This thread acquired Camera3Stream lock and bufferQueue lock, and try to lock
727 * StreamingProcessor lock.
728 * Thread 3: Camera3Stream::getBuffer(). This thread acquired Camera3Stream lock
729 * and try to lock bufferQueue lock.
730 * Then there is circular locking dependency.
731 */
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800732 sp<Surface> consumer = mConsumer;
Shuzhen Wang6c14e312021-07-05 16:20:33 -0700733 size_t remainingBuffers = (mState == STATE_PREPARING ? mTotalBufferCount :
734 camera_stream::max_buffers) - mHandoutTotalBufferCount;
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800735 mLock.unlock();
736
Shuzhen Wang686f6442017-06-20 16:16:04 -0700737 nsecs_t dequeueStart = systemTime(SYSTEM_TIME_MONOTONIC);
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800738
Shuzhen Wangc7629462021-07-12 15:02:58 -0700739 size_t batchSize = mBatchSize.load();
740 if (batchSize == 1) {
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800741 sp<ANativeWindow> anw = consumer;
742 res = anw->dequeueBuffer(anw.get(), anb, fenceFd);
743 } else {
Shuzhen Wangc7629462021-07-12 15:02:58 -0700744 std::unique_lock<std::mutex> batchLock(mBatchLock);
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800745 res = OK;
746 if (mBatchedBuffers.size() == 0) {
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800747 if (remainingBuffers == 0) {
748 ALOGE("%s: cannot get buffer while all buffers are handed out", __FUNCTION__);
749 return INVALID_OPERATION;
750 }
751 if (batchSize > remainingBuffers) {
752 batchSize = remainingBuffers;
753 }
Shuzhen Wangc7629462021-07-12 15:02:58 -0700754 batchLock.unlock();
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800755 // Refill batched buffers
Shuzhen Wangc7629462021-07-12 15:02:58 -0700756 std::vector<Surface::BatchBuffer> batchedBuffers;
757 batchedBuffers.resize(batchSize);
758 res = consumer->dequeueBuffers(&batchedBuffers);
759 batchLock.lock();
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800760 if (res != OK) {
761 ALOGE("%s: batch dequeueBuffers call failed! %s (%d)",
762 __FUNCTION__, strerror(-res), res);
Shuzhen Wangc7629462021-07-12 15:02:58 -0700763 } else {
764 mBatchedBuffers = std::move(batchedBuffers);
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800765 }
766 }
767
768 if (res == OK) {
769 // Dispatch batch buffers
770 *anb = mBatchedBuffers.back().buffer;
771 *fenceFd = mBatchedBuffers.back().fenceFd;
772 mBatchedBuffers.pop_back();
773 }
774 }
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800775
Shuzhen Wang686f6442017-06-20 16:16:04 -0700776 nsecs_t dequeueEnd = systemTime(SYSTEM_TIME_MONOTONIC);
777 mDequeueBufferLatency.add(dequeueStart, dequeueEnd);
778
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800779 mLock.lock();
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800780
781 if (mUseBufferManager && res == TIMED_OUT) {
782 checkRemovedBuffersLocked();
783
784 sp<GraphicBuffer> gb;
785 res = mBufferManager->getBufferForStream(
Shuzhen Wang83bff122020-11-20 15:51:39 -0800786 getId(), getStreamSetId(), isMultiResolution(),
787 &gb, fenceFd, /*noFreeBuffer*/true);
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800788
789 if (res == OK) {
790 // Attach this buffer to the bufferQueue: the buffer will be in dequeue state after
791 // a successful return.
792 *anb = gb.get();
793 res = mConsumer->attachBuffer(*anb);
794 gotBufferFromManager = true;
795 ALOGV("Stream %d: Attached new buffer", getId());
796
797 if (res != OK) {
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700798 if (shouldLogError(res, mState)) {
799 ALOGE("%s: Stream %d: Can't attach the output buffer to this surface:"
800 " %s (%d)", __FUNCTION__, mId, strerror(-res), res);
801 }
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800802 checkRetAndSetAbandonedLocked(res);
803 return res;
804 }
805 } else {
806 ALOGE("%s: Stream %d: Can't get next output buffer from buffer manager:"
807 " %s (%d)", __FUNCTION__, mId, strerror(-res), res);
808 return res;
809 }
810 } else if (res != OK) {
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700811 if (shouldLogError(res, mState)) {
812 ALOGE("%s: Stream %d: Can't dequeue next output buffer: %s (%d)",
813 __FUNCTION__, mId, strerror(-res), res);
814 }
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800815 checkRetAndSetAbandonedLocked(res);
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800816 return res;
817 }
818 }
819
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -0700820 if (res == OK) {
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800821 checkRemovedBuffersLocked();
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -0700822 }
823
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800824 return res;
825}
826
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800827void Camera3OutputStream::checkRemovedBuffersLocked(bool notifyBufferManager) {
828 std::vector<sp<GraphicBuffer>> removedBuffers;
829 status_t res = mConsumer->getAndFlushRemovedBuffers(&removedBuffers);
830 if (res == OK) {
831 onBuffersRemovedLocked(removedBuffers);
832
833 if (notifyBufferManager && mUseBufferManager && removedBuffers.size() > 0) {
Shuzhen Wang83bff122020-11-20 15:51:39 -0800834 mBufferManager->onBuffersRemoved(getId(), getStreamSetId(), isMultiResolution(),
835 removedBuffers.size());
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800836 }
837 }
838}
839
840void Camera3OutputStream::checkRetAndSetAbandonedLocked(status_t res) {
841 // Only transition to STATE_ABANDONED from STATE_CONFIGURED. (If it is
842 // STATE_PREPARING, let prepareNextBuffer handle the error.)
843 if ((res == NO_INIT || res == DEAD_OBJECT) && mState == STATE_CONFIGURED) {
844 mState = STATE_ABANDONED;
845 }
846}
847
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700848bool Camera3OutputStream::shouldLogError(status_t res, StreamState state) {
849 if (res == OK) {
850 return false;
851 }
852 if ((res == DEAD_OBJECT || res == NO_INIT) && state == STATE_ABANDONED) {
853 return false;
854 }
855 return true;
856}
857
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800858status_t Camera3OutputStream::disconnectLocked() {
859 status_t res;
860
Igor Murashkine3a9f962013-05-08 18:03:15 -0700861 if ((res = Camera3IOStreamBase::disconnectLocked()) != OK) {
862 return res;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800863 }
864
Zhijun He5d677d12016-05-29 16:52:39 -0700865 // Stream configuration was not finished (can only be in STATE_IN_CONFIG or STATE_CONSTRUCTED
866 // state), don't need change the stream state, return OK.
867 if (mConsumer == nullptr) {
868 return OK;
869 }
870
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800871 returnPrefetchedBuffersLocked();
872
Zhijun He125684a2015-12-26 15:07:30 -0800873 ALOGV("%s: disconnecting stream %d from native window", __FUNCTION__, getId());
874
Igor Murashkine3a9f962013-05-08 18:03:15 -0700875 res = native_window_api_disconnect(mConsumer.get(),
876 NATIVE_WINDOW_API_CAMERA);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800877 /**
878 * This is not an error. if client calling process dies, the window will
879 * also die and all calls to it will return DEAD_OBJECT, thus it's already
880 * "disconnected"
881 */
882 if (res == DEAD_OBJECT) {
883 ALOGW("%s: While disconnecting stream %d from native window, the"
884 " native window died from under us", __FUNCTION__, mId);
885 }
886 else if (res != OK) {
Igor Murashkine3a9f962013-05-08 18:03:15 -0700887 ALOGE("%s: Unable to disconnect stream %d from native window "
888 "(error %d %s)",
889 __FUNCTION__, mId, res, strerror(-res));
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800890 mState = STATE_ERROR;
891 return res;
892 }
893
Zhijun He125684a2015-12-26 15:07:30 -0800894 // Since device is already idle, there is no getBuffer call to buffer manager, unregister the
895 // stream at this point should be safe.
896 if (mUseBufferManager) {
Shuzhen Wang83bff122020-11-20 15:51:39 -0800897 res = mBufferManager->unregisterStream(getId(), getStreamSetId(), isMultiResolution());
Zhijun He125684a2015-12-26 15:07:30 -0800898 if (res != OK) {
899 ALOGE("%s: Unable to unregister stream %d from buffer manager "
900 "(error %d %s)", __FUNCTION__, mId, res, strerror(-res));
901 mState = STATE_ERROR;
902 return res;
903 }
904 // Note that, to make prepare/teardown case work, we must not mBufferManager.clear(), as
905 // the stream is still in usable state after this call.
906 mUseBufferManager = false;
907 }
908
Igor Murashkine3a9f962013-05-08 18:03:15 -0700909 mState = (mState == STATE_IN_RECONFIG) ? STATE_IN_CONFIG
910 : STATE_CONSTRUCTED;
Shuzhen Wang686f6442017-06-20 16:16:04 -0700911
912 mDequeueBufferLatency.log("Stream %d dequeueBuffer latency histogram", mId);
913 mDequeueBufferLatency.reset();
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800914 return OK;
915}
916
Emilian Peev050f5dc2017-05-18 14:43:56 +0100917status_t Camera3OutputStream::getEndpointUsage(uint64_t *usage) const {
Eino-Ville Talvalab2f5b192013-07-30 14:36:03 -0700918
919 status_t res;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700920
Zhijun He5d677d12016-05-29 16:52:39 -0700921 if (mConsumer == nullptr) {
922 // mConsumerUsage was sanitized before the Camera3OutputStream was constructed.
923 *usage = mConsumerUsage;
924 return OK;
925 }
926
Shuzhen Wang0129d522016-10-30 22:43:41 -0700927 res = getEndpointUsageForSurface(usage, mConsumer);
928
929 return res;
930}
931
Emilian Peev35ae8262018-11-08 13:11:32 +0000932void Camera3OutputStream::applyZSLUsageQuirk(int format, uint64_t *consumerUsage /*inout*/) {
933 if (consumerUsage == nullptr) {
934 return;
935 }
Shuzhen Wang0129d522016-10-30 22:43:41 -0700936
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700937 // If an opaque output stream's endpoint is ImageReader, add
Yin-Chia Yeh47cf8e62017-04-04 13:00:03 -0700938 // GRALLOC_USAGE_HW_CAMERA_ZSL to the usage so HAL knows it will be used
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700939 // for the ZSL use case.
940 // Assume it's for ImageReader if the consumer usage doesn't have any of these bits set:
941 // 1. GRALLOC_USAGE_HW_TEXTURE
942 // 2. GRALLOC_USAGE_HW_RENDER
943 // 3. GRALLOC_USAGE_HW_COMPOSER
944 // 4. GRALLOC_USAGE_HW_VIDEO_ENCODER
Emilian Peev35ae8262018-11-08 13:11:32 +0000945 if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED &&
946 (*consumerUsage & (GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER |
Shuzhen Wang0129d522016-10-30 22:43:41 -0700947 GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_VIDEO_ENCODER)) == 0) {
Emilian Peev35ae8262018-11-08 13:11:32 +0000948 *consumerUsage |= GRALLOC_USAGE_HW_CAMERA_ZSL;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700949 }
Emilian Peev35ae8262018-11-08 13:11:32 +0000950}
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700951
Emilian Peev35ae8262018-11-08 13:11:32 +0000952status_t Camera3OutputStream::getEndpointUsageForSurface(uint64_t *usage,
953 const sp<Surface>& surface) const {
954 status_t res;
955 uint64_t u = 0;
956
957 res = native_window_get_consumer_usage(static_cast<ANativeWindow*>(surface.get()), &u);
Emilian Peevf4816702020-04-03 15:44:51 -0700958 applyZSLUsageQuirk(camera_stream::format, &u);
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700959 *usage = u;
Eino-Ville Talvalab2f5b192013-07-30 14:36:03 -0700960 return res;
961}
962
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700963bool Camera3OutputStream::isVideoStream() const {
Emilian Peev050f5dc2017-05-18 14:43:56 +0100964 uint64_t usage = 0;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700965 status_t res = getEndpointUsage(&usage);
966 if (res != OK) {
967 ALOGE("%s: getting end point usage failed: %s (%d).", __FUNCTION__, strerror(-res), res);
968 return false;
969 }
970
971 return (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) != 0;
972}
973
Zhijun He125684a2015-12-26 15:07:30 -0800974status_t Camera3OutputStream::setBufferManager(sp<Camera3BufferManager> bufferManager) {
975 Mutex::Autolock l(mLock);
976 if (mState != STATE_CONSTRUCTED) {
Zhijun He5d677d12016-05-29 16:52:39 -0700977 ALOGE("%s: this method can only be called when stream in CONSTRUCTED state.",
Zhijun He125684a2015-12-26 15:07:30 -0800978 __FUNCTION__);
979 return INVALID_OPERATION;
980 }
981 mBufferManager = bufferManager;
982
983 return OK;
984}
985
Emilian Peev40ead602017-09-26 15:46:36 +0100986status_t Camera3OutputStream::updateStream(const std::vector<sp<Surface>> &/*outputSurfaces*/,
987 const std::vector<OutputStreamInfo> &/*outputInfo*/,
988 const std::vector<size_t> &/*removedSurfaceIds*/,
989 KeyedVector<sp<Surface>, size_t> * /*outputMapo*/) {
990 ALOGE("%s: this method is not supported!", __FUNCTION__);
991 return INVALID_OPERATION;
992}
993
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700994void Camera3OutputStream::BufferProducerListener::onBufferReleased() {
Zhijun He125684a2015-12-26 15:07:30 -0800995 sp<Camera3OutputStream> stream = mParent.promote();
996 if (stream == nullptr) {
997 ALOGV("%s: Parent camera3 output stream was destroyed", __FUNCTION__);
998 return;
999 }
1000
1001 Mutex::Autolock l(stream->mLock);
1002 if (!(stream->mUseBufferManager)) {
1003 return;
1004 }
1005
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001006 ALOGV("Stream %d: Buffer released", stream->getId());
Yin-Chia Yeh89954d92017-05-21 17:28:53 -07001007 bool shouldFreeBuffer = false;
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001008 status_t res = stream->mBufferManager->onBufferReleased(
Shuzhen Wang83bff122020-11-20 15:51:39 -08001009 stream->getId(), stream->getStreamSetId(), stream->isMultiResolution(),
1010 &shouldFreeBuffer);
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001011 if (res != OK) {
1012 ALOGE("%s: signaling buffer release to buffer manager failed: %s (%d).", __FUNCTION__,
1013 strerror(-res), res);
1014 stream->mState = STATE_ERROR;
1015 }
Yin-Chia Yeh89954d92017-05-21 17:28:53 -07001016
1017 if (shouldFreeBuffer) {
1018 sp<GraphicBuffer> buffer;
1019 // Detach and free a buffer (when buffer goes out of scope)
1020 stream->detachBufferLocked(&buffer, /*fenceFd*/ nullptr);
1021 if (buffer.get() != nullptr) {
1022 stream->mBufferManager->notifyBufferRemoved(
Shuzhen Wang83bff122020-11-20 15:51:39 -08001023 stream->getId(), stream->getStreamSetId(), stream->isMultiResolution());
Yin-Chia Yeh89954d92017-05-21 17:28:53 -07001024 }
1025 }
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001026}
1027
Shuzhen Wang0160ddd2019-08-15 09:11:56 -07001028void Camera3OutputStream::BufferProducerListener::onBuffersDiscarded(
1029 const std::vector<sp<GraphicBuffer>>& buffers) {
1030 sp<Camera3OutputStream> stream = mParent.promote();
1031 if (stream == nullptr) {
1032 ALOGV("%s: Parent camera3 output stream was destroyed", __FUNCTION__);
1033 return;
1034 }
1035
1036 if (buffers.size() > 0) {
1037 Mutex::Autolock l(stream->mLock);
1038 stream->onBuffersRemovedLocked(buffers);
1039 if (stream->mUseBufferManager) {
1040 stream->mBufferManager->onBuffersRemoved(stream->getId(),
Shuzhen Wang83bff122020-11-20 15:51:39 -08001041 stream->getStreamSetId(), stream->isMultiResolution(), buffers.size());
Shuzhen Wang0160ddd2019-08-15 09:11:56 -07001042 }
1043 ALOGV("Stream %d: %zu Buffers discarded.", stream->getId(), buffers.size());
1044 }
1045}
1046
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -07001047void Camera3OutputStream::onBuffersRemovedLocked(
1048 const std::vector<sp<GraphicBuffer>>& removedBuffers) {
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -07001049 sp<Camera3StreamBufferFreedListener> callback = mBufferFreedListener.promote();
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -07001050 if (callback != nullptr) {
Chih-Hung Hsieh48fc6192017-08-04 14:37:31 -07001051 for (const auto& gb : removedBuffers) {
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -07001052 callback->onBufferFreed(mId, gb->handle);
1053 }
1054 }
1055}
1056
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001057status_t Camera3OutputStream::detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd) {
1058 Mutex::Autolock l(mLock);
Yin-Chia Yeh89954d92017-05-21 17:28:53 -07001059 return detachBufferLocked(buffer, fenceFd);
1060}
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001061
Yin-Chia Yeh89954d92017-05-21 17:28:53 -07001062status_t Camera3OutputStream::detachBufferLocked(sp<GraphicBuffer>* buffer, int* fenceFd) {
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001063 ALOGV("Stream %d: detachBuffer", getId());
1064 if (buffer == nullptr) {
1065 return BAD_VALUE;
1066 }
1067
Zhijun He125684a2015-12-26 15:07:30 -08001068 sp<Fence> fence;
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001069 status_t res = mConsumer->detachNextBuffer(buffer, &fence);
Zhijun He125684a2015-12-26 15:07:30 -08001070 if (res == NO_MEMORY) {
1071 // This may rarely happen, which indicates that the released buffer was freed by other
1072 // call (e.g., attachBuffer, dequeueBuffer etc.) before reaching here. We should notify the
1073 // buffer manager that this buffer has been freed. It's not fatal, but should be avoided,
1074 // therefore log a warning.
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001075 *buffer = 0;
Zhijun He125684a2015-12-26 15:07:30 -08001076 ALOGW("%s: the released buffer has already been freed by the buffer queue!", __FUNCTION__);
1077 } else if (res != OK) {
Eino-Ville Talvalaff51b472016-06-28 15:26:19 -07001078 // Treat other errors as abandonment
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -07001079 if (shouldLogError(res, mState)) {
1080 ALOGE("%s: detach next buffer failed: %s (%d).", __FUNCTION__, strerror(-res), res);
1081 }
Eino-Ville Talvalaff51b472016-06-28 15:26:19 -07001082 mState = STATE_ABANDONED;
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001083 return res;
Zhijun He125684a2015-12-26 15:07:30 -08001084 }
1085
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001086 if (fenceFd != nullptr) {
1087 if (fence!= 0 && fence->isValid()) {
1088 *fenceFd = fence->dup();
1089 } else {
1090 *fenceFd = -1;
1091 }
Zhijun He125684a2015-12-26 15:07:30 -08001092 }
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -07001093
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -08001094 // Here we assume detachBuffer is called by buffer manager so it doesn't need to be notified
1095 checkRemovedBuffersLocked(/*notifyBufferManager*/false);
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -07001096 return res;
Zhijun He125684a2015-12-26 15:07:30 -08001097}
Shuzhen Wang13a69632016-01-26 09:51:07 -08001098
Chien-Yu Chena936ac22017-10-23 15:59:49 -07001099status_t Camera3OutputStream::dropBuffers(bool dropping) {
1100 Mutex::Autolock l(mLock);
1101 mDropBuffers = dropping;
1102 return OK;
1103}
1104
Shuzhen Wang5c22c152017-12-31 17:12:25 -08001105const String8& Camera3OutputStream::getPhysicalCameraId() const {
1106 Mutex::Autolock l(mLock);
1107 return physicalCameraId();
1108}
1109
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -08001110status_t Camera3OutputStream::notifyBufferReleased(ANativeWindowBuffer* /*anwBuffer*/) {
Shuzhen Wang0129d522016-10-30 22:43:41 -07001111 return OK;
1112}
1113
1114bool Camera3OutputStream::isConsumerConfigurationDeferred(size_t surface_id) const {
Zhijun He5d677d12016-05-29 16:52:39 -07001115 Mutex::Autolock l(mLock);
Shuzhen Wang0129d522016-10-30 22:43:41 -07001116
1117 if (surface_id != 0) {
Shuzhen Wang758c2152017-01-10 18:26:18 -08001118 ALOGE("%s: surface_id %zu for Camera3OutputStream should be 0!", __FUNCTION__, surface_id);
Shuzhen Wang0129d522016-10-30 22:43:41 -07001119 }
Zhijun He5d677d12016-05-29 16:52:39 -07001120 return mConsumer == nullptr;
1121}
1122
Shuzhen Wang758c2152017-01-10 18:26:18 -08001123status_t Camera3OutputStream::setConsumers(const std::vector<sp<Surface>>& consumers) {
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -08001124 Mutex::Autolock l(mLock);
Shuzhen Wang758c2152017-01-10 18:26:18 -08001125 if (consumers.size() != 1) {
1126 ALOGE("%s: it's illegal to set %zu consumer surfaces!",
1127 __FUNCTION__, consumers.size());
1128 return INVALID_OPERATION;
1129 }
1130 if (consumers[0] == nullptr) {
1131 ALOGE("%s: it's illegal to set null consumer surface!", __FUNCTION__);
Zhijun He5d677d12016-05-29 16:52:39 -07001132 return INVALID_OPERATION;
1133 }
1134
1135 if (mConsumer != nullptr) {
1136 ALOGE("%s: consumer surface was already set!", __FUNCTION__);
1137 return INVALID_OPERATION;
1138 }
1139
Shuzhen Wang758c2152017-01-10 18:26:18 -08001140 mConsumer = consumers[0];
Zhijun He5d677d12016-05-29 16:52:39 -07001141 return OK;
1142}
1143
Shuzhen Wang13a69632016-01-26 09:51:07 -08001144bool Camera3OutputStream::isConsumedByHWComposer() const {
Emilian Peev050f5dc2017-05-18 14:43:56 +01001145 uint64_t usage = 0;
Shuzhen Wang13a69632016-01-26 09:51:07 -08001146 status_t res = getEndpointUsage(&usage);
1147 if (res != OK) {
1148 ALOGE("%s: getting end point usage failed: %s (%d).", __FUNCTION__, strerror(-res), res);
1149 return false;
1150 }
1151
1152 return (usage & GRALLOC_USAGE_HW_COMPOSER) != 0;
1153}
1154
Zhijun Hef0645c12016-08-02 00:58:11 -07001155bool Camera3OutputStream::isConsumedByHWTexture() const {
Emilian Peev050f5dc2017-05-18 14:43:56 +01001156 uint64_t usage = 0;
Zhijun Hef0645c12016-08-02 00:58:11 -07001157 status_t res = getEndpointUsage(&usage);
1158 if (res != OK) {
1159 ALOGE("%s: getting end point usage failed: %s (%d).", __FUNCTION__, strerror(-res), res);
1160 return false;
1161 }
1162
1163 return (usage & GRALLOC_USAGE_HW_TEXTURE) != 0;
1164}
1165
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001166void Camera3OutputStream::dumpImageToDisk(nsecs_t timestamp,
1167 ANativeWindowBuffer* anwBuffer, int fence) {
1168 // Deriver output file name
1169 std::string fileExtension = "jpg";
1170 char imageFileName[64];
1171 time_t now = time(0);
1172 tm *localTime = localtime(&now);
1173 snprintf(imageFileName, sizeof(imageFileName), "IMG_%4d%02d%02d_%02d%02d%02d_%" PRId64 ".%s",
Shuzhen Wang6a8237f2021-07-13 14:42:57 -07001174 1900 + localTime->tm_year, localTime->tm_mon + 1, localTime->tm_mday,
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -08001175 localTime->tm_hour, localTime->tm_min, localTime->tm_sec,
1176 timestamp, fileExtension.c_str());
1177
1178 // Lock the image for CPU read
1179 sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(anwBuffer);
1180 void* mapped = nullptr;
1181 base::unique_fd fenceFd(dup(fence));
1182 status_t res = graphicBuffer->lockAsync(GraphicBuffer::USAGE_SW_READ_OFTEN, &mapped,
1183 fenceFd.get());
1184 if (res != OK) {
1185 ALOGE("%s: Failed to lock the buffer: %s (%d)", __FUNCTION__, strerror(-res), res);
1186 return;
1187 }
1188
1189 // Figure out actual file size
1190 auto actualJpegSize = android::camera2::JpegProcessor::findJpegSize((uint8_t*)mapped, mMaxSize);
1191 if (actualJpegSize == 0) {
1192 actualJpegSize = mMaxSize;
1193 }
1194
1195 // Output image data to file
1196 std::string filePath = "/data/misc/cameraserver/";
1197 filePath += imageFileName;
1198 std::ofstream imageFile(filePath.c_str(), std::ofstream::binary);
1199 if (!imageFile.is_open()) {
1200 ALOGE("%s: Unable to create file %s", __FUNCTION__, filePath.c_str());
1201 graphicBuffer->unlock();
1202 return;
1203 }
1204 imageFile.write((const char*)mapped, actualJpegSize);
1205
1206 graphicBuffer->unlock();
1207}
1208
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -08001209status_t Camera3OutputStream::setBatchSize(size_t batchSize) {
1210 Mutex::Autolock l(mLock);
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -08001211 if (batchSize == 0) {
1212 ALOGE("%s: invalid batch size 0", __FUNCTION__);
1213 return BAD_VALUE;
1214 }
1215
1216 if (mUseBufferManager) {
1217 ALOGE("%s: batch operation is not supported with buffer manager", __FUNCTION__);
1218 return INVALID_OPERATION;
1219 }
1220
1221 if (!isVideoStream()) {
1222 ALOGE("%s: batch operation is not supported with non-video stream", __FUNCTION__);
1223 return INVALID_OPERATION;
1224 }
1225
Shuzhen Wangc7629462021-07-12 15:02:58 -07001226 if (camera_stream::max_buffers < batchSize) {
1227 ALOGW("%s: batch size is capped by max_buffers %d", __FUNCTION__,
1228 camera_stream::max_buffers);
1229 batchSize = camera_stream::max_buffers;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -08001230 }
Shuzhen Wangc7629462021-07-12 15:02:58 -07001231
1232 size_t defaultBatchSize = 1;
1233 if (!mBatchSize.compare_exchange_strong(defaultBatchSize, batchSize)) {
1234 ALOGE("%s: change batch size from %zu to %zu dynamically is not supported",
1235 __FUNCTION__, defaultBatchSize, batchSize);
1236 return INVALID_OPERATION;
1237 }
1238
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -08001239 return OK;
1240}
1241
Shuzhen Wang00abbeb2022-02-25 17:14:42 -08001242void Camera3OutputStream::onMinDurationChanged(nsecs_t duration) {
1243 Mutex::Autolock l(mLock);
1244 mMinExpectedDuration = duration;
1245}
1246
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -08001247void Camera3OutputStream::returnPrefetchedBuffersLocked() {
Shuzhen Wangc7629462021-07-12 15:02:58 -07001248 std::vector<Surface::BatchBuffer> batchedBuffers;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -08001249
Shuzhen Wangc7629462021-07-12 15:02:58 -07001250 {
1251 std::lock_guard<std::mutex> batchLock(mBatchLock);
1252 if (mBatchedBuffers.size() != 0) {
1253 ALOGW("%s: %zu extra prefetched buffers detected. Returning",
1254 __FUNCTION__, mBatchedBuffers.size());
1255 batchedBuffers = std::move(mBatchedBuffers);
1256 }
1257 }
1258
1259 if (batchedBuffers.size() > 0) {
1260 mConsumer->cancelBuffers(batchedBuffers);
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -08001261 }
1262}
1263
Shuzhen Wang00abbeb2022-02-25 17:14:42 -08001264nsecs_t Camera3OutputStream::syncTimestampToDisplayLocked(nsecs_t t) {
1265 ParcelableVsyncEventData parcelableVsyncEventData;
1266 auto res = mDisplayEventReceiver.getLatestVsyncEventData(&parcelableVsyncEventData);
1267 if (res != OK) {
1268 ALOGE("%s: Stream %d: Error getting latest vsync event data: %s (%d)",
1269 __FUNCTION__, mId, strerror(-res), res);
1270 return t;
1271 }
1272
1273 const VsyncEventData& vsyncEventData = parcelableVsyncEventData.vsync;
1274 nsecs_t currentTime = systemTime();
1275
1276 // Reset capture to present time offset if more than 1 second
1277 // between frames.
1278 if (t - mLastCaptureTime > kSpacingResetIntervalNs) {
1279 for (size_t i = 0; i < VsyncEventData::kFrameTimelinesLength; i++) {
1280 if (vsyncEventData.frameTimelines[i].deadlineTimestamp >= currentTime) {
1281 mCaptureToPresentOffset =
1282 vsyncEventData.frameTimelines[i].expectedPresentationTime - t;
1283 break;
1284 }
1285 }
1286 }
1287
1288 nsecs_t idealPresentT = t + mCaptureToPresentOffset;
1289 nsecs_t expectedPresentT = 0;
1290 nsecs_t minDiff = INT64_MAX;
1291 // Derive minimum intervals between presentation times based on minimal
1292 // expected duration.
1293 size_t minVsyncs = (mMinExpectedDuration + vsyncEventData.frameInterval - 1) /
1294 vsyncEventData.frameInterval - 1;
1295 nsecs_t minInterval = minVsyncs * vsyncEventData.frameInterval + kTimelineThresholdNs;
1296 // Find best timestamp in the vsync timeline:
1297 // - closest to the ideal present time,
1298 // - deadline timestamp is greater than the current time, and
1299 // - the candidate present time is at least minInterval in the future
1300 // compared to last present time.
1301 for (const auto& vsyncTime : vsyncEventData.frameTimelines) {
1302 if (std::abs(vsyncTime.expectedPresentationTime - idealPresentT) < minDiff &&
1303 vsyncTime.deadlineTimestamp >= currentTime &&
1304 vsyncTime.expectedPresentationTime > mLastPresentTime + minInterval) {
1305 expectedPresentT = vsyncTime.expectedPresentationTime;
1306 minDiff = std::abs(vsyncTime.expectedPresentationTime - idealPresentT);
1307 }
1308 }
1309 return expectedPresentT;
Shuzhen Wange4adddb2021-09-21 15:24:44 -07001310}
1311
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -08001312}; // namespace camera3
1313
1314}; // namespace android