blob: 7fa6273d61d324d2033b584f5fc525c08f71162a [file] [log] [blame]
Igor Murashkinae500e52013-04-22 14:03:54 -07001/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_SERVERS_CAMERA3_STREAM_INTERFACE_H
18#define ANDROID_SERVERS_CAMERA3_STREAM_INTERFACE_H
19
20#include <utils/RefBase.h>
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080021
Shuzhen Wange4208922022-02-01 16:52:48 -080022#include <camera/camera2/OutputConfiguration.h>
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -080023#include <camera/CameraMetadata.h>
Igor Murashkinae500e52013-04-22 14:03:54 -070024#include "Camera3StreamBufferListener.h"
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -070025#include "Camera3StreamBufferFreedListener.h"
Igor Murashkinae500e52013-04-22 14:03:54 -070026
Igor Murashkinae500e52013-04-22 14:03:54 -070027namespace android {
28
29namespace camera3 {
30
Emilian Peevf4816702020-04-03 15:44:51 -070031typedef enum camera_buffer_status {
32 CAMERA_BUFFER_STATUS_OK = 0,
33 CAMERA_BUFFER_STATUS_ERROR = 1
34} camera_buffer_status_t;
35
36typedef enum camera_stream_type {
37 CAMERA_STREAM_OUTPUT = 0,
38 CAMERA_STREAM_INPUT = 1,
39 CAMERA_NUM_STREAM_TYPES
40} camera_stream_type_t;
41
42typedef enum camera_stream_rotation {
43 /* No rotation */
44 CAMERA_STREAM_ROTATION_0 = 0,
45
46 /* Rotate by 90 degree counterclockwise */
47 CAMERA_STREAM_ROTATION_90 = 1,
48
49 /* Rotate by 180 degree counterclockwise */
50 CAMERA_STREAM_ROTATION_180 = 2,
51
52 /* Rotate by 270 degree counterclockwise */
53 CAMERA_STREAM_ROTATION_270 = 3
54} camera_stream_rotation_t;
55
56typedef struct camera_stream {
57 camera_stream_type_t stream_type;
58 uint32_t width;
59 uint32_t height;
60 int format;
61 uint32_t usage;
62 uint32_t max_buffers;
63 android_dataspace_t data_space;
64 camera_stream_rotation_t rotation;
Austin Borgered99f642023-06-01 16:51:35 -070065 std::string physical_camera_id;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -080066
67 std::unordered_set<int32_t> sensor_pixel_modes_used;
Emilian Peevc81a7592022-02-14 17:38:18 -080068 int64_t dynamic_range_profile;
Shuzhen Wang8ed1e872022-03-08 16:34:33 -080069 int64_t use_case;
Austin Borger9e2b27c2022-07-15 11:27:24 -070070 int32_t color_space;
Emilian Peevf4816702020-04-03 15:44:51 -070071} camera_stream_t;
72
73typedef struct camera_stream_buffer {
74 camera_stream_t *stream;
75 buffer_handle_t *buffer;
76 camera_buffer_status_t status;
77 int acquire_fence;
78 int release_fence;
79} camera_stream_buffer_t;
80
Shuzhen Wang83bff122020-11-20 15:51:39 -080081struct Size {
82 uint32_t width;
83 uint32_t height;
84 explicit Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){}
85};
86
Zhijun He125684a2015-12-26 15:07:30 -080087enum {
88 /**
89 * This stream set ID indicates that the set ID is invalid, and this stream doesn't intend to
90 * share buffers with any other stream. It is illegal to register this kind of stream to
91 * Camera3BufferManager.
92 */
93 CAMERA3_STREAM_SET_ID_INVALID = -1,
94
95 /**
96 * Invalid output stream ID.
97 */
98 CAMERA3_STREAM_ID_INVALID = -1,
99};
100
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700101class StatusTracker;
102
Emilian Peev40ead602017-09-26 15:46:36 +0100103// OutputStreamInfo describes the property of a camera stream.
104class OutputStreamInfo {
105 public:
106 int width;
107 int height;
108 int format;
109 android_dataspace dataSpace;
110 uint64_t consumerUsage;
111 bool finalized = false;
Emilian Peevcc0b7952020-01-07 13:54:47 -0800112 bool supportsOffline = false;
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800113 std::unordered_set<int32_t> sensorPixelModesUsed;
Emilian Peevc81a7592022-02-14 17:38:18 -0800114 int64_t dynamicRangeProfile;
Shuzhen Wang8ed1e872022-03-08 16:34:33 -0800115 int64_t streamUseCase;
Shuzhen Wange4208922022-02-01 16:52:48 -0800116 int timestampBase;
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800117 int mirrorMode;
Austin Borger9e2b27c2022-07-15 11:27:24 -0700118 int32_t colorSpace;
Emilian Peev40ead602017-09-26 15:46:36 +0100119 OutputStreamInfo() :
120 width(-1), height(-1), format(-1), dataSpace(HAL_DATASPACE_UNKNOWN),
Emilian Peev2295df72021-11-12 18:14:10 -0800121 consumerUsage(0),
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800122 dynamicRangeProfile(ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD),
Shuzhen Wange4208922022-02-01 16:52:48 -0800123 streamUseCase(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT),
Shuzhen Wang610d7b82022-02-08 14:37:22 -0800124 timestampBase(OutputConfiguration::TIMESTAMP_BASE_DEFAULT),
Austin Borger9e2b27c2022-07-15 11:27:24 -0700125 mirrorMode(OutputConfiguration::MIRROR_MODE_AUTO),
126 colorSpace(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED) {}
Emilian Peev40ead602017-09-26 15:46:36 +0100127 OutputStreamInfo(int _width, int _height, int _format, android_dataspace _dataSpace,
Emilian Peev2295df72021-11-12 18:14:10 -0800128 uint64_t _consumerUsage, const std::unordered_set<int32_t>& _sensorPixelModesUsed,
Austin Borger9e2b27c2022-07-15 11:27:24 -0700129 int64_t _dynamicRangeProfile, int _streamUseCase, int _timestampBase, int _mirrorMode,
130 int32_t _colorSpace) :
Emilian Peev40ead602017-09-26 15:46:36 +0100131 width(_width), height(_height), format(_format),
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800132 dataSpace(_dataSpace), consumerUsage(_consumerUsage),
Shuzhen Wangc8ab4522021-12-14 20:12:42 -0800133 sensorPixelModesUsed(_sensorPixelModesUsed), dynamicRangeProfile(_dynamicRangeProfile),
Austin Borger9e2b27c2022-07-15 11:27:24 -0700134 streamUseCase(_streamUseCase), timestampBase(_timestampBase), mirrorMode(_mirrorMode),
135 colorSpace(_colorSpace) {}
Emilian Peev40ead602017-09-26 15:46:36 +0100136};
137
Jayant Chowdharyc67af1b2022-04-07 18:05:04 +0000138// Utility class to lock and unlock a GraphicBuffer
139class GraphicBufferLocker {
140public:
141 GraphicBufferLocker(sp<GraphicBuffer> buffer) : _buffer(buffer) {}
142
143 status_t lockAsync(uint32_t usage, void** dstBuffer, int fenceFd) {
144 if (_buffer == nullptr) return BAD_VALUE;
145
146 status_t res = OK;
147 if (!_locked) {
148 status_t res = _buffer->lockAsync(usage, dstBuffer, fenceFd);
149 if (res == OK) {
150 _locked = true;
151 }
152 }
153 return res;
154 }
155
156 status_t lockAsync(void** dstBuffer, int fenceFd) {
157 return lockAsync(GRALLOC_USAGE_SW_WRITE_OFTEN, dstBuffer, fenceFd);
158 }
159
160 ~GraphicBufferLocker() {
161 if (_locked && _buffer != nullptr) {
162 auto res = _buffer->unlock();
163 if (res != OK) {
164 ALOGE("%s: Error trying to unlock buffer: %s (%d)", __FUNCTION__,
165 strerror(-res), res);
166 }
167 }
168 }
169
170private:
171 sp<GraphicBuffer> _buffer;
172 bool _locked = false;
173};
174
Igor Murashkinae500e52013-04-22 14:03:54 -0700175/**
176 * An interface for managing a single stream of input and/or output data from
177 * the camera device.
178 */
179class Camera3StreamInterface : public virtual RefBase {
180 public:
Ruben Brunkc78ac262015-08-13 17:58:46 -0700181
182 enum {
183 ALLOCATE_PIPELINE_MAX = 0, // Allocate max buffers used by a given surface
184 };
185
Igor Murashkinae500e52013-04-22 14:03:54 -0700186 /**
187 * Get the stream's ID
188 */
189 virtual int getId() const = 0;
190
191 /**
Zhijun He125684a2015-12-26 15:07:30 -0800192 * Get the output stream set id.
193 */
194 virtual int getStreamSetId() const = 0;
195
196 /**
Shuzhen Wang99080502021-03-07 21:08:20 -0800197 * Is this stream part of a multi-resolution stream set
198 */
199 virtual bool isMultiResolution() const = 0;
200
201 /**
202 * Get the HAL stream group id for a multi-resolution stream set
203 */
204 virtual int getHalStreamGroupId() const = 0;
205
206 /**
Igor Murashkinae500e52013-04-22 14:03:54 -0700207 * Get the stream's dimensions and format
208 */
209 virtual uint32_t getWidth() const = 0;
210 virtual uint32_t getHeight() const = 0;
211 virtual int getFormat() const = 0;
Emilian Peevc81a7592022-02-14 17:38:18 -0800212 virtual int64_t getDynamicRangeProfile() const = 0;
Eino-Ville Talvalad46a6b92015-05-14 17:26:24 -0700213 virtual android_dataspace getDataSpace() const = 0;
Austin Borger9e2b27c2022-07-15 11:27:24 -0700214 virtual int32_t getColorSpace() const = 0;
Emilian Peev710c1422017-08-30 11:19:38 +0100215 virtual void setFormatOverride(bool formatOverriden) = 0;
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700216 virtual bool isFormatOverridden() const = 0;
217 virtual int getOriginalFormat() const = 0;
218 virtual void setDataSpaceOverride(bool dataSpaceOverriden) = 0;
219 virtual bool isDataSpaceOverridden() const = 0;
220 virtual android_dataspace getOriginalDataSpace() const = 0;
Shuzhen Wang316781a2020-08-18 18:11:01 -0700221 virtual int getMaxHalBuffers() const = 0;
222 virtual int getMaxTotalBuffers() const = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700223
224 /**
Yin-Chia Yeh5fd603e2019-11-20 11:22:27 -0800225 * Offline processing
226 */
227 virtual void setOfflineProcessingSupport(bool support) = 0;
228 virtual bool getOfflineProcessingSupport() const = 0;
229
230 /**
Emilian Peevf4816702020-04-03 15:44:51 -0700231 * Get a handle for the stream, without starting stream configuration.
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800232 */
Emilian Peevf4816702020-04-03 15:44:51 -0700233 virtual camera_stream* asHalStream() = 0;
Eino-Ville Talvala0b1cb142016-12-19 16:29:17 -0800234
235 /**
Igor Murashkinae500e52013-04-22 14:03:54 -0700236 * Start the stream configuration process. Returns a handle to the stream's
Emilian Peevf4816702020-04-03 15:44:51 -0700237 * information to be passed into the device's configure_streams call.
Igor Murashkinae500e52013-04-22 14:03:54 -0700238 *
239 * Until finishConfiguration() is called, no other methods on the stream may
Emilian Peevf4816702020-04-03 15:44:51 -0700240 * be called. The usage and max_buffers fields of camera_stream may be
Igor Murashkinae500e52013-04-22 14:03:54 -0700241 * modified between start/finishConfiguration, but may not be changed after
Emilian Peevf4816702020-04-03 15:44:51 -0700242 * that. The priv field of camera_stream may be modified at any time after
Igor Murashkinae500e52013-04-22 14:03:54 -0700243 * startConfiguration.
244 *
245 * Returns NULL in case of error starting configuration.
246 */
Emilian Peevf4816702020-04-03 15:44:51 -0700247 virtual camera_stream* startConfiguration() = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700248
249 /**
250 * Check if the stream is mid-configuration (start has been called, but not
251 * finish). Used for lazy completion of configuration.
252 */
253 virtual bool isConfiguring() const = 0;
254
255 /**
256 * Completes the stream configuration process. During this call, the stream
257 * may call the device's register_stream_buffers() method. The stream
258 * information structure returned by startConfiguration() may no longer be
259 * modified after this call, but can still be read until the destruction of
260 * the stream.
261 *
Yin-Chia Yeh573a2702019-04-17 10:08:55 -0700262 * streamReconfigured: set to true when a stream is being reconfigured.
263 *
Igor Murashkinae500e52013-04-22 14:03:54 -0700264 * Returns:
265 * OK on a successful configuration
266 * NO_INIT in case of a serious error from the HAL device
267 * NO_MEMORY in case of an error registering buffers
268 * INVALID_OPERATION in case connecting to the consumer failed
269 */
Yin-Chia Yeh573a2702019-04-17 10:08:55 -0700270 virtual status_t finishConfiguration(/*out*/bool* streamReconfigured = nullptr) = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700271
272 /**
Eino-Ville Talvala17543512014-08-06 14:32:02 -0700273 * Cancels the stream configuration process. This returns the stream to the
274 * initial state, allowing it to be configured again later.
275 * This is done if the HAL rejects the proposed combined stream configuration
276 */
277 virtual status_t cancelConfiguration() = 0;
278
279 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700280 * Determine whether the stream has already become in-use (has received
281 * a valid filled buffer), which determines if a stream can still have
282 * prepareNextBuffer called on it.
283 */
284 virtual bool isUnpreparable() = 0;
285
286 /**
Emilian Peevf0348ae2021-01-13 13:39:45 -0800287 * Mark the stream as unpreparable.
288 */
289 virtual void markUnpreparable() = 0;
290
291 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700292 * Start stream preparation. May only be called in the CONFIGURED state,
Ruben Brunkc78ac262015-08-13 17:58:46 -0700293 * when no valid buffers have yet been returned to this stream. Prepares
294 * up to maxCount buffers, or the maximum number of buffers needed by the
295 * pipeline if maxCount is ALLOCATE_PIPELINE_MAX.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700296 *
297 * If no prepartion is necessary, returns OK and does not transition to
298 * PREPARING state. Otherwise, returns NOT_ENOUGH_DATA and transitions
299 * to PREPARING.
300 *
Shuzhen Wangb3a0fb52018-09-13 17:24:08 -0700301 * blockRequest specifies whether prepare will block upcoming capture
302 * request. This flag should only be set to false if the caller guarantees
303 * the whole buffer preparation process is done before capture request
304 * comes in.
305 *
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700306 * Returns:
307 * OK if no more buffers need to be preallocated
308 * NOT_ENOUGH_DATA if calls to prepareNextBuffer are needed to finish
309 * buffer pre-allocation, and transitions to the PREPARING state.
310 * NO_INIT in case of a serious error from the HAL device
311 * INVALID_OPERATION if called when not in CONFIGURED state, or a
312 * valid buffer has already been returned to this stream.
313 */
Shuzhen Wangb3a0fb52018-09-13 17:24:08 -0700314 virtual status_t startPrepare(int maxCount, bool blockRequest) = 0;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700315
316 /**
Shuzhen Wangb3a0fb52018-09-13 17:24:08 -0700317 * Check if the request on a stream is blocked by prepare.
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700318 */
Shuzhen Wangb3a0fb52018-09-13 17:24:08 -0700319 virtual bool isBlockedByPrepare() const = 0;
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700320
321 /**
322 * Continue stream buffer preparation by allocating the next
323 * buffer for this stream. May only be called in the PREPARED state.
324 *
325 * Returns OK and transitions to the CONFIGURED state if all buffers
326 * are allocated after the call concludes. Otherwise returns NOT_ENOUGH_DATA.
327 *
328 * Returns:
329 * OK if no more buffers need to be preallocated, and transitions
330 * to the CONFIGURED state.
331 * NOT_ENOUGH_DATA if more calls to prepareNextBuffer are needed to finish
332 * buffer pre-allocation.
333 * NO_INIT in case of a serious error from the HAL device
334 * INVALID_OPERATION if called when not in CONFIGURED state, or a
335 * valid buffer has already been returned to this stream.
336 */
337 virtual status_t prepareNextBuffer() = 0;
338
339 /**
340 * Cancel stream preparation early. In case allocation needs to be
341 * stopped, this method transitions the stream back to the CONFIGURED state.
342 * Buffers that have been allocated with prepareNextBuffer remain that way,
343 * but a later use of prepareNextBuffer will require just as many
344 * calls as if the earlier prepare attempt had not existed.
345 *
346 * Returns:
347 * OK if cancellation succeeded, and transitions to the CONFIGURED state
348 * INVALID_OPERATION if not in the PREPARING state
349 * NO_INIT in case of a serious error from the HAL device
350 */
351 virtual status_t cancelPrepare() = 0;
352
353 /**
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700354 * Tear down memory for this stream. This frees all unused gralloc buffers
355 * allocated for this stream, but leaves it ready for operation afterward.
356 *
357 * May only be called in the CONFIGURED state, and keeps the stream in
358 * the CONFIGURED state.
359 *
360 * Returns:
361 * OK if teardown succeeded.
362 * INVALID_OPERATION if not in the CONFIGURED state
363 * NO_INIT in case of a serious error from the HAL device
364 */
365 virtual status_t tearDown() = 0;
366
367 /**
Emilian Peevf4816702020-04-03 15:44:51 -0700368 * Fill in the camera_stream_buffer with the next valid buffer for this
Igor Murashkinae500e52013-04-22 14:03:54 -0700369 * stream, to hand over to the HAL.
370 *
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800371 * Multiple surfaces could share the same HAL stream, but a request may
372 * be only for a subset of surfaces. In this case, the
373 * Camera3StreamInterface object needs the surface ID information to acquire
374 * buffers for those surfaces. For the case of single surface for a HAL
375 * stream, surface_ids parameter has no effect.
376 *
Igor Murashkinae500e52013-04-22 14:03:54 -0700377 * This method may only be called once finishConfiguration has been called.
378 * For bidirectional streams, this method applies to the output-side
379 * buffers.
380 *
381 */
Emilian Peevf4816702020-04-03 15:44:51 -0700382 virtual status_t getBuffer(camera_stream_buffer *buffer,
Yin-Chia Yehb3a80b12018-09-04 12:13:05 -0700383 nsecs_t waitBufferTimeout,
Shuzhen Wangbee0f0a2017-01-24 14:51:37 -0800384 const std::vector<size_t>& surface_ids = std::vector<size_t>()) = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700385
Yin-Chia Yeh14ef48d2020-02-10 15:06:37 -0800386 struct OutstandingBuffer {
387 camera_stream_buffer* outBuffer;
388
389 /**
390 * Multiple surfaces could share the same HAL stream, but a request may
391 * be only for a subset of surfaces. In this case, the
392 * Camera3StreamInterface object needs the surface ID information to acquire
393 * buffers for those surfaces. For the case of single surface for a HAL
394 * stream, surface_ids parameter has no effect.
395 */
396 std::vector<size_t> surface_ids;
397 };
398 /**
399 * Similar to getBuffer() except this method fills multiple buffers.
400 */
401 virtual status_t getBuffers(std::vector<OutstandingBuffer>* buffers,
402 nsecs_t waitBufferTimeout) = 0;
403
Igor Murashkinae500e52013-04-22 14:03:54 -0700404 /**
405 * Return a buffer to the stream after use by the HAL.
406 *
Yin-Chia Yeh58b1b4e2018-10-15 12:18:36 -0700407 * Multiple surfaces could share the same HAL stream, but a request may
408 * be only for a subset of surfaces. In this case, the
409 * Camera3StreamInterface object needs the surface ID information to attach
410 * buffers for those surfaces. For the case of single surface for a HAL
411 * stream, surface_ids parameter has no effect.
412 *
Igor Murashkinae500e52013-04-22 14:03:54 -0700413 * This method may only be called for buffers provided by getBuffer().
414 * For bidirectional streams, this method applies to the output-side buffers
415 */
Emilian Peevf4816702020-04-03 15:44:51 -0700416 virtual status_t returnBuffer(const camera_stream_buffer &buffer,
Shuzhen Wang90708ea2021-11-04 11:40:49 -0700417 nsecs_t timestamp, nsecs_t readoutTimestamp, bool timestampIncreasing = true,
Emilian Peev538c90e2018-12-17 18:03:19 +0000418 const std::vector<size_t>& surface_ids = std::vector<size_t>(),
Emilian Peev5104fe92021-10-21 14:27:09 -0700419 uint64_t frameNumber = 0, int32_t transform = -1) = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700420
421 /**
Emilian Peevf4816702020-04-03 15:44:51 -0700422 * Fill in the camera_stream_buffer with the next valid buffer for this
Igor Murashkinae500e52013-04-22 14:03:54 -0700423 * stream, to hand over to the HAL.
424 *
425 * This method may only be called once finishConfiguration has been called.
426 * For bidirectional streams, this method applies to the input-side
427 * buffers.
428 *
Eino-Ville Talvalaba435252017-06-21 16:07:25 -0700429 * Normally this call will block until the handed out buffer count is less than the stream
430 * max buffer count; if respectHalLimit is set to false, this is ignored.
Igor Murashkinae500e52013-04-22 14:03:54 -0700431 */
Shuzhen Wang83bff122020-11-20 15:51:39 -0800432 virtual status_t getInputBuffer(camera_stream_buffer *buffer,
433 Size *size, bool respectHalLimit = true) = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700434
435 /**
436 * Return a buffer to the stream after use by the HAL.
437 *
438 * This method may only be called for buffers provided by getBuffer().
439 * For bidirectional streams, this method applies to the input-side buffers
440 */
Emilian Peevf4816702020-04-03 15:44:51 -0700441 virtual status_t returnInputBuffer(const camera_stream_buffer &buffer) = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700442
443 /**
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700444 * Get the buffer producer of the input buffer queue.
445 *
446 * This method only applies to input streams.
447 */
448 virtual status_t getInputBufferProducer(sp<IGraphicBufferProducer> *producer) = 0;
449
450 /**
Igor Murashkinae500e52013-04-22 14:03:54 -0700451 * Whether any of the stream's buffers are currently in use by the HAL,
452 * including buffers that have been returned but not yet had their
453 * release fence signaled.
454 */
455 virtual bool hasOutstandingBuffers() const = 0;
456
Yin-Chia Yehd5cd5ff2018-10-01 14:43:04 -0700457 /**
458 * Get number of buffers currently handed out to HAL
459 */
460 virtual size_t getOutstandingBuffersCount() const = 0;
461
Igor Murashkinae500e52013-04-22 14:03:54 -0700462 enum {
463 TIMEOUT_NEVER = -1
464 };
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700465
Igor Murashkinae500e52013-04-22 14:03:54 -0700466 /**
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700467 * Set the state tracker to use for signaling idle transitions.
Igor Murashkinae500e52013-04-22 14:03:54 -0700468 */
Eino-Ville Talvalaf1e98d82013-09-06 09:32:43 -0700469 virtual status_t setStatusTracker(sp<StatusTracker> statusTracker) = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700470
471 /**
472 * Disconnect stream from its non-HAL endpoint. After this,
473 * start/finishConfiguration must be called before the stream can be used
474 * again. This cannot be called if the stream has outstanding dequeued
475 * buffers.
476 */
477 virtual status_t disconnect() = 0;
478
479 /**
Chien-Yu Chene8c535e2016-04-14 12:18:26 -0700480 * Return if the buffer queue of the stream is abandoned.
481 */
482 virtual bool isAbandoned() const = 0;
483
484 /**
Igor Murashkinae500e52013-04-22 14:03:54 -0700485 * Debug dump of the stream's state.
486 */
487 virtual void dump(int fd, const Vector<String16> &args) const = 0;
488
489 virtual void addBufferListener(
490 wp<Camera3StreamBufferListener> listener) = 0;
491 virtual void removeBufferListener(
492 const sp<Camera3StreamBufferListener>& listener) = 0;
Yin-Chia Yehbe83fa72017-03-30 13:35:36 -0700493
494 /**
495 * Setting listner will remove previous listener (if exists)
496 * Only allow set listener during stream configuration because stream is guaranteed to be IDLE
497 * at this state, so setBufferFreedListener won't collide with onBufferFreed callbacks.
498 * Client is responsible to keep the listener object alive throughout the lifecycle of this
499 * Camera3Stream.
500 */
Yin-Chia Yehdb1e8642017-07-14 15:19:30 -0700501 virtual void setBufferFreedListener(wp<Camera3StreamBufferFreedListener> listener) = 0;
Emilian Peev538c90e2018-12-17 18:03:19 +0000502
503 /**
504 * Notify buffer stream listeners about incoming request with particular frame number.
505 */
Shuzhen Wang68ac7ad2019-01-30 14:03:28 -0800506 virtual void fireBufferRequestForFrameNumber(uint64_t frameNumber,
507 const CameraMetadata& settings) = 0;
Igor Murashkinae500e52013-04-22 14:03:54 -0700508};
509
510} // namespace camera3
511
512} // namespace android
513
514#endif