blob: b42f3f6bc1f164e4c2722fae6b9b458273776493 [file] [log] [blame]
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -08001/*
Shuzhen Wangc28189a2017-11-27 23:05:10 -08002 * Copyright (C) 2013-2018 The Android Open Source Project
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -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_CAMERA_CAMERADEVICEBASE_H
18#define ANDROID_SERVERS_CAMERA_CAMERADEVICEBASE_H
19
Shuzhen Wang0129d522016-10-30 22:43:41 -070020#include <list>
21
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080022#include <utils/RefBase.h>
23#include <utils/String8.h>
24#include <utils/String16.h>
25#include <utils/Vector.h>
Emilian Peev40ead602017-09-26 15:46:36 +010026#include <utils/KeyedVector.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080027#include <utils/Timers.h>
Jianing Wei90e59c92014-03-12 18:29:36 -070028#include <utils/List.h>
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080029
30#include "hardware/camera2.h"
31#include "camera/CameraMetadata.h"
Jianing Weicb0652e2014-03-12 18:29:36 -070032#include "camera/CaptureResult.h"
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -070033#include "gui/IGraphicBufferProducer.h"
Zhijun He125684a2015-12-26 15:07:30 -080034#include "device3/Camera3StreamInterface.h"
Shuzhen Wange8675782019-12-05 09:12:14 -080035#include "device3/StatusTracker.h"
Eino-Ville Talvalad56db1d2015-12-17 16:50:35 -080036#include "binder/Status.h"
Emilian Peevfaa4bde2020-01-23 12:19:37 -080037#include "FrameProducer.h"
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080038
Yin-Chia Yehb978c382019-10-30 00:22:37 -070039#include "CameraOfflineSessionBase.h"
40
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080041namespace android {
42
Emilian Peevf4816702020-04-03 15:44:51 -070043namespace camera3 {
44
45typedef enum camera_request_template {
46 CAMERA_TEMPLATE_PREVIEW = 1,
47 CAMERA_TEMPLATE_STILL_CAPTURE = 2,
48 CAMERA_TEMPLATE_VIDEO_RECORD = 3,
49 CAMERA_TEMPLATE_VIDEO_SNAPSHOT = 4,
50 CAMERA_TEMPLATE_ZERO_SHUTTER_LAG = 5,
51 CAMERA_TEMPLATE_MANUAL = 6,
52 CAMERA_TEMPLATE_COUNT,
53 CAMERA_VENDOR_TEMPLATE_START = 0x40000000
54} camera_request_template_t;
55
56typedef enum camera_stream_configuration_mode {
57 CAMERA_STREAM_CONFIGURATION_NORMAL_MODE = 0,
58 CAMERA_STREAM_CONFIGURATION_CONSTRAINED_HIGH_SPEED_MODE = 1,
59 CAMERA_VENDOR_STREAM_CONFIGURATION_MODE_START = 0x8000
60} camera_stream_configuration_mode_t;
61
62typedef struct camera_jpeg_blob {
63 uint16_t jpeg_blob_id;
64 uint32_t jpeg_size;
65} camera_jpeg_blob_t;
66
67enum {
68 CAMERA_JPEG_BLOB_ID = 0x00FF,
69 CAMERA_JPEG_APP_SEGMENTS_BLOB_ID = 0x0100,
70};
71
72} // namespace camera3
73
74using camera3::camera_request_template_t;;
75using camera3::camera_stream_configuration_mode_t;
76using camera3::camera_stream_rotation_t;
77
Eino-Ville Talvala2f09bac2016-12-13 11:29:54 -080078class CameraProviderManager;
79
Shuzhen Wang0129d522016-10-30 22:43:41 -070080// Mapping of output stream index to surface ids
81typedef std::unordered_map<int, std::vector<size_t> > SurfaceMap;
82
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080083/**
84 * Base interface for version >= 2 camera device classes, which interface to
85 * camera HAL device versions >= 2.
86 */
Emilian Peevfaa4bde2020-01-23 12:19:37 -080087class CameraDeviceBase : public virtual FrameProducer {
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080088 public:
89 virtual ~CameraDeviceBase();
90
Igor Murashkin71381052013-03-04 14:53:08 -080091 /**
Emilian Peev00420d22018-02-05 21:33:13 +000092 * The device vendor tag ID
93 */
94 virtual metadata_vendor_id_t getVendorTagId() const = 0;
95
Emilian Peevbd8c5032018-02-14 23:05:40 +000096 virtual status_t initialize(sp<CameraProviderManager> manager, const String8& monitorTags) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -080097 virtual status_t disconnect() = 0;
98
Jianing Weicb0652e2014-03-12 18:29:36 -070099 virtual status_t dump(int fd, const Vector<String16> &args) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800100
101 /**
Jayant Chowdhary6a6d3a82021-11-17 16:54:34 -0800102 * The physical camera device's static characteristics metadata buffer, or
103 * the logical camera's static characteristics if physical id is empty.
Shuzhen Wang2e7f58f2018-07-11 14:00:29 -0700104 */
Emilian Peevfaa4bde2020-01-23 12:19:37 -0800105 virtual const CameraMetadata& infoPhysical(const String8& physicalId) const = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800106
Emilian Peevaebbe412018-01-15 13:53:24 +0000107 struct PhysicalCameraSettings {
108 std::string cameraId;
109 CameraMetadata metadata;
Shuzhen Wang911c6a32021-10-27 13:36:03 -0700110
111 // Whether the physical camera supports testPatternMode/testPatternData
112 bool mHasTestPatternModeTag = true;
113 bool mHasTestPatternDataTag = true;
114
115 // Original value of TEST_PATTERN_MODE and DATA so that they can be
116 // restored when sensor muting is turned off
117 int32_t mOriginalTestPatternMode = 0;
118 int32_t mOriginalTestPatternData[4] = {};
119
Emilian Peevaebbe412018-01-15 13:53:24 +0000120 };
121 typedef List<PhysicalCameraSettings> PhysicalCameraSettingsList;
122
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800123 /**
124 * Submit request for capture. The CameraDevice takes ownership of the
125 * passed-in buffer.
Jianing Weicb0652e2014-03-12 18:29:36 -0700126 * Output lastFrameNumber is the expected frame number of this request.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800127 */
Jianing Weicb0652e2014-03-12 18:29:36 -0700128 virtual status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800129
130 /**
Jianing Wei90e59c92014-03-12 18:29:36 -0700131 * Submit a list of requests.
Jianing Weicb0652e2014-03-12 18:29:36 -0700132 * Output lastFrameNumber is the expected last frame number of the list of requests.
Jianing Wei90e59c92014-03-12 18:29:36 -0700133 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000134 virtual status_t captureList(const List<const PhysicalCameraSettingsList> &requests,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700135 const std::list<const SurfaceMap> &surfaceMaps,
Jianing Weicb0652e2014-03-12 18:29:36 -0700136 int64_t *lastFrameNumber = NULL) = 0;
Jianing Wei90e59c92014-03-12 18:29:36 -0700137
138 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800139 * Submit request for streaming. The CameraDevice makes a copy of the
140 * passed-in buffer and the caller retains ownership.
Jianing Weicb0652e2014-03-12 18:29:36 -0700141 * Output lastFrameNumber is the last frame number of the previous streaming request.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800142 */
Jianing Weicb0652e2014-03-12 18:29:36 -0700143 virtual status_t setStreamingRequest(const CameraMetadata &request,
144 int64_t *lastFrameNumber = NULL) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800145
146 /**
Jianing Wei90e59c92014-03-12 18:29:36 -0700147 * Submit a list of requests for streaming.
Jianing Weicb0652e2014-03-12 18:29:36 -0700148 * Output lastFrameNumber is the last frame number of the previous streaming request.
Jianing Wei90e59c92014-03-12 18:29:36 -0700149 */
Emilian Peevaebbe412018-01-15 13:53:24 +0000150 virtual status_t setStreamingRequestList(const List<const PhysicalCameraSettingsList> &requests,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700151 const std::list<const SurfaceMap> &surfaceMaps,
Jianing Weicb0652e2014-03-12 18:29:36 -0700152 int64_t *lastFrameNumber = NULL) = 0;
Jianing Wei90e59c92014-03-12 18:29:36 -0700153
154 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800155 * Clear the streaming request slot.
Jianing Weicb0652e2014-03-12 18:29:36 -0700156 * Output lastFrameNumber is the last frame number of the previous streaming request.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800157 */
Jianing Weicb0652e2014-03-12 18:29:36 -0700158 virtual status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800159
160 /**
161 * Wait until a request with the given ID has been dequeued by the
162 * HAL. Returns TIMED_OUT if the timeout duration is reached. Returns
163 * immediately if the latest request received by the HAL has this id.
164 */
165 virtual status_t waitUntilRequestReceived(int32_t requestId,
166 nsecs_t timeout) = 0;
167
168 /**
Yin-Chia Yehb97babb2015-03-12 13:42:44 -0700169 * Create an output stream of the requested size, format, rotation and dataspace
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800170 *
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800171 * For HAL_PIXEL_FORMAT_BLOB formats, the width and height should be the
172 * logical dimensions of the buffer, not the number of bytes.
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800173 */
Eino-Ville Talvala727d1722015-06-09 13:44:19 -0700174 virtual status_t createStream(sp<Surface> consumer,
Eino-Ville Talvala3d82c0d2015-02-23 15:19:19 -0800175 uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700176 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800177 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800178 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev40ead602017-09-26 15:46:36 +0100179 std::vector<int> *surfaceIds = nullptr,
Zhijun He5d677d12016-05-29 16:52:39 -0700180 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800181 bool isShared = false, bool isMultiResolution = false,
182 uint64_t consumerUsage = 0) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800183
184 /**
Shuzhen Wang0129d522016-10-30 22:43:41 -0700185 * Create an output stream of the requested size, format, rotation and
186 * dataspace with a number of consumers.
187 *
188 * For HAL_PIXEL_FORMAT_BLOB formats, the width and height should be the
189 * logical dimensions of the buffer, not the number of bytes.
190 */
191 virtual status_t createStream(const std::vector<sp<Surface>>& consumers,
192 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format,
Emilian Peevf4816702020-04-03 15:44:51 -0700193 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id,
Shuzhen Wangc28189a2017-11-27 23:05:10 -0800194 const String8& physicalCameraId,
Jayant Chowdhary13f9b2f2020-12-02 22:46:15 -0800195 const std::unordered_set<int32_t> &sensorPixelModesUsed,
Emilian Peev40ead602017-09-26 15:46:36 +0100196 std::vector<int> *surfaceIds = nullptr,
Shuzhen Wang0129d522016-10-30 22:43:41 -0700197 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800198 bool isShared = false, bool isMultiResolution = false,
199 uint64_t consumerUsage = 0) = 0;
Shuzhen Wang0129d522016-10-30 22:43:41 -0700200
201 /**
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700202 * Create an input stream of width, height, and format.
203 *
204 * Return value is the stream ID if non-negative and an error if negative.
205 */
206 virtual status_t createInputStream(uint32_t width, uint32_t height,
Shuzhen Wang83bff122020-11-20 15:51:39 -0800207 int32_t format, bool multiResolution, /*out*/ int32_t *id) = 0;
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700208
Emilian Peev710c1422017-08-30 11:19:38 +0100209 struct StreamInfo {
210 uint32_t width;
211 uint32_t height;
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700212
Emilian Peev710c1422017-08-30 11:19:38 +0100213 uint32_t format;
214 bool formatOverridden;
215 uint32_t originalFormat;
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700216
Emilian Peev710c1422017-08-30 11:19:38 +0100217 android_dataspace dataSpace;
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700218 bool dataSpaceOverridden;
219 android_dataspace originalDataSpace;
220
Emilian Peev710c1422017-08-30 11:19:38 +0100221 StreamInfo() : width(0), height(0), format(0), formatOverridden(false), originalFormat(0),
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700222 dataSpace(HAL_DATASPACE_UNKNOWN), dataSpaceOverridden(false),
223 originalDataSpace(HAL_DATASPACE_UNKNOWN) {}
Emilian Peev710c1422017-08-30 11:19:38 +0100224 /**
225 * Check whether the format matches the current or the original one in case
226 * it got overridden.
227 */
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700228 bool matchFormat(uint32_t clientFormat) const {
Emilian Peev710c1422017-08-30 11:19:38 +0100229 if ((formatOverridden && (originalFormat == clientFormat)) ||
230 (format == clientFormat)) {
231 return true;
232 }
233 return false;
234 }
Eino-Ville Talvala91cd3f82017-08-21 16:12:50 -0700235
236 /**
237 * Check whether the dataspace matches the current or the original one in case
238 * it got overridden.
239 */
240 bool matchDataSpace(android_dataspace clientDataSpace) const {
241 if ((dataSpaceOverridden && (originalDataSpace == clientDataSpace)) ||
242 (dataSpace == clientDataSpace)) {
243 return true;
244 }
245 return false;
246 }
247
Emilian Peev710c1422017-08-30 11:19:38 +0100248 };
249
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700250 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800251 * Get information about a given stream.
252 */
Emilian Peev710c1422017-08-30 11:19:38 +0100253 virtual status_t getStreamInfo(int id, StreamInfo *streamInfo) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800254
255 /**
256 * Set stream gralloc buffer transform
257 */
258 virtual status_t setStreamTransform(int id, int transform) = 0;
259
260 /**
261 * Delete stream. Must not be called if there are requests in flight which
262 * reference that stream.
263 */
264 virtual status_t deleteStream(int id) = 0;
265
266 /**
Igor Murashkine2d167e2014-08-19 16:19:59 -0700267 * Take the currently-defined set of streams and configure the HAL to use
268 * them. This is a long-running operation (may be several hundered ms).
269 *
270 * The device must be idle (see waitUntilDrained) before calling this.
271 *
272 * Returns OK on success; otherwise on error:
273 * - BAD_VALUE if the set of streams was invalid (e.g. fmts or sizes)
274 * - INVALID_OPERATION if the device was in the wrong state
275 */
Emilian Peev5fbe0ba2017-10-20 15:45:45 +0100276 virtual status_t configureStreams(const CameraMetadata& sessionParams,
Emilian Peevf4816702020-04-03 15:44:51 -0700277 int operatingMode =
278 camera_stream_configuration_mode_t::CAMERA_STREAM_CONFIGURATION_NORMAL_MODE) = 0;
Igor Murashkine2d167e2014-08-19 16:19:59 -0700279
Emilian Peevcc0b7952020-01-07 13:54:47 -0800280 /**
281 * Retrieve a list of all stream ids that were advertised as capable of
282 * supporting offline processing mode by Hal after the last stream configuration.
283 */
284 virtual void getOfflineStreamIds(std::vector<int> *offlineStreamIds) = 0;
285
Chien-Yu Chen618ff8a2015-03-13 11:27:17 -0700286 // get the buffer producer of the input stream
287 virtual status_t getInputBufferProducer(
288 sp<IGraphicBufferProducer> *producer) = 0;
289
Igor Murashkine2d167e2014-08-19 16:19:59 -0700290 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800291 * Create a metadata buffer with fields that the HAL device believes are
292 * best for the given use case
293 */
Emilian Peevf4816702020-04-03 15:44:51 -0700294 virtual status_t createDefaultRequest(camera_request_template_t templateId,
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800295 CameraMetadata *request) = 0;
296
297 /**
298 * Wait until all requests have been processed. Returns INVALID_OPERATION if
299 * the streaming slot is not empty, or TIMED_OUT if the requests haven't
300 * finished processing in 10 seconds.
301 */
302 virtual status_t waitUntilDrained() = 0;
303
304 /**
Zhijun He28c9b6f2014-08-08 12:00:47 -0700305 * Get Jpeg buffer size for a given jpeg resolution.
306 * Negative values are error codes.
307 */
Jayant Chowdhary6a6d3a82021-11-17 16:54:34 -0800308 virtual ssize_t getJpegBufferSize(const CameraMetadata &info, uint32_t width,
309 uint32_t height) const = 0;
Zhijun He28c9b6f2014-08-08 12:00:47 -0700310
311 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800312 * Connect HAL notifications to a listener. Overwrites previous
313 * listener. Set to NULL to stop receiving notifications.
314 */
Yin-Chia Yehe1c80632016-08-08 14:48:05 -0700315 virtual status_t setNotifyCallback(wp<NotificationListener> listener) = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800316
317 /**
Eino-Ville Talvala46910bd2013-07-18 19:15:17 -0700318 * Whether the device supports calling notifyAutofocus, notifyAutoExposure,
319 * and notifyAutoWhitebalance; if this returns false, the client must
320 * synthesize these notifications from received frame metadata.
321 */
322 virtual bool willNotify3A() = 0;
323
324 /**
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800325 * Trigger auto-focus. The latest ID used in a trigger autofocus or cancel
326 * autofocus call will be returned by the HAL in all subsequent AF
327 * notifications.
328 */
329 virtual status_t triggerAutofocus(uint32_t id) = 0;
330
331 /**
332 * Cancel auto-focus. The latest ID used in a trigger autofocus/cancel
333 * autofocus call will be returned by the HAL in all subsequent AF
334 * notifications.
335 */
336 virtual status_t triggerCancelAutofocus(uint32_t id) = 0;
337
338 /**
339 * Trigger pre-capture metering. The latest ID used in a trigger pre-capture
340 * call will be returned by the HAL in all subsequent AE and AWB
341 * notifications.
342 */
343 virtual status_t triggerPrecaptureMetering(uint32_t id) = 0;
344
345 /**
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700346 * Flush all pending and in-flight requests. Blocks until flush is
347 * complete.
Jianing Weicb0652e2014-03-12 18:29:36 -0700348 * Output lastFrameNumber is the last frame number of the previous streaming request.
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700349 */
Jianing Weicb0652e2014-03-12 18:29:36 -0700350 virtual status_t flush(int64_t *lastFrameNumber = NULL) = 0;
Eino-Ville Talvalaabaa51d2013-08-14 11:37:00 -0700351
Zhijun He204e3292014-07-14 17:09:23 -0700352 /**
Eino-Ville Talvala4d44cad2015-04-11 13:15:45 -0700353 * Prepare stream by preallocating buffers for it asynchronously.
354 * Calls notifyPrepared() once allocation is complete.
355 */
356 virtual status_t prepare(int streamId) = 0;
357
358 /**
Eino-Ville Talvalab25e3c82015-07-15 16:04:27 -0700359 * Free stream resources by dumping its unused gralloc buffers.
360 */
361 virtual status_t tearDown(int streamId) = 0;
362
363 /**
Shuzhen Wangb0fdc1e2016-03-20 23:21:39 -0700364 * Add buffer listener for a particular stream in the device.
365 */
366 virtual status_t addBufferListenerForStream(int streamId,
367 wp<camera3::Camera3StreamBufferListener> listener) = 0;
368
369 /**
Ruben Brunkc78ac262015-08-13 17:58:46 -0700370 * Prepare stream by preallocating up to maxCount buffers for it asynchronously.
371 * Calls notifyPrepared() once allocation is complete.
372 */
373 virtual status_t prepare(int maxCount, int streamId) = 0;
374
375 /**
Zhijun He5d677d12016-05-29 16:52:39 -0700376 * Set the deferred consumer surface and finish the rest of the stream configuration.
377 */
Shuzhen Wang758c2152017-01-10 18:26:18 -0800378 virtual status_t setConsumerSurfaces(int streamId,
Emilian Peev40ead602017-09-26 15:46:36 +0100379 const std::vector<sp<Surface>>& consumers, std::vector<int> *surfaceIds /*out*/) = 0;
Zhijun He5d677d12016-05-29 16:52:39 -0700380
Emilian Peev40ead602017-09-26 15:46:36 +0100381 /**
382 * Update a given stream.
383 */
384 virtual status_t updateStream(int streamId, const std::vector<sp<Surface>> &newSurfaces,
385 const std::vector<android::camera3::OutputStreamInfo> &outputInfo,
386 const std::vector<size_t> &removedSurfaceIds,
387 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/) = 0;
Chien-Yu Chena936ac22017-10-23 15:59:49 -0700388
389 /**
390 * Drop buffers for stream of streamId if dropping is true. If dropping is false, do not
391 * drop buffers for stream of streamId.
392 */
393 virtual status_t dropStreamBuffers(bool /*dropping*/, int /*streamId*/) = 0;
Emilian Peev2a8e2832019-08-23 13:00:31 -0700394
395 /**
396 * Returns the maximum expected time it'll take for all currently in-flight
397 * requests to complete, based on their settings
398 */
399 virtual nsecs_t getExpectedInFlightDuration() = 0;
Yin-Chia Yehb978c382019-10-30 00:22:37 -0700400
401 /**
402 * switch to offline session
403 */
404 virtual status_t switchToOffline(
405 const std::vector<int32_t>& streamsToKeep,
406 /*out*/ sp<CameraOfflineSessionBase>* session) = 0;
Eino-Ville Talvalaf2e37092020-01-07 15:32:32 -0800407
408 /**
409 * Set the current behavior for the ROTATE_AND_CROP control when in AUTO.
410 *
411 * The value must be one of the ROTATE_AND_CROP_* values besides AUTO,
412 * and defaults to NONE.
413 */
414 virtual status_t setRotateAndCropAutoBehavior(
415 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue) = 0;
416
Shuzhen Wange8675782019-12-05 09:12:14 -0800417 /**
Eino-Ville Talvala305cec62020-11-12 14:18:17 -0800418 * Whether camera muting (producing black-only output) is supported.
419 *
420 * Calling setCameraMute(true) when this returns false will return an
421 * INVALID_OPERATION error.
422 */
423 virtual bool supportsCameraMute() = 0;
424
425 /**
426 * Mute the camera.
427 *
428 * When muted, black image data is output on all output streams.
429 */
430 virtual status_t setCameraMute(bool enabled) = 0;
431
432 /**
Shuzhen Wange8675782019-12-05 09:12:14 -0800433 * Get the status tracker of the camera device
434 */
435 virtual wp<camera3::StatusTracker> getStatusTracker() = 0;
Shuzhen Wangabbcb6b2020-12-09 22:32:44 -0800436
437 /**
438 * Set bitmask for image dump flag
439 */
440 void setImageDumpMask(int mask) { mImageDumpMask = mask; }
441
442protected:
443 bool mImageDumpMask = 0;
Eino-Ville Talvala7fa43f32013-02-06 17:20:07 -0800444};
445
446}; // namespace android
447
448#endif