1 /* 2 * Copyright (C) 2013-2018 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_CAMERA_CAMERADEVICEBASE_H 18 #define ANDROID_SERVERS_CAMERA_CAMERADEVICEBASE_H 19 20 #include <list> 21 22 #include <utils/RefBase.h> 23 #include <utils/String8.h> 24 #include <utils/String16.h> 25 #include <utils/Vector.h> 26 #include <utils/KeyedVector.h> 27 #include <utils/Timers.h> 28 #include <utils/List.h> 29 30 #include "hardware/camera2.h" 31 #include "camera/CameraMetadata.h" 32 #include "camera/CaptureResult.h" 33 #include "gui/IGraphicBufferProducer.h" 34 #include "device3/Camera3StreamInterface.h" 35 #include "device3/StatusTracker.h" 36 #include "binder/Status.h" 37 #include "FrameProducer.h" 38 39 #include "CameraOfflineSessionBase.h" 40 41 namespace android { 42 43 namespace camera3 { 44 45 typedef 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 56 typedef 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 62 typedef struct camera_jpeg_blob { 63 uint16_t jpeg_blob_id; 64 uint32_t jpeg_size; 65 } camera_jpeg_blob_t; 66 67 enum { 68 CAMERA_JPEG_BLOB_ID = 0x00FF, 69 CAMERA_JPEG_APP_SEGMENTS_BLOB_ID = 0x0100, 70 }; 71 72 } // namespace camera3 73 74 using camera3::camera_request_template_t;; 75 using camera3::camera_stream_configuration_mode_t; 76 using camera3::camera_stream_rotation_t; 77 78 class CameraProviderManager; 79 80 // Mapping of output stream index to surface ids 81 typedef std::unordered_map<int, std::vector<size_t> > SurfaceMap; 82 83 /** 84 * Base interface for version >= 2 camera device classes, which interface to 85 * camera HAL device versions >= 2. 86 */ 87 class CameraDeviceBase : public virtual FrameProducer { 88 public: 89 virtual ~CameraDeviceBase(); 90 91 /** 92 * The device vendor tag ID 93 */ 94 virtual metadata_vendor_id_t getVendorTagId() const = 0; 95 96 virtual status_t initialize(sp<CameraProviderManager> manager, const String8& monitorTags) = 0; 97 virtual status_t disconnect() = 0; 98 99 virtual status_t dump(int fd, const Vector<String16> &args) = 0; 100 101 /** 102 * The physical camera device's static characteristics metadata buffer 103 */ 104 virtual const CameraMetadata& infoPhysical(const String8& physicalId) const = 0; 105 106 struct PhysicalCameraSettings { 107 std::string cameraId; 108 CameraMetadata metadata; 109 }; 110 typedef List<PhysicalCameraSettings> PhysicalCameraSettingsList; 111 112 /** 113 * Submit request for capture. The CameraDevice takes ownership of the 114 * passed-in buffer. 115 * Output lastFrameNumber is the expected frame number of this request. 116 */ 117 virtual status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) = 0; 118 119 /** 120 * Submit a list of requests. 121 * Output lastFrameNumber is the expected last frame number of the list of requests. 122 */ 123 virtual status_t captureList(const List<const PhysicalCameraSettingsList> &requests, 124 const std::list<const SurfaceMap> &surfaceMaps, 125 int64_t *lastFrameNumber = NULL) = 0; 126 127 /** 128 * Submit request for streaming. The CameraDevice makes a copy of the 129 * passed-in buffer and the caller retains ownership. 130 * Output lastFrameNumber is the last frame number of the previous streaming request. 131 */ 132 virtual status_t setStreamingRequest(const CameraMetadata &request, 133 int64_t *lastFrameNumber = NULL) = 0; 134 135 /** 136 * Submit a list of requests for streaming. 137 * Output lastFrameNumber is the last frame number of the previous streaming request. 138 */ 139 virtual status_t setStreamingRequestList(const List<const PhysicalCameraSettingsList> &requests, 140 const std::list<const SurfaceMap> &surfaceMaps, 141 int64_t *lastFrameNumber = NULL) = 0; 142 143 /** 144 * Clear the streaming request slot. 145 * Output lastFrameNumber is the last frame number of the previous streaming request. 146 */ 147 virtual status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) = 0; 148 149 /** 150 * Wait until a request with the given ID has been dequeued by the 151 * HAL. Returns TIMED_OUT if the timeout duration is reached. Returns 152 * immediately if the latest request received by the HAL has this id. 153 */ 154 virtual status_t waitUntilRequestReceived(int32_t requestId, 155 nsecs_t timeout) = 0; 156 157 /** 158 * Create an output stream of the requested size, format, rotation and dataspace 159 * 160 * For HAL_PIXEL_FORMAT_BLOB formats, the width and height should be the 161 * logical dimensions of the buffer, not the number of bytes. 162 */ 163 virtual status_t createStream(sp<Surface> consumer, 164 uint32_t width, uint32_t height, int format, 165 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id, 166 const String8& physicalCameraId, 167 const std::unordered_set<int32_t> &sensorPixelModesUsed, 168 std::vector<int> *surfaceIds = nullptr, 169 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID, 170 bool isShared = false, bool isMultiResolution = false, 171 uint64_t consumerUsage = 0) = 0; 172 173 /** 174 * Create an output stream of the requested size, format, rotation and 175 * dataspace with a number of consumers. 176 * 177 * For HAL_PIXEL_FORMAT_BLOB formats, the width and height should be the 178 * logical dimensions of the buffer, not the number of bytes. 179 */ 180 virtual status_t createStream(const std::vector<sp<Surface>>& consumers, 181 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, 182 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id, 183 const String8& physicalCameraId, 184 const std::unordered_set<int32_t> &sensorPixelModesUsed, 185 std::vector<int> *surfaceIds = nullptr, 186 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID, 187 bool isShared = false, bool isMultiResolution = false, 188 uint64_t consumerUsage = 0) = 0; 189 190 /** 191 * Create an input stream of width, height, and format. 192 * 193 * Return value is the stream ID if non-negative and an error if negative. 194 */ 195 virtual status_t createInputStream(uint32_t width, uint32_t height, 196 int32_t format, bool multiResolution, /*out*/ int32_t *id) = 0; 197 198 struct StreamInfo { 199 uint32_t width; 200 uint32_t height; 201 202 uint32_t format; 203 bool formatOverridden; 204 uint32_t originalFormat; 205 206 android_dataspace dataSpace; 207 bool dataSpaceOverridden; 208 android_dataspace originalDataSpace; 209 StreamInfoStreamInfo210 StreamInfo() : width(0), height(0), format(0), formatOverridden(false), originalFormat(0), 211 dataSpace(HAL_DATASPACE_UNKNOWN), dataSpaceOverridden(false), 212 originalDataSpace(HAL_DATASPACE_UNKNOWN) {} 213 /** 214 * Check whether the format matches the current or the original one in case 215 * it got overridden. 216 */ matchFormatStreamInfo217 bool matchFormat(uint32_t clientFormat) const { 218 if ((formatOverridden && (originalFormat == clientFormat)) || 219 (format == clientFormat)) { 220 return true; 221 } 222 return false; 223 } 224 225 /** 226 * Check whether the dataspace matches the current or the original one in case 227 * it got overridden. 228 */ matchDataSpaceStreamInfo229 bool matchDataSpace(android_dataspace clientDataSpace) const { 230 if ((dataSpaceOverridden && (originalDataSpace == clientDataSpace)) || 231 (dataSpace == clientDataSpace)) { 232 return true; 233 } 234 return false; 235 } 236 237 }; 238 239 /** 240 * Get information about a given stream. 241 */ 242 virtual status_t getStreamInfo(int id, StreamInfo *streamInfo) = 0; 243 244 /** 245 * Set stream gralloc buffer transform 246 */ 247 virtual status_t setStreamTransform(int id, int transform) = 0; 248 249 /** 250 * Delete stream. Must not be called if there are requests in flight which 251 * reference that stream. 252 */ 253 virtual status_t deleteStream(int id) = 0; 254 255 /** 256 * Take the currently-defined set of streams and configure the HAL to use 257 * them. This is a long-running operation (may be several hundered ms). 258 * 259 * The device must be idle (see waitUntilDrained) before calling this. 260 * 261 * Returns OK on success; otherwise on error: 262 * - BAD_VALUE if the set of streams was invalid (e.g. fmts or sizes) 263 * - INVALID_OPERATION if the device was in the wrong state 264 */ 265 virtual status_t configureStreams(const CameraMetadata& sessionParams, 266 int operatingMode = 267 camera_stream_configuration_mode_t::CAMERA_STREAM_CONFIGURATION_NORMAL_MODE) = 0; 268 269 /** 270 * Retrieve a list of all stream ids that were advertised as capable of 271 * supporting offline processing mode by Hal after the last stream configuration. 272 */ 273 virtual void getOfflineStreamIds(std::vector<int> *offlineStreamIds) = 0; 274 275 // get the buffer producer of the input stream 276 virtual status_t getInputBufferProducer( 277 sp<IGraphicBufferProducer> *producer) = 0; 278 279 /** 280 * Create a metadata buffer with fields that the HAL device believes are 281 * best for the given use case 282 */ 283 virtual status_t createDefaultRequest(camera_request_template_t templateId, 284 CameraMetadata *request) = 0; 285 286 /** 287 * Wait until all requests have been processed. Returns INVALID_OPERATION if 288 * the streaming slot is not empty, or TIMED_OUT if the requests haven't 289 * finished processing in 10 seconds. 290 */ 291 virtual status_t waitUntilDrained() = 0; 292 293 /** 294 * Get Jpeg buffer size for a given jpeg resolution. 295 * Negative values are error codes. 296 */ 297 virtual ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const = 0; 298 299 /** 300 * Connect HAL notifications to a listener. Overwrites previous 301 * listener. Set to NULL to stop receiving notifications. 302 */ 303 virtual status_t setNotifyCallback(wp<NotificationListener> listener) = 0; 304 305 /** 306 * Whether the device supports calling notifyAutofocus, notifyAutoExposure, 307 * and notifyAutoWhitebalance; if this returns false, the client must 308 * synthesize these notifications from received frame metadata. 309 */ 310 virtual bool willNotify3A() = 0; 311 312 /** 313 * Trigger auto-focus. The latest ID used in a trigger autofocus or cancel 314 * autofocus call will be returned by the HAL in all subsequent AF 315 * notifications. 316 */ 317 virtual status_t triggerAutofocus(uint32_t id) = 0; 318 319 /** 320 * Cancel auto-focus. The latest ID used in a trigger autofocus/cancel 321 * autofocus call will be returned by the HAL in all subsequent AF 322 * notifications. 323 */ 324 virtual status_t triggerCancelAutofocus(uint32_t id) = 0; 325 326 /** 327 * Trigger pre-capture metering. The latest ID used in a trigger pre-capture 328 * call will be returned by the HAL in all subsequent AE and AWB 329 * notifications. 330 */ 331 virtual status_t triggerPrecaptureMetering(uint32_t id) = 0; 332 333 /** 334 * Flush all pending and in-flight requests. Blocks until flush is 335 * complete. 336 * Output lastFrameNumber is the last frame number of the previous streaming request. 337 */ 338 virtual status_t flush(int64_t *lastFrameNumber = NULL) = 0; 339 340 /** 341 * Prepare stream by preallocating buffers for it asynchronously. 342 * Calls notifyPrepared() once allocation is complete. 343 */ 344 virtual status_t prepare(int streamId) = 0; 345 346 /** 347 * Free stream resources by dumping its unused gralloc buffers. 348 */ 349 virtual status_t tearDown(int streamId) = 0; 350 351 /** 352 * Add buffer listener for a particular stream in the device. 353 */ 354 virtual status_t addBufferListenerForStream(int streamId, 355 wp<camera3::Camera3StreamBufferListener> listener) = 0; 356 357 /** 358 * Prepare stream by preallocating up to maxCount buffers for it asynchronously. 359 * Calls notifyPrepared() once allocation is complete. 360 */ 361 virtual status_t prepare(int maxCount, int streamId) = 0; 362 363 /** 364 * Set the deferred consumer surface and finish the rest of the stream configuration. 365 */ 366 virtual status_t setConsumerSurfaces(int streamId, 367 const std::vector<sp<Surface>>& consumers, std::vector<int> *surfaceIds /*out*/) = 0; 368 369 /** 370 * Update a given stream. 371 */ 372 virtual status_t updateStream(int streamId, const std::vector<sp<Surface>> &newSurfaces, 373 const std::vector<android::camera3::OutputStreamInfo> &outputInfo, 374 const std::vector<size_t> &removedSurfaceIds, 375 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/) = 0; 376 377 /** 378 * Drop buffers for stream of streamId if dropping is true. If dropping is false, do not 379 * drop buffers for stream of streamId. 380 */ 381 virtual status_t dropStreamBuffers(bool /*dropping*/, int /*streamId*/) = 0; 382 383 /** 384 * Returns the maximum expected time it'll take for all currently in-flight 385 * requests to complete, based on their settings 386 */ 387 virtual nsecs_t getExpectedInFlightDuration() = 0; 388 389 /** 390 * switch to offline session 391 */ 392 virtual status_t switchToOffline( 393 const std::vector<int32_t>& streamsToKeep, 394 /*out*/ sp<CameraOfflineSessionBase>* session) = 0; 395 396 /** 397 * Set the current behavior for the ROTATE_AND_CROP control when in AUTO. 398 * 399 * The value must be one of the ROTATE_AND_CROP_* values besides AUTO, 400 * and defaults to NONE. 401 */ 402 virtual status_t setRotateAndCropAutoBehavior( 403 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue) = 0; 404 405 /** 406 * Whether camera muting (producing black-only output) is supported. 407 * 408 * Calling setCameraMute(true) when this returns false will return an 409 * INVALID_OPERATION error. 410 */ 411 virtual bool supportsCameraMute() = 0; 412 413 /** 414 * Mute the camera. 415 * 416 * When muted, black image data is output on all output streams. 417 */ 418 virtual status_t setCameraMute(bool enabled) = 0; 419 420 /** 421 * Get the status tracker of the camera device 422 */ 423 virtual wp<camera3::StatusTracker> getStatusTracker() = 0; 424 425 /** 426 * Set bitmask for image dump flag 427 */ setImageDumpMask(int mask)428 void setImageDumpMask(int mask) { mImageDumpMask = mask; } 429 430 protected: 431 bool mImageDumpMask = 0; 432 }; 433 434 }; // namespace android 435 436 #endif 437