blob: c7910b7bce05a7fa5978656f2189abab90ab11d4 [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>
24
Shuzhen Wang686f6442017-06-20 16:16:04 -070025#include "utils/LatencyHistogram.h"
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080026#include "Camera3Stream.h"
Igor Murashkine3a9f962013-05-08 18:03:15 -070027#include "Camera3IOStreamBase.h"
Igor Murashkin2fba5842013-04-22 14:03:54 -070028#include "Camera3OutputStreamInterface.h"
Zhijun He125684a2015-12-26 15:07:30 -080029#include "Camera3BufferManager.h"
Shuzhen Wange4adddb2021-09-21 15:24:44 -070030#include "PreviewFrameScheduler.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,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -080093 int dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wange4208922022-02-01 16:52:48 -080094 int streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
95 bool deviceTimeBaseIsRealtime = false,
96 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -080097 /**
98 * Set up a stream for formats that have a variable buffer size for the same
99 * dimensions, such as compressed JPEG.
Zhijun He125684a2015-12-26 15:07:30 -0800100 * A valid stream set id needs to be set to support buffer sharing between multiple
101 * streams.
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800102 */
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700103 Camera3OutputStream(int id, sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800104 uint32_t width, uint32_t height, size_t maxSize, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700105 android_dataspace dataSpace, camera_stream_rotation_t rotation,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800106 nsecs_t timestampOffset, const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800107 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev2295df72021-11-12 18:14:10 -0800108 int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800109 int dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wange4208922022-02-01 16:52:48 -0800110 int streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
111 bool deviceTimeBaseIsRealtime = false,
112 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT);
Zhijun He5d677d12016-05-29 16:52:39 -0700113 /**
114 * Set up a stream with deferred consumer for formats that have 2 dimensions, such as
115 * RAW and YUV. The consumer must be set before using this stream for output. A valid
116 * stream set id needs to be set to support buffer sharing between multiple streams.
117 */
118 Camera3OutputStream(int id, uint32_t width, uint32_t height, int format,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100119 uint64_t consumerUsage, android_dataspace dataSpace,
Emilian Peevf4816702020-04-03 15:44:51 -0700120 camera_stream_rotation_t rotation, nsecs_t timestampOffset,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800121 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800122 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev2295df72021-11-12 18:14:10 -0800123 int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800124 int dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wange4208922022-02-01 16:52:48 -0800125 int streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
126 bool deviceTimeBaseIsRealtime = false,
127 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT);
Zhijun He5d677d12016-05-29 16:52:39 -0700128
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800129 virtual ~Camera3OutputStream();
130
131 /**
132 * Camera3Stream interface
133 */
134
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800135 virtual void dump(int fd, const Vector<String16> &args) const;
136
137 /**
138 * Set the transform on the output stream; one of the
139 * HAL_TRANSFORM_* / NATIVE_WINDOW_TRANSFORM_* constants.
140 */
141 status_t setTransform(int transform);
142
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700143 /**
144 * Return if this output stream is for video encoding.
145 */
146 bool isVideoStream() const;
Shuzhen Wang13a69632016-01-26 09:51:07 -0800147 /**
148 * Return if this output stream is consumed by hardware composer.
149 */
150 bool isConsumedByHWComposer() const;
Chien-Yu Chen85a64552015-08-28 15:46:12 -0700151
Zhijun He5d677d12016-05-29 16:52:39 -0700152 /**
Zhijun Hef0645c12016-08-02 00:58:11 -0700153 * Return if this output stream is consumed by hardware texture.
154 */
155 bool isConsumedByHWTexture() const;
156
157 /**
Zhijun He5d677d12016-05-29 16:52:39 -0700158 * Return if the consumer configuration of this stream is deferred.
159 */
Shuzhen Wang0129d522016-10-30 22:43:41 -0700160 virtual bool isConsumerConfigurationDeferred(size_t surface_id) const;
Zhijun He5d677d12016-05-29 16:52:39 -0700161
162 /**
Shuzhen Wang758c2152017-01-10 18:26:18 -0800163 * Set the consumer surfaces to the output stream.
Zhijun He5d677d12016-05-29 16:52:39 -0700164 */
Shuzhen Wang758c2152017-01-10 18:26:18 -0800165 virtual status_t setConsumers(const std::vector<sp<Surface>>& consumers);
Zhijun He5d677d12016-05-29 16:52:39 -0700166
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700167 class BufferProducerListener : public SurfaceListener {
Zhijun He125684a2015-12-26 15:07:30 -0800168 public:
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700169 BufferProducerListener(wp<Camera3OutputStream> parent, bool needsReleaseNotify)
170 : mParent(parent), mNeedsReleaseNotify(needsReleaseNotify) {}
Zhijun He125684a2015-12-26 15:07:30 -0800171
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700172 /**
173 * Implementation of IProducerListener, used to notify this stream that the consumer
174 * has returned a buffer and it is ready to return to Camera3BufferManager for reuse.
175 */
176 virtual void onBufferReleased();
177 virtual bool needsReleaseNotify() { return mNeedsReleaseNotify; }
178 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>& buffers);
Zhijun He125684a2015-12-26 15:07:30 -0800179
180 private:
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700181 wp<Camera3OutputStream> mParent;
182 bool mNeedsReleaseNotify;
Zhijun He125684a2015-12-26 15:07:30 -0800183 };
184
Eino-Ville Talvala77c1a352016-06-13 12:32:43 -0700185 virtual status_t detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd);
186
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800187 /**
188 * Notify that the buffer is being released to the buffer queue instead of
189 * being queued to the consumer.
190 */
191 virtual status_t notifyBufferReleased(ANativeWindowBuffer *anwBuffer);
Shuzhen Wang0129d522016-10-30 22:43:41 -0700192
Zhijun He125684a2015-12-26 15:07:30 -0800193 /**
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700194 * Drop buffers if dropping is true. If dropping is false, do not drop buffers.
195 */
196 virtual status_t dropBuffers(bool dropping) override;
197
198 /**
Shuzhen Wang5c22c152017-12-31 17:12:25 -0800199 * Query the physical camera id for the output stream.
200 */
201 virtual const String8& getPhysicalCameraId() const override;
202
203 /**
Zhijun He125684a2015-12-26 15:07:30 -0800204 * Set the graphic buffer manager to get/return the stream buffers.
205 *
206 * It is only legal to call this method when stream is in STATE_CONSTRUCTED state.
207 */
208 status_t setBufferManager(sp<Camera3BufferManager> bufferManager);
209
Emilian Peev40ead602017-09-26 15:46:36 +0100210 /**
211 * Query the ouput surface id.
212 */
213 virtual ssize_t getSurfaceId(const sp<Surface> &/*surface*/) { return 0; }
214
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700215 virtual status_t getUniqueSurfaceIds(const std::vector<size_t>&,
216 /*out*/std::vector<size_t>*) { return INVALID_OPERATION; };
217
Emilian Peev40ead602017-09-26 15:46:36 +0100218 /**
219 * Update the stream output surfaces.
220 */
221 virtual status_t updateStream(const std::vector<sp<Surface>> &outputSurfaces,
222 const std::vector<OutputStreamInfo> &outputInfo,
223 const std::vector<size_t> &removedSurfaceIds,
224 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
225
Emilian Peev35ae8262018-11-08 13:11:32 +0000226 /**
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800227 * Set the batch size for buffer operations. The output stream will request
228 * buffers from buffer queue on a batch basis. Currently only video streams
229 * are allowed to set the batch size. Also if the stream is managed by
230 * buffer manager (Surface group in Java API) then batching is also not
231 * supported. Changing batch size on the fly while there is already batched
232 * buffers in the stream is also not supported.
233 * If the batch size is larger than the max dequeue count set
234 * by the camera HAL, the batch size will be set to the max dequeue count
235 * instead.
236 */
237 virtual status_t setBatchSize(size_t batchSize = 1) override;
238
239 /**
Emilian Peev35ae8262018-11-08 13:11:32 +0000240 * Apply ZSL related consumer usage quirk.
241 */
242 static void applyZSLUsageQuirk(int format, uint64_t *consumerUsage /*inout*/);
243
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800244 void setImageDumpMask(int mask) { mImageDumpMask = mask; }
Shuzhen Wange4adddb2021-09-21 15:24:44 -0700245 bool shouldLogError(status_t res);
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800246
Igor Murashkine3a9f962013-05-08 18:03:15 -0700247 protected:
Emilian Peevf4816702020-04-03 15:44:51 -0700248 Camera3OutputStream(int id, camera_stream_type_t type,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800249 uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700250 android_dataspace dataSpace, camera_stream_rotation_t rotation,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800251 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800252 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev050f5dc2017-05-18 14:43:56 +0100253 uint64_t consumerUsage = 0, nsecs_t timestampOffset = 0,
Emilian Peev2295df72021-11-12 18:14:10 -0800254 int setId = CAMERA3_STREAM_SET_ID_INVALID, bool isMultiResolution = false,
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800255 int dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
Shuzhen Wange4208922022-02-01 16:52:48 -0800256 int streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
257 bool deviceTimeBaseIsRealtime = false,
258 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT);
Igor Murashkine3a9f962013-05-08 18:03:15 -0700259
Zhijun He124ccf42013-05-22 14:01:30 -0700260 /**
261 * Note that we release the lock briefly in this function
262 */
Igor Murashkine3a9f962013-05-08 18:03:15 -0700263 virtual status_t returnBufferCheckedLocked(
Emilian Peevf4816702020-04-03 15:44:51 -0700264 const camera_stream_buffer &buffer,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700265 nsecs_t timestamp,
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700266 nsecs_t readoutTimestamp,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700267 bool output,
Emilian Peev5104fe92021-10-21 14:27:09 -0700268 int32_t transform,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700269 const std::vector<size_t>& surface_ids,
Igor Murashkine3a9f962013-05-08 18:03:15 -0700270 /*out*/
271 sp<Fence> *releaseFenceOut);
272
Zhijun He0a210512014-07-24 13:45:15 -0700273 virtual status_t disconnectLocked();
274
Emilian Peev050f5dc2017-05-18 14:43:56 +0100275 status_t getEndpointUsageForSurface(uint64_t *usage,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700276 const sp<Surface>& surface) const;
Shuzhen Wange4adddb2021-09-21 15:24:44 -0700277 status_t configureConsumerQueueLocked(bool allowPreviewScheduler);
Shuzhen Wang0129d522016-10-30 22:43:41 -0700278
279 // Consumer as the output of camera HAL
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700280 sp<Surface> mConsumer;
Zhijun He5d677d12016-05-29 16:52:39 -0700281
Emilian Peev050f5dc2017-05-18 14:43:56 +0100282 uint64_t getPresetConsumerUsage() const { return mConsumerUsage; }
Zhijun Hef0645c12016-08-02 00:58:11 -0700283
284 static const nsecs_t kDequeueBufferTimeout = 1000000000; // 1 sec
285
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800286 status_t getBufferLockedCommon(ANativeWindowBuffer** anb, int* fenceFd);
287
288
Shuzhen Wang0129d522016-10-30 22:43:41 -0700289 private:
290
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800291 int mTransform;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800292
Igor Murashkine3a9f962013-05-08 18:03:15 -0700293 virtual status_t setTransformLocked(int transform);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800294
Ruchit Sharmae0711f22014-08-18 13:48:24 -0400295 bool mTraceFirstBuffer;
296
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700297 // Name of Surface consumer
298 String8 mConsumerName;
299
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800300 /**
Zhijun He125684a2015-12-26 15:07:30 -0800301 * GraphicBuffer manager this stream is registered to. Used to replace the buffer
302 * allocation/deallocation role of BufferQueue.
303 */
304 sp<Camera3BufferManager> mBufferManager;
305
306 /**
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700307 * Buffer producer listener, used to handle notification when a buffer is released
308 * from consumer side, or a set of buffers are discarded by the consumer.
Zhijun He125684a2015-12-26 15:07:30 -0800309 */
Shuzhen Wang0160ddd2019-08-15 09:11:56 -0700310 sp<BufferProducerListener> mBufferProducerListener;
Zhijun He125684a2015-12-26 15:07:30 -0800311
312 /**
313 * Flag indicating if the buffer manager is used to allocate the stream buffers
314 */
315 bool mUseBufferManager;
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800316
317 /**
Shuzhen Wange4208922022-02-01 16:52:48 -0800318 * Offset used to override camera HAL produced timestamps
319 *
320 * The offset is first initialized to bootTime - monotonicTime in
321 * constructor, and may later be updated based on the client's timestampBase
322 * setting.
Shuzhen Wangc28dccc2016-02-11 23:48:46 -0800323 */
324 nsecs_t mTimestampOffset;
325
Zhijun He125684a2015-12-26 15:07:30 -0800326 /**
Zhijun He5d677d12016-05-29 16:52:39 -0700327 * Consumer end point usage flag set by the constructor for the deferred
328 * consumer case.
329 */
Emilian Peev050f5dc2017-05-18 14:43:56 +0100330 uint64_t mConsumerUsage;
Zhijun He5d677d12016-05-29 16:52:39 -0700331
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700332 // Whether to drop valid buffers.
333 bool mDropBuffers;
334
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800335
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800336
337 // The batch size for buffer operation
Shuzhen Wangc7629462021-07-12 15:02:58 -0700338 std::atomic_size_t mBatchSize = 1;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800339
Shuzhen Wangc7629462021-07-12 15:02:58 -0700340 // Protecting batch states below, must be acquired after mLock
341 std::mutex mBatchLock;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800342 // Prefetched buffers (ready to be handed to client)
343 std::vector<Surface::BatchBuffer> mBatchedBuffers;
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800344 // ---- End of mBatchLock protected scope ----
345
Zhijun He5d677d12016-05-29 16:52:39 -0700346 /**
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800347 * Internal Camera3Stream interface
348 */
Emilian Peevf4816702020-04-03 15:44:51 -0700349 virtual status_t getBufferLocked(camera_stream_buffer *buffer,
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800350 const std::vector<size_t>& surface_ids);
351
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800352 virtual status_t getBuffersLocked(/*out*/std::vector<OutstandingBuffer>* buffers) override;
353
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800354 virtual status_t returnBufferLocked(
Emilian Peevf4816702020-04-03 15:44:51 -0700355 const camera_stream_buffer &buffer,
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700356 nsecs_t timestamp, nsecs_t readoutTimestamp,
357 int32_t transform, const std::vector<size_t>& surface_ids);
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800358
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800359 virtual status_t queueBufferToConsumer(sp<ANativeWindow>& consumer,
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700360 ANativeWindowBuffer* buffer, int anwReleaseFence,
361 const std::vector<size_t>& surface_ids);
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800362
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800363 virtual status_t configureQueueLocked();
Eino-Ville Talvalab2f5b192013-07-30 14:36:03 -0700364
Emilian Peev050f5dc2017-05-18 14:43:56 +0100365 virtual status_t getEndpointUsage(uint64_t *usage) const;
Eino-Ville Talvalab2f5b192013-07-30 14:36:03 -0700366
Yin-Chia Yeh89954d92017-05-21 17:28:53 -0700367 /**
368 * Private methods
369 */
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -0700370 void onBuffersRemovedLocked(const std::vector<sp<GraphicBuffer>>&);
Yin-Chia Yeh89954d92017-05-21 17:28:53 -0700371 status_t detachBufferLocked(sp<GraphicBuffer>* buffer, int* fenceFd);
Yin-Chia Yehbf1b8b92019-03-06 14:56:08 -0800372 // Call this after each dequeueBuffer/attachBuffer/detachNextBuffer call to get update on
373 // removed buffers. Set notifyBufferManager to false when the call is initiated by buffer
374 // manager so buffer manager doesn't need to be notified.
375 void checkRemovedBuffersLocked(bool notifyBufferManager = true);
376
377 // Check return status of IGBP calls and set abandoned state accordingly
378 void checkRetAndSetAbandonedLocked(status_t res);
Yin-Chia Yeh017d49c2017-03-31 19:11:00 -0700379
Yin-Chia Yeha1b56c82019-03-27 15:50:39 -0700380 // If the status indicates abandonded stream, only log when state hasn't been updated to
381 // STATE_ABANDONED
382 static bool shouldLogError(status_t res, StreamState state);
383
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800384 // Dump images to disk before returning to consumer
385 void dumpImageToDisk(nsecs_t timestamp, ANativeWindowBuffer* anwBuffer, int fence);
386
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800387 void returnPrefetchedBuffersLocked();
388
Shuzhen Wang686f6442017-06-20 16:16:04 -0700389 static const int32_t kDequeueLatencyBinSize = 5; // in ms
390 CameraLatencyHistogram mDequeueBufferLatency;
391
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800392 int mImageDumpMask = 0;
393
Shuzhen Wange4adddb2021-09-21 15:24:44 -0700394 // The preview stream scheduler for re-timing frames
395 std::unique_ptr<PreviewFrameScheduler> mPreviewFrameScheduler;
Eino-Ville Talvalafd58f1a2013-03-06 16:20:06 -0800396}; // class Camera3OutputStream
397
398} // namespace camera3
399
400} // namespace android
401
402#endif