blob: 6ea7ef701a189a2c4b545200e22fcd1087f4f5da [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#ifndef ANDROID_SERVERS_CAMERA3_OUTPUT_STREAM_H
18#define ANDROID_SERVERS_CAMERA3_OUTPUT_STREAM_H
19
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -080020#include <mutex>
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080021#include <utils/RefBase.h>
Zhijun He125684a2015-12-26 15:07:30 -080022#include <gui/IProducerListener.h>
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080023#include <gui/Surface.h>
Shuzhen Wang00abbeb2022-02-25 17:14:42 -080024#include <gui/DisplayEventReceiver.h>
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080025
Shuzhen Wang686f6442017-06-20 16:16:04 -070026#include "utils/LatencyHistogram.h"
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080027#include "Camera3Stream.h"
Igor Murashkine3a9f962013-05-08 18:03:15 -070028#include "Camera3IOStreamBase.h"
Igor Murashkin2fba5842013-04-22 14:03:54 -070029#include "Camera3OutputStreamInterface.h"
Zhijun He125684a2015-12-26 15:07:30 -080030#include "Camera3BufferManager.h"
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080031
32namespace android {
33
34namespace camera3 {
35
Zhijun He125684a2015-12-26 15:07:30 -080036class Camera3BufferManager;
37
38/**
39 * Stream info structure that holds the necessary stream info for buffer manager to use for
40 * buffer allocation and management.
41 */
42struct StreamInfo {
43 int streamId;
44 int streamSetId;
45 uint32_t width;
46 uint32_t height;
47 uint32_t format;
48 android_dataspace dataSpace;
Emilian Peev050f5dc2017-05-18 14:43:56 +010049 uint64_t combinedUsage;
Zhijun He125684a2015-12-26 15:07:30 -080050 size_t totalBufferCount;
51 bool isConfigured;
Shuzhen Wang83bff122020-11-20 15:51:39 -080052 bool isMultiRes;
Chih-Hung Hsiehd19d9942016-08-29 14:21:14 -070053 explicit StreamInfo(int id = CAMERA3_STREAM_ID_INVALID,
Zhijun He125684a2015-12-26 15:07:30 -080054 int setId = CAMERA3_STREAM_SET_ID_INVALID,
55 uint32_t w = 0,
56 uint32_t h = 0,
57 uint32_t fmt = 0,
58 android_dataspace ds = HAL_DATASPACE_UNKNOWN,
Emilian Peev050f5dc2017-05-18 14:43:56 +010059 uint64_t usage = 0,
Zhijun He125684a2015-12-26 15:07:30 -080060 size_t bufferCount = 0,
Shuzhen Wang83bff122020-11-20 15:51:39 -080061 bool configured = false,
62 bool multiRes = false) :
Zhijun He125684a2015-12-26 15:07:30 -080063 streamId(id),
64 streamSetId(setId),
65 width(w),
66 height(h),
67 format(fmt),
68 dataSpace(ds),
69 combinedUsage(usage),
70 totalBufferCount(bufferCount),
Shuzhen Wang83bff122020-11-20 15:51:39 -080071 isConfigured(configured),
72 isMultiRes(multiRes) {}
Zhijun He125684a2015-12-26 15:07:30 -080073};
74
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080075/**
76 * A class for managing a single stream of output data from the camera device.
77 */
Igor Murashkin2fba5842013-04-22 14:03:54 -070078class Camera3OutputStream :
Igor Murashkine3a9f962013-05-08 18:03:15 -070079 public Camera3IOStreamBase,
Igor Murashkin2fba5842013-04-22 14:03:54 -070080 public Camera3OutputStreamInterface {
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080081 public:
82 /**
83 * Set up a stream for formats that have 2 dimensions, such as RAW and YUV.
Zhijun He125684a2015-12-26 15:07:30 -080084 * A valid stream set id needs to be set to support buffer sharing between multiple
85 * streams.
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080086 */
Eino-Ville Talvala727d1722015-06-09 13:44:19 -070087 Camera3OutputStream(int id, sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -080088 uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -070089 android_dataspace dataSpace, camera_stream_rotation_t rotation,
Shuzhen Wangc28189a2017-11-27 23:05:10 -080090 nsecs_t timestampOffset, const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -080091 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev2295df72021-11-12 18:14:10 -080092 int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false,
Emilian Peevc81a7592022-02-14 17:38:18 -080093 int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -080094 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
Shuzhen Wange4208922022-02-01 16:52:48 -080095 bool deviceTimeBaseIsRealtime = false,
Shuzhen Wang610d7b82022-02-08 14:37:22 -080096 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT,
97 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080098 /**
99 * Set up a stream for formats that have a variable buffer size for the same
100 * dimensions, such as compressed JPEG.
Zhijun He125684a2015-12-26 15:07:30 -0800101 * A valid stream set id needs to be set to support buffer sharing between multiple
102 * streams.
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800103 */
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700104 Camera3OutputStream(int id, sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800105 uint32_t width, uint32_t height, size_t maxSize, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700106 android_dataspace dataSpace, camera_stream_rotation_t rotation,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800107 nsecs_t timestampOffset, const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800108 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev2295df72021-11-12 18:14:10 -0800109 int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false,
Emilian Peevc81a7592022-02-14 17:38:18 -0800110 int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800111 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
Shuzhen Wange4208922022-02-01 16:52:48 -0800112 bool deviceTimeBaseIsRealtime = false,
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800113 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT,
114 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO);
Zhijun He5d677d12016-05-29 16:52:39 -0700115 /**
116 * Set up a stream with deferred consumer for formats that have 2 dimensions, such as
117 * RAW and YUV. The consumer must be set before using this stream for output. A valid
118 * stream set id needs to be set to support buffer sharing between multiple streams.
119 */
120 Camera3OutputStream(int id, uint32_t width, uint32_t height, int format,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100121 uint64_t consumerUsage, android_dataspace dataSpace,
Emilian Peevf4816702020-04-03 15:44:51 -0700122 camera_stream_rotation_t rotation, nsecs_t timestampOffset,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800123 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800124 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev2295df72021-11-12 18:14:10 -0800125 int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false,
Emilian Peevc81a7592022-02-14 17:38:18 -0800126 int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800127 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
Shuzhen Wange4208922022-02-01 16:52:48 -0800128 bool deviceTimeBaseIsRealtime = false,
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800129 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT,
130 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO);
Zhijun He5d677d12016-05-29 16:52:39 -0700131
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800132 virtual ~Camera3OutputStream();
133
134 /**
135 * Camera3Stream interface
136 */
137
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800138 virtual void dump(int fd, const Vector<String16> &args) const;
139
140 /**
141 * Set the transform on the output stream; one of the
142 * HAL_TRANSFORM_* / NATIVE_WINDOW_TRANSFORM_* constants.
143 */
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800144 status_t setTransform(int transform, bool mayChangeMirror);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800145
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700146 /**
147 * Return if this output stream is for video encoding.
148 */
149 bool isVideoStream() const;
Shuzhen Wang13a69632016-01-26 09:51:07 -0800150 /**
151 * Return if this output stream is consumed by hardware composer.
152 */
153 bool isConsumedByHWComposer() const;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700154
Zhijun He5d677d12016-05-29 16:52:39 -0700155 /**
Zhijun Hef0645c12016-08-02 00:58:11 -0700156 * Return if this output stream is consumed by hardware texture.
157 */
158 bool isConsumedByHWTexture() const;
159
160 /**
Zhijun He5d677d12016-05-29 16:52:39 -0700161 * Return if the consumer configuration of this stream is deferred.
162 */
Shuzhen Wang0129d522016-10-30 22:43:41 -0700163 virtual bool isConsumerConfigurationDeferred(size_t surface_id) const;
Zhijun He5d677d12016-05-29 16:52:39 -0700164
165 /**
Shuzhen Wang758c2152017-01-10 18:26:18 -0800166 * Set the consumer surfaces to the output stream.
Zhijun He5d677d12016-05-29 16:52:39 -0700167 */
Shuzhen Wang758c2152017-01-10 18:26:18 -0800168 virtual status_t setConsumers(const std::vector<sp<Surface>>& consumers);
Zhijun He5d677d12016-05-29 16:52:39 -0700169
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700170 class BufferProducerListener : public SurfaceListener {
Zhijun He125684a2015-12-26 15:07:30 -0800171 public:
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700172 BufferProducerListener(wp<Camera3OutputStream> parent, bool needsReleaseNotify)
173 : mParent(parent), mNeedsReleaseNotify(needsReleaseNotify) {}
Zhijun He125684a2015-12-26 15:07:30 -0800174
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700175 /**
176 * Implementation of IProducerListener, used to notify this stream that the consumer
177 * has returned a buffer and it is ready to return to Camera3BufferManager for reuse.
178 */
179 virtual void onBufferReleased();
180 virtual bool needsReleaseNotify() { return mNeedsReleaseNotify; }
181 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers);
Zhijun He125684a2015-12-26 15:07:30 -0800182
183 private:
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700184 wp<Camera3OutputStream> mParent;
185 bool mNeedsReleaseNotify;
Zhijun He125684a2015-12-26 15:07:30 -0800186 };
187
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -0700188 virtual status_t detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd);
189
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800190 /**
191 * Notify that the buffer is being released to the buffer queue instead of
192 * being queued to the consumer.
193 */
194 virtual status_t notifyBufferReleased(ANativeWindowBuffer *anwBuffer);
Shuzhen Wang0129d522016-10-30 22:43:41 -0700195
Zhijun He125684a2015-12-26 15:07:30 -0800196 /**
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700197 * Drop buffers if dropping is true. If dropping is false, do not drop buffers.
198 */
199 virtual status_t dropBuffers(bool dropping) override;
200
201 /**
Shuzhen Wang5c22c152017-12-31 17:12:25 -0800202 * Query the physical camera id for the output stream.
203 */
204 virtual const String8& getPhysicalCameraId() const override;
205
206 /**
Zhijun He125684a2015-12-26 15:07:30 -0800207 * Set the graphic buffer manager to get/return the stream buffers.
208 *
209 * It is only legal to call this method when stream is in STATE_CONSTRUCTED state.
210 */
211 status_t setBufferManager(sp<Camera3BufferManager> bufferManager);
212
Emilian Peev40ead602017-09-26 15:46:36 +0100213 /**
214 * Query the ouput surface id.
215 */
216 virtual ssize_t getSurfaceId(const sp<Surface> &/*surface*/) { return 0; }
217
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700218 virtual status_t getUniqueSurfaceIds(const std::vector<size_t>&,
219 /*out*/std::vector<size_t>*) { return INVALID_OPERATION; };
220
Emilian Peev40ead602017-09-26 15:46:36 +0100221 /**
222 * Update the stream output surfaces.
223 */
224 virtual status_t updateStream(const std::vector<sp<Surface>> &outputSurfaces,
225 const std::vector<OutputStreamInfo> &outputInfo,
226 const std::vector<size_t> &removedSurfaceIds,
227 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
228
Emilian Peev35ae8262018-11-08 13:11:32 +0000229 /**
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800230 * Set the batch size for buffer operations. The output stream will request
231 * buffers from buffer queue on a batch basis. Currently only video streams
232 * are allowed to set the batch size. Also if the stream is managed by
233 * buffer manager (Surface group in Java API) then batching is also not
234 * supported. Changing batch size on the fly while there is already batched
235 * buffers in the stream is also not supported.
236 * If the batch size is larger than the max dequeue count set
237 * by the camera HAL, the batch size will be set to the max dequeue count
238 * instead.
239 */
240 virtual status_t setBatchSize(size_t batchSize = 1) override;
241
242 /**
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800243 * Notify the stream on change of min frame durations.
244 */
245 virtual void onMinDurationChanged(nsecs_t duration) override;
246
247 /**
Emilian Peev35ae8262018-11-08 13:11:32 +0000248 * Apply ZSL related consumer usage quirk.
249 */
250 static void applyZSLUsageQuirk(int format, uint64_t *consumerUsage /*inout*/);
251
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800252 void setImageDumpMask(int mask) { mImageDumpMask = mask; }
253
Igor Murashkine3a9f962013-05-08 18:03:15 -0700254 protected:
Emilian Peevf4816702020-04-03 15:44:51 -0700255 Camera3OutputStream(int id, camera_stream_type_t type,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800256 uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700257 android_dataspace dataSpace, camera_stream_rotation_t rotation,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800258 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800259 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100260 uint64_t consumerUsage = 0, nsecs_t timestampOffset = 0,
Emilian Peev2295df72021-11-12 18:14:10 -0800261 int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false,
Emilian Peevc81a7592022-02-14 17:38:18 -0800262 int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800263 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
Shuzhen Wange4208922022-02-01 16:52:48 -0800264 bool deviceTimeBaseIsRealtime = false,
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800265 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT,
266 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO);
Igor Murashkine3a9f962013-05-08 18:03:15 -0700267
Zhijun He124ccf42013-05-22 14:01:30 -0700268 /**
269 * Note that we release the lock briefly in this function
270 */
Igor Murashkine3a9f962013-05-08 18:03:15 -0700271 virtual status_t returnBufferCheckedLocked(
Emilian Peevf4816702020-04-03 15:44:51 -0700272 const camera_stream_buffer &buffer,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700273 nsecs_t timestamp,
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700274 nsecs_t readoutTimestamp,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700275 bool output,
Emilian Peev5104fe92021-10-21 14:27:09 -0700276 int32_t transform,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700277 const std::vector<size_t>& surface_ids,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700278 /*out*/
279 sp<Fence> *releaseFenceOut);
280
Zhijun He0a210512014-07-24 13:45:15 -0700281 virtual status_t disconnectLocked();
282
Emilian Peev050f5dc2017-05-18 14:43:56 +0100283 status_t getEndpointUsageForSurface(uint64_t *usage,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700284 const sp<Surface>& surface) const;
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800285 status_t configureConsumerQueueLocked(bool allowDisplaySync);
Shuzhen Wang0129d522016-10-30 22:43:41 -0700286
287 // Consumer as the output of camera HAL
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700288 sp<Surface> mConsumer;
Zhijun He5d677d12016-05-29 16:52:39 -0700289
Emilian Peev050f5dc2017-05-18 14:43:56 +0100290 uint64_t getPresetConsumerUsage() const { return mConsumerUsage; }
Zhijun Hef0645c12016-08-02 00:58:11 -0700291
292 static const nsecs_t kDequeueBufferTimeout = 1000000000; // 1 sec
293
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800294 status_t getBufferLockedCommon(ANativeWindowBuffer** anb, int* fenceFd);
295
296
Shuzhen Wang0129d522016-10-30 22:43:41 -0700297 private:
298
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800299 int mTransform;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800300
Igor Murashkine3a9f962013-05-08 18:03:15 -0700301 virtual status_t setTransformLocked(int transform);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800302
Ruchit Sharmae0711f22014-08-18 13:48:24 -0400303 bool mTraceFirstBuffer;
304
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700305 // Name of Surface consumer
306 String8 mConsumerName;
307
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800308 /**
Zhijun He125684a2015-12-26 15:07:30 -0800309 * GraphicBuffer manager this stream is registered to. Used to replace the buffer
310 * allocation/deallocation role of BufferQueue.
311 */
312 sp<Camera3BufferManager> mBufferManager;
313
314 /**
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700315 * Buffer producer listener, used to handle notification when a buffer is released
316 * from consumer side, or a set of buffers are discarded by the consumer.
Zhijun He125684a2015-12-26 15:07:30 -0800317 */
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700318 sp<BufferProducerListener> mBufferProducerListener;
Zhijun He125684a2015-12-26 15:07:30 -0800319
320 /**
321 * Flag indicating if the buffer manager is used to allocate the stream buffers
322 */
323 bool mUseBufferManager;
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800324
325 /**
Shuzhen Wange4208922022-02-01 16:52:48 -0800326 * Offset used to override camera HAL produced timestamps
327 *
328 * The offset is first initialized to bootTime - monotonicTime in
329 * constructor, and may later be updated based on the client's timestampBase
330 * setting.
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800331 */
332 nsecs_t mTimestampOffset;
333
Zhijun He125684a2015-12-26 15:07:30 -0800334 /**
Zhijun He5d677d12016-05-29 16:52:39 -0700335 * Consumer end point usage flag set by the constructor for the deferred
336 * consumer case.
337 */
Emilian Peev050f5dc2017-05-18 14:43:56 +0100338 uint64_t mConsumerUsage;
Zhijun He5d677d12016-05-29 16:52:39 -0700339
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700340 // Whether to drop valid buffers.
341 bool mDropBuffers;
342
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800343
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800344
345 // The batch size for buffer operation
Shuzhen Wangc7629462021-07-12 15:02:58 -0700346 std::atomic_size_t mBatchSize = 1;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800347
Shuzhen Wangc7629462021-07-12 15:02:58 -0700348 // Protecting batch states below, must be acquired after mLock
349 std::mutex mBatchLock;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800350 // Prefetched buffers (ready to be handed to client)
351 std::vector<Surface::BatchBuffer> mBatchedBuffers;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800352 // ---- End of mBatchLock protected scope ----
353
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800354 const int mMirrorMode;
355
Zhijun He5d677d12016-05-29 16:52:39 -0700356 /**
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800357 * Internal Camera3Stream interface
358 */
Emilian Peevf4816702020-04-03 15:44:51 -0700359 virtual status_t getBufferLocked(camera_stream_buffer *buffer,
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800360 const std::vector<size_t>& surface_ids);
361
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800362 virtual status_t getBuffersLocked(/*out*/std::vector<OutstandingBuffer>* buffers) override;
363
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800364 virtual status_t returnBufferLocked(
Emilian Peevf4816702020-04-03 15:44:51 -0700365 const camera_stream_buffer &buffer,
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700366 nsecs_t timestamp, nsecs_t readoutTimestamp,
367 int32_t transform, const std::vector<size_t>& surface_ids);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800368
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800369 virtual status_t queueBufferToConsumer(sp<ANativeWindow>& consumer,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700370 ANativeWindowBuffer* buffer, int anwReleaseFence,
371 const std::vector<size_t>& surface_ids);
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800372
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800373 virtual status_t configureQueueLocked();
Eino-Ville Talvalab2f5b192013-07-30 14:36:03 -0700374
Emilian Peev050f5dc2017-05-18 14:43:56 +0100375 virtual status_t getEndpointUsage(uint64_t *usage) const;
Eino-Ville Talvalab2f5b192013-07-30 14:36:03 -0700376
Yin-Chia Yeh89954d92017-05-21 17:28:53 -0700377 /**
378 * Private methods
379 */
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -0700380 void onBuffersRemovedLocked(const std::vector<sp<GraphicBuffer>>&);
Yin-Chia Yeh89954d92017-05-21 17:28:53 -0700381 status_t detachBufferLocked(sp<GraphicBuffer>* buffer, int* fenceFd);
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800382 // Call this after each dequeueBuffer/attachBuffer/detachNextBuffer call to get update on
383 // removed buffers. Set notifyBufferManager to false when the call is initiated by buffer
384 // manager so buffer manager doesn't need to be notified.
385 void checkRemovedBuffersLocked(bool notifyBufferManager = true);
386
387 // Check return status of IGBP calls and set abandoned state accordingly
388 void checkRetAndSetAbandonedLocked(status_t res);
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -0700389
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700390 // If the status indicates abandonded stream, only log when state hasn't been updated to
391 // STATE_ABANDONED
392 static bool shouldLogError(status_t res, StreamState state);
393
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800394 // Dump images to disk before returning to consumer
395 void dumpImageToDisk(nsecs_t timestamp, ANativeWindowBuffer* anwBuffer, int fence);
396
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800397 void returnPrefetchedBuffersLocked();
398
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800399 // Synchronize camera timestamp to display, and the return value
400 // can be used as presentation timestamp
401 nsecs_t syncTimestampToDisplayLocked(nsecs_t t);
402
Shuzhen Wang686f6442017-06-20 16:16:04 -0700403 static const int32_t kDequeueLatencyBinSize = 5; // in ms
404 CameraLatencyHistogram mDequeueBufferLatency;
405
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800406 int mImageDumpMask = 0;
407
Shuzhen Wang00abbeb2022-02-25 17:14:42 -0800408 nsecs_t mMinExpectedDuration = 0;
409 bool mSyncToDisplay = false;
410 DisplayEventReceiver mDisplayEventReceiver;
411 nsecs_t mLastCaptureTime = 0;
412 nsecs_t mLastPresentTime = 0;
413 nsecs_t mCaptureToPresentOffset = 0;
414 static constexpr size_t kDisplaySyncExtraBuffer = 2;
415 static constexpr nsecs_t kSpacingResetIntervalNs = 1000000000LL; // 1 second
416 static constexpr nsecs_t kTimelineThresholdNs = 1000000LL; // 1 millisecond
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800417}; // class Camera3OutputStream
418
419} // namespace camera3
420
421} // namespace android
422
423#endif