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