Camera3Device.h revision a640c5a8731adb001b955192ce032c69c7322849
1/* 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_CAMERA3DEVICE_H 18#define ANDROID_SERVERS_CAMERA3DEVICE_H 19 20#include <utility> 21#include <unordered_map> 22 23#include <utils/Condition.h> 24#include <utils/Errors.h> 25#include <utils/List.h> 26#include <utils/Mutex.h> 27#include <utils/Thread.h> 28#include <utils/KeyedVector.h> 29#include <utils/Timers.h> 30 31#include <android/hardware/camera/device/3.2/ICameraDevice.h> 32#include <android/hardware/camera/device/3.2/ICameraDeviceSession.h> 33#include <android/hardware/camera/device/3.2/ICameraDeviceCallback.h> 34#include <fmq/MessageQueue.h> 35#include <hardware/camera3.h> 36 37#include <camera/CaptureResult.h> 38 39#include "common/CameraDeviceBase.h" 40#include "device3/StatusTracker.h" 41#include "device3/Camera3BufferManager.h" 42#include "utils/TagMonitor.h" 43#include <camera_metadata_hidden.h> 44 45/** 46 * Function pointer types with C calling convention to 47 * use for HAL callback functions. 48 */ 49extern "C" { 50 typedef void (callbacks_process_capture_result_t)( 51 const struct camera3_callback_ops *, 52 const camera3_capture_result_t *); 53 54 typedef void (callbacks_notify_t)( 55 const struct camera3_callback_ops *, 56 const camera3_notify_msg_t *); 57} 58 59namespace android { 60 61namespace camera3 { 62 63class Camera3Stream; 64class Camera3ZslStream; 65class Camera3OutputStreamInterface; 66class Camera3StreamInterface; 67 68} // namespace camera3 69 70/** 71 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher. 72 */ 73class Camera3Device : 74 public CameraDeviceBase, 75 virtual public hardware::camera::device::V3_2::ICameraDeviceCallback, 76 private camera3_callback_ops { 77 public: 78 79 explicit Camera3Device(const String8& id); 80 81 virtual ~Camera3Device(); 82 83 /** 84 * CameraDeviceBase interface 85 */ 86 87 const String8& getId() const override; 88 89 // Transitions to idle state on success. 90 status_t initialize(CameraModule *module) override; 91 status_t initialize(sp<CameraProviderManager> manager) override; 92 status_t disconnect() override; 93 status_t dump(int fd, const Vector<String16> &args) override; 94 const CameraMetadata& info() const override; 95 96 // Capture and setStreamingRequest will configure streams if currently in 97 // idle state 98 status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) override; 99 status_t captureList(const List<const CameraMetadata> &requests, 100 const std::list<const SurfaceMap> &surfaceMaps, 101 int64_t *lastFrameNumber = NULL) override; 102 status_t setStreamingRequest(const CameraMetadata &request, 103 int64_t *lastFrameNumber = NULL) override; 104 status_t setStreamingRequestList(const List<const CameraMetadata> &requests, 105 const std::list<const SurfaceMap> &surfaceMaps, 106 int64_t *lastFrameNumber = NULL) override; 107 status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) override; 108 109 status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) override; 110 111 // Actual stream creation/deletion is delayed until first request is submitted 112 // If adding streams while actively capturing, will pause device before adding 113 // stream, reconfiguring device, and unpausing. If the client create a stream 114 // with nullptr consumer surface, the client must then call setConsumers() 115 // and finish the stream configuration before starting output streaming. 116 status_t createStream(sp<Surface> consumer, 117 uint32_t width, uint32_t height, int format, 118 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id, 119 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID, 120 bool isShared = false, uint32_t consumerUsage = 0) override; 121 status_t createStream(const std::vector<sp<Surface>>& consumers, 122 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, 123 android_dataspace dataSpace, camera3_stream_rotation_t rotation, int *id, 124 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID, 125 bool isShared = false, uint32_t consumerUsage = 0) override; 126 127 status_t createInputStream( 128 uint32_t width, uint32_t height, int format, 129 int *id) override; 130 131 status_t getStreamInfo(int id, 132 uint32_t *width, uint32_t *height, 133 uint32_t *format, android_dataspace *dataSpace) override; 134 status_t setStreamTransform(int id, int transform) override; 135 136 status_t deleteStream(int id) override; 137 138 status_t configureStreams(int operatingMode = 139 static_cast<int>(hardware::camera::device::V3_2::StreamConfigurationMode::NORMAL_MODE)) 140 override; 141 status_t getInputBufferProducer( 142 sp<IGraphicBufferProducer> *producer) override; 143 144 status_t createDefaultRequest(int templateId, CameraMetadata *request) override; 145 146 // Transitions to the idle state on success 147 status_t waitUntilDrained() override; 148 149 status_t setNotifyCallback(wp<NotificationListener> listener) override; 150 bool willNotify3A() override; 151 status_t waitForNextFrame(nsecs_t timeout) override; 152 status_t getNextResult(CaptureResult *frame) override; 153 154 status_t triggerAutofocus(uint32_t id) override; 155 status_t triggerCancelAutofocus(uint32_t id) override; 156 status_t triggerPrecaptureMetering(uint32_t id) override; 157 158 status_t flush(int64_t *lastFrameNumber = NULL) override; 159 160 status_t prepare(int streamId) override; 161 162 status_t tearDown(int streamId) override; 163 164 status_t addBufferListenerForStream(int streamId, 165 wp<camera3::Camera3StreamBufferListener> listener) override; 166 167 status_t prepare(int maxCount, int streamId) override; 168 169 uint32_t getDeviceVersion() override; 170 171 ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const override; 172 ssize_t getPointCloudBufferSize() const; 173 ssize_t getRawOpaqueBufferSize(int32_t width, int32_t height) const; 174 175 // Methods called by subclasses 176 void notifyStatus(bool idle); // updates from StatusTracker 177 178 /** 179 * Set the deferred consumer surfaces to the output stream and finish the deferred 180 * consumer configuration. 181 */ 182 status_t setConsumerSurfaces(int streamId, const std::vector<sp<Surface>>& consumers) override; 183 184 private: 185 186 // internal typedefs 187 using RequestMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>; 188 using ResultMetadataQueue = hardware::MessageQueue<uint8_t, hardware::kSynchronizedReadWrite>; 189 190 static const size_t kDumpLockAttempts = 10; 191 static const size_t kDumpSleepDuration = 100000; // 0.10 sec 192 static const nsecs_t kShutdownTimeout = 5000000000; // 5 sec 193 static const nsecs_t kActiveTimeout = 500000000; // 500 ms 194 static const size_t kInFlightWarnLimit = 20; 195 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8 196 // SCHED_FIFO priority for request submission thread in HFR mode 197 static const int kRequestThreadPriority = 1; 198 199 struct RequestTrigger; 200 // minimal jpeg buffer size: 256KB + blob header 201 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera3_jpeg_blob); 202 // Constant to use for stream ID when one doesn't exist 203 static const int NO_STREAM = -1; 204 205 // A lock to enforce serialization on the input/configure side 206 // of the public interface. 207 // Only locked by public methods inherited from CameraDeviceBase. 208 // Not locked by methods guarded by mOutputLock, since they may act 209 // concurrently to the input/configure side of the interface. 210 // Must be locked before mLock if both will be locked by a method 211 Mutex mInterfaceLock; 212 213 // The main lock on internal state 214 Mutex mLock; 215 216 // Camera device ID 217 const String8 mId; 218 219 // Current stream configuration mode; 220 int mOperatingMode; 221 // Constant to use for no set operating mode 222 static const int NO_MODE = -1; 223 224 // Flag indicating is the current active stream configuration is constrained high speed. 225 bool mIsConstrainedHighSpeedConfiguration; 226 227 // FMQ to write result on. Must be guarded by mProcessCaptureResultLock. 228 std::unique_ptr<ResultMetadataQueue> mResultMetadataQueue; 229 230 /**** Scope for mLock ****/ 231 232 /** 233 * Adapter for legacy HAL / HIDL HAL interface calls; calls either into legacy HALv3 or the 234 * HIDL HALv3 interfaces. 235 */ 236 class HalInterface : public camera3::Camera3StreamBufferFreedListener { 237 public: 238 HalInterface(camera3_device_t *device); 239 HalInterface(sp<hardware::camera::device::V3_2::ICameraDeviceSession> &session, 240 std::shared_ptr<RequestMetadataQueue> queue); 241 HalInterface(const HalInterface &other); 242 HalInterface(); 243 244 // Returns true if constructed with a valid device or session, and not yet cleared 245 bool valid(); 246 247 // Reset this HalInterface object (does not call close()) 248 void clear(); 249 250 // Check if HalInterface support sending requests in batch 251 bool supportBatchRequest(); 252 253 // Calls into the HAL interface 254 255 // Caller takes ownership of requestTemplate 256 status_t constructDefaultRequestSettings(camera3_request_template_t templateId, 257 /*out*/ camera_metadata_t **requestTemplate); 258 status_t configureStreams(/*inout*/ camera3_stream_configuration *config); 259 status_t processCaptureRequest(camera3_capture_request_t *request); 260 status_t processBatchCaptureRequests( 261 std::vector<camera3_capture_request_t*>& requests, 262 /*out*/uint32_t* numRequestProcessed); 263 status_t flush(); 264 status_t dump(int fd); 265 status_t close(); 266 267 // Find a buffer_handle_t based on frame number and stream ID 268 status_t popInflightBuffer(int32_t frameNumber, int32_t streamId, 269 /*out*/ buffer_handle_t **buffer); 270 271 private: 272 camera3_device_t *mHal3Device; 273 sp<hardware::camera::device::V3_2::ICameraDeviceSession> mHidlSession; 274 std::shared_ptr<RequestMetadataQueue> mRequestMetadataQueue; 275 276 std::mutex mInflightLock; 277 278 // The output HIDL request still depends on input camera3_capture_request_t 279 // Do not free input camera3_capture_request_t before output HIDL request 280 void wrapAsHidlRequest(camera3_capture_request_t* in, 281 /*out*/hardware::camera::device::V3_2::CaptureRequest* out, 282 /*out*/std::vector<native_handle_t*>* handlesCreated); 283 284 status_t pushInflightBufferLocked(int32_t frameNumber, int32_t streamId, 285 buffer_handle_t *buffer, int acquireFence); 286 // Cache of buffer handles keyed off (frameNumber << 32 | streamId) 287 // value is a pair of (buffer_handle_t*, acquire_fence FD) 288 std::unordered_map<uint64_t, std::pair<buffer_handle_t*, int>> mInflightBufferMap; 289 290 struct BufferHasher { 291 size_t operator()(const buffer_handle_t& buf) const { 292 if (buf == nullptr) 293 return 0; 294 295 size_t result = 1; 296 result = 31 * result + buf->numFds; 297 result = 31 * result + buf->numInts; 298 int length = buf->numFds + buf->numInts; 299 for (int i = 0; i < length; i++) { 300 result = 31 * result + buf->data[i]; 301 } 302 return result; 303 } 304 }; 305 306 struct BufferComparator { 307 bool operator()(const buffer_handle_t& buf1, const buffer_handle_t& buf2) const { 308 if (buf1->numFds == buf2->numFds && buf1->numInts == buf2->numInts) { 309 int length = buf1->numFds + buf1->numInts; 310 for (int i = 0; i < length; i++) { 311 if (buf1->data[i] != buf2->data[i]) { 312 return false; 313 } 314 } 315 return true; 316 } 317 return false; 318 } 319 }; 320 321 std::mutex mBufferIdMapLock; // protecting mBufferIdMaps and mNextBufferId 322 typedef std::unordered_map<const buffer_handle_t, uint64_t, 323 BufferHasher, BufferComparator> BufferIdMap; 324 // stream ID -> per stream buffer ID map 325 std::unordered_map<int, BufferIdMap> mBufferIdMaps; 326 uint64_t mNextBufferId = 1; // 0 means no buffer 327 static const uint64_t BUFFER_ID_NO_BUFFER = 0; 328 329 // method to extract buffer's unique ID 330 // TODO: we should switch to use gralloc mapper's getBackingStore API 331 // once we ran in binderized gralloc mode, but before that is ready, 332 // we need to rely on the conventional buffer queue behavior where 333 // buffer_handle_t's FD won't change. 334 // return pair of (newlySeenBuffer?, bufferId) 335 std::pair<bool, uint64_t> getBufferId(const buffer_handle_t& buf, int streamId); 336 337 virtual void onBufferFreed(int streamId, const native_handle_t* handle) override; 338 339 std::vector<std::pair<int, uint64_t>> mFreedBuffers; 340 }; 341 342 std::unique_ptr<HalInterface> mInterface; 343 344 CameraMetadata mDeviceInfo; 345 346 CameraMetadata mRequestTemplateCache[CAMERA3_TEMPLATE_COUNT]; 347 348 uint32_t mDeviceVersion; 349 350 // whether Camera3Device should derive ANDROID_CONTROL_POST_RAW_SENSITIVITY_BOOST for 351 // backward compatibility. Should not be changed after initialization. 352 bool mDerivePostRawSensKey = false; 353 354 struct Size { 355 uint32_t width; 356 uint32_t height; 357 explicit Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){} 358 }; 359 // Map from format to size. 360 Vector<Size> mSupportedOpaqueInputSizes; 361 362 enum Status { 363 STATUS_ERROR, 364 STATUS_UNINITIALIZED, 365 STATUS_UNCONFIGURED, 366 STATUS_CONFIGURED, 367 STATUS_ACTIVE 368 } mStatus; 369 370 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock 371 Vector<Status> mRecentStatusUpdates; 372 int mStatusWaiters; 373 374 Condition mStatusChanged; 375 376 // Tracking cause of fatal errors when in STATUS_ERROR 377 String8 mErrorCause; 378 379 // Mapping of stream IDs to stream instances 380 typedef KeyedVector<int, sp<camera3::Camera3OutputStreamInterface> > 381 StreamSet; 382 383 StreamSet mOutputStreams; 384 sp<camera3::Camera3Stream> mInputStream; 385 int mNextStreamId; 386 bool mNeedConfig; 387 388 int mDummyStreamId; 389 390 // Whether to send state updates upstream 391 // Pause when doing transparent reconfiguration 392 bool mPauseStateNotify; 393 394 // Need to hold on to stream references until configure completes. 395 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams; 396 397 // Whether the HAL will send partial result 398 bool mUsePartialResult; 399 400 // Number of partial results that will be delivered by the HAL. 401 uint32_t mNumPartialResults; 402 403 /**** End scope for mLock ****/ 404 405 // The offset converting from clock domain of other subsystem 406 // (video/hardware composer) to that of camera. Assumption is that this 407 // offset won't change during the life cycle of the camera device. In other 408 // words, camera device shouldn't be open during CPU suspend. 409 nsecs_t mTimestampOffset; 410 411 typedef struct AeTriggerCancelOverride { 412 bool applyAeLock; 413 uint8_t aeLock; 414 bool applyAePrecaptureTrigger; 415 uint8_t aePrecaptureTrigger; 416 } AeTriggerCancelOverride_t; 417 418 class CaptureRequest : public LightRefBase<CaptureRequest> { 419 public: 420 CameraMetadata mSettings; 421 sp<camera3::Camera3Stream> mInputStream; 422 camera3_stream_buffer_t mInputBuffer; 423 Vector<sp<camera3::Camera3OutputStreamInterface> > 424 mOutputStreams; 425 SurfaceMap mOutputSurfaces; 426 CaptureResultExtras mResultExtras; 427 // Used to cancel AE precapture trigger for devices doesn't support 428 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL 429 AeTriggerCancelOverride_t mAeTriggerCancelOverride; 430 // The number of requests that should be submitted to HAL at a time. 431 // For example, if batch size is 8, this request and the following 7 432 // requests will be submitted to HAL at a time. The batch size for 433 // the following 7 requests will be ignored by the request thread. 434 int mBatchSize; 435 // Whether this request is from a repeating or repeating burst. 436 bool mRepeating; 437 }; 438 typedef List<sp<CaptureRequest> > RequestList; 439 440 status_t checkStatusOkToCaptureLocked(); 441 442 status_t convertMetadataListToRequestListLocked( 443 const List<const CameraMetadata> &metadataList, 444 const std::list<const SurfaceMap> &surfaceMaps, 445 bool repeating, 446 /*out*/ 447 RequestList *requestList); 448 449 void convertToRequestList(List<const CameraMetadata>& requests, 450 std::list<const SurfaceMap>& surfaceMaps, 451 const CameraMetadata& request); 452 453 status_t submitRequestsHelper(const List<const CameraMetadata> &requests, 454 const std::list<const SurfaceMap> &surfaceMaps, 455 bool repeating, 456 int64_t *lastFrameNumber = NULL); 457 458 459 /** 460 * Implementation of android::hardware::camera::device::V3_2::ICameraDeviceCallback 461 */ 462 463 hardware::Return<void> processCaptureResult( 464 const hardware::hidl_vec< 465 hardware::camera::device::V3_2::CaptureResult>& results) override; 466 hardware::Return<void> notify( 467 const hardware::hidl_vec< 468 hardware::camera::device::V3_2::NotifyMsg>& msgs) override; 469 470 // Handle one capture result. Assume that mProcessCaptureResultLock is held. 471 void processOneCaptureResultLocked( 472 const hardware::camera::device::V3_2::CaptureResult& results); 473 // Handle one notify message 474 void notify(const hardware::camera::device::V3_2::NotifyMsg& msg); 475 476 // lock to ensure only one processCaptureResult is called at a time. 477 Mutex mProcessCaptureResultLock; 478 479 /** 480 * Common initialization code shared by both HAL paths 481 * 482 * Must be called with mLock and mInterfaceLock held. 483 */ 484 status_t initializeCommonLocked(); 485 486 /** 487 * Get the last request submitted to the hal by the request thread. 488 * 489 * Must be called with mLock held. 490 */ 491 virtual CameraMetadata getLatestRequestLocked(); 492 493 /** 494 * Update the current device status and wake all waiting threads. 495 * 496 * Must be called with mLock held. 497 */ 498 void internalUpdateStatusLocked(Status status); 499 500 /** 501 * Pause processing and flush everything, but don't tell the clients. 502 * This is for reconfiguring outputs transparently when according to the 503 * CameraDeviceBase interface we shouldn't need to. 504 * Must be called with mLock and mInterfaceLock both held. 505 */ 506 status_t internalPauseAndWaitLocked(); 507 508 /** 509 * Resume work after internalPauseAndWaitLocked() 510 * Must be called with mLock and mInterfaceLock both held. 511 */ 512 status_t internalResumeLocked(); 513 514 /** 515 * Wait until status tracker tells us we've transitioned to the target state 516 * set, which is either ACTIVE when active==true or IDLE (which is any 517 * non-ACTIVE state) when active==false. 518 * 519 * Needs to be called with mLock and mInterfaceLock held. This means there 520 * can ever only be one waiter at most. 521 * 522 * During the wait mLock is released. 523 * 524 */ 525 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout); 526 527 /** 528 * Implementation of waitUntilDrained. On success, will transition to IDLE state. 529 * 530 * Need to be called with mLock and mInterfaceLock held. 531 */ 532 status_t waitUntilDrainedLocked(); 533 534 /** 535 * Do common work for setting up a streaming or single capture request. 536 * On success, will transition to ACTIVE if in IDLE. 537 */ 538 sp<CaptureRequest> setUpRequestLocked(const CameraMetadata &request, 539 const SurfaceMap &surfaceMap); 540 541 /** 542 * Build a CaptureRequest request from the CameraDeviceBase request 543 * settings. 544 */ 545 sp<CaptureRequest> createCaptureRequest(const CameraMetadata &request, 546 const SurfaceMap &surfaceMap); 547 548 /** 549 * Take the currently-defined set of streams and configure the HAL to use 550 * them. This is a long-running operation (may be several hundered ms). 551 */ 552 status_t configureStreamsLocked(int operatingMode); 553 554 /** 555 * Cancel stream configuration that did not finish successfully. 556 */ 557 void cancelStreamsConfigurationLocked(); 558 559 /** 560 * Add a dummy stream to the current stream set as a workaround for 561 * not allowing 0 streams in the camera HAL spec. 562 */ 563 status_t addDummyStreamLocked(); 564 565 /** 566 * Remove a dummy stream if the current config includes real streams. 567 */ 568 status_t tryRemoveDummyStreamLocked(); 569 570 /** 571 * Set device into an error state due to some fatal failure, and set an 572 * error message to indicate why. Only the first call's message will be 573 * used. The message is also sent to the log. 574 */ 575 void setErrorState(const char *fmt, ...); 576 void setErrorStateV(const char *fmt, va_list args); 577 void setErrorStateLocked(const char *fmt, ...); 578 void setErrorStateLockedV(const char *fmt, va_list args); 579 580 /** 581 * Debugging trylock/spin method 582 * Try to acquire a lock a few times with sleeps between before giving up. 583 */ 584 bool tryLockSpinRightRound(Mutex& lock); 585 586 /** 587 * Helper function to determine if an input size for implementation defined 588 * format is supported. 589 */ 590 bool isOpaqueInputSizeSupported(uint32_t width, uint32_t height); 591 592 /** 593 * Helper function to get the largest Jpeg resolution (in area) 594 * Return Size(0, 0) if static metatdata is invalid 595 */ 596 Size getMaxJpegResolution() const; 597 598 /** 599 * Helper function to get the offset between MONOTONIC and BOOTTIME 600 * timestamp. 601 */ 602 static nsecs_t getMonoToBoottimeOffset(); 603 604 /** 605 * Helper function to map between legacy and new dataspace enums 606 */ 607 static android_dataspace mapToLegacyDataspace(android_dataspace dataSpace); 608 609 /** 610 * Helper functions to map between framework and HIDL values 611 */ 612 static hardware::graphics::common::V1_0::PixelFormat mapToPixelFormat(int frameworkFormat); 613 static hardware::camera::device::V3_2::DataspaceFlags mapToHidlDataspace( 614 android_dataspace dataSpace); 615 static hardware::camera::device::V3_2::BufferUsageFlags mapToConsumerUsage(uint32_t usage); 616 static hardware::camera::device::V3_2::StreamRotation mapToStreamRotation( 617 camera3_stream_rotation_t rotation); 618 // Returns a negative error code if the passed-in operation mode is not valid. 619 static status_t mapToStreamConfigurationMode(camera3_stream_configuration_mode_t operationMode, 620 /*out*/ hardware::camera::device::V3_2::StreamConfigurationMode *mode); 621 static camera3_buffer_status_t mapHidlBufferStatus(hardware::camera::device::V3_2::BufferStatus status); 622 static int mapToFrameworkFormat(hardware::graphics::common::V1_0::PixelFormat pixelFormat); 623 static uint32_t mapConsumerToFrameworkUsage( 624 hardware::camera::device::V3_2::BufferUsageFlags usage); 625 static uint32_t mapProducerToFrameworkUsage( 626 hardware::camera::device::V3_2::BufferUsageFlags usage); 627 628 struct RequestTrigger { 629 // Metadata tag number, e.g. android.control.aePrecaptureTrigger 630 uint32_t metadataTag; 631 // Metadata value, e.g. 'START' or the trigger ID 632 int32_t entryValue; 633 634 // The last part of the fully qualified path, e.g. afTrigger 635 const char *getTagName() const { 636 return get_camera_metadata_tag_name(metadataTag) ?: "NULL"; 637 } 638 639 // e.g. TYPE_BYTE, TYPE_INT32, etc. 640 int getTagType() const { 641 return get_camera_metadata_tag_type(metadataTag); 642 } 643 }; 644 645 /** 646 * Thread for managing capture request submission to HAL device. 647 */ 648 class RequestThread : public Thread { 649 650 public: 651 652 RequestThread(wp<Camera3Device> parent, 653 sp<camera3::StatusTracker> statusTracker, 654 HalInterface* interface, 655 uint32_t deviceVersion, 656 bool aeLockAvailable); 657 ~RequestThread(); 658 659 void setNotificationListener(wp<NotificationListener> listener); 660 661 /** 662 * Call after stream (re)-configuration is completed. 663 */ 664 void configurationComplete(bool isConstrainedHighSpeed); 665 666 /** 667 * Set or clear the list of repeating requests. Does not block 668 * on either. Use waitUntilPaused to wait until request queue 669 * has emptied out. 670 */ 671 status_t setRepeatingRequests(const RequestList& requests, 672 /*out*/ 673 int64_t *lastFrameNumber = NULL); 674 status_t clearRepeatingRequests(/*out*/ 675 int64_t *lastFrameNumber = NULL); 676 677 status_t queueRequestList(List<sp<CaptureRequest> > &requests, 678 /*out*/ 679 int64_t *lastFrameNumber = NULL); 680 681 /** 682 * Remove all queued and repeating requests, and pending triggers 683 */ 684 status_t clear(/*out*/int64_t *lastFrameNumber = NULL); 685 686 /** 687 * Flush all pending requests in HAL. 688 */ 689 status_t flush(); 690 691 /** 692 * Queue a trigger to be dispatched with the next outgoing 693 * process_capture_request. The settings for that request only 694 * will be temporarily rewritten to add the trigger tag/value. 695 * Subsequent requests will not be rewritten (for this tag). 696 */ 697 status_t queueTrigger(RequestTrigger trigger[], size_t count); 698 699 /** 700 * Pause/unpause the capture thread. Doesn't block, so use 701 * waitUntilPaused to wait until the thread is paused. 702 */ 703 void setPaused(bool paused); 704 705 /** 706 * Wait until thread processes the capture request with settings' 707 * android.request.id == requestId. 708 * 709 * Returns TIMED_OUT in case the thread does not process the request 710 * within the timeout. 711 */ 712 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout); 713 714 /** 715 * Shut down the thread. Shutdown is asynchronous, so thread may 716 * still be running once this method returns. 717 */ 718 virtual void requestExit(); 719 720 /** 721 * Get the latest request that was sent to the HAL 722 * with process_capture_request. 723 */ 724 CameraMetadata getLatestRequest() const; 725 726 /** 727 * Returns true if the stream is a target of any queued or repeating 728 * capture request 729 */ 730 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream); 731 732 protected: 733 734 virtual bool threadLoop(); 735 736 private: 737 static const String8& getId(const wp<Camera3Device> &device); 738 739 status_t queueTriggerLocked(RequestTrigger trigger); 740 // Mix-in queued triggers into this request 741 int32_t insertTriggers(const sp<CaptureRequest> &request); 742 // Purge the queued triggers from this request, 743 // restoring the old field values for those tags. 744 status_t removeTriggers(const sp<CaptureRequest> &request); 745 746 // HAL workaround: Make sure a trigger ID always exists if 747 // a trigger does 748 status_t addDummyTriggerIds(const sp<CaptureRequest> &request); 749 750 static const nsecs_t kRequestTimeout = 50e6; // 50 ms 751 752 // Used to prepare a batch of requests. 753 struct NextRequest { 754 sp<CaptureRequest> captureRequest; 755 camera3_capture_request_t halRequest; 756 Vector<camera3_stream_buffer_t> outputBuffers; 757 bool submitted; 758 }; 759 760 // Wait for the next batch of requests and put them in mNextRequests. mNextRequests will 761 // be empty if it times out. 762 void waitForNextRequestBatch(); 763 764 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold. 765 sp<CaptureRequest> waitForNextRequestLocked(); 766 767 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any 768 // output buffer timed out. If an error is returned, the caller should clean up the pending 769 // request batch. 770 status_t prepareHalRequests(); 771 772 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and 773 // send request errors if sendRequestError is true. The buffers will be returned in the 774 // ERROR state to mark them as not having valid data. mNextRequests will be cleared. 775 void cleanUpFailedRequests(bool sendRequestError); 776 777 // Stop the repeating request if any of its output streams is abandoned. 778 void checkAndStopRepeatingRequest(); 779 780 // Pause handling 781 bool waitIfPaused(); 782 void unpauseForNewRequests(); 783 784 // Relay error to parent device object setErrorState 785 void setErrorState(const char *fmt, ...); 786 787 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold 788 bool isRepeatingRequestLocked(const sp<CaptureRequest>&); 789 790 // Handle AE precapture trigger cancel for devices <= CAMERA_DEVICE_API_VERSION_3_2. 791 void handleAePrecaptureCancelRequest(const sp<CaptureRequest>& request); 792 793 // Clear repeating requests. Must be called with mRequestLock held. 794 status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL); 795 796 // send request in mNextRequests to HAL one by one. Return true = sucssess 797 bool sendRequestsOneByOne(); 798 799 // send request in mNextRequests to HAL in a batch. Return true = sucssess 800 bool sendRequestsBatch(); 801 802 wp<Camera3Device> mParent; 803 wp<camera3::StatusTracker> mStatusTracker; 804 HalInterface* mInterface; 805 uint32_t mDeviceVersion; 806 807 wp<NotificationListener> mListener; 808 809 const String8& mId; // The camera ID 810 int mStatusId; // The RequestThread's component ID for 811 // status tracking 812 813 Mutex mRequestLock; 814 Condition mRequestSignal; 815 RequestList mRequestQueue; 816 RequestList mRepeatingRequests; 817 // The next batch of requests being prepped for submission to the HAL, no longer 818 // on the request queue. Read-only even with mRequestLock held, outside 819 // of threadLoop 820 Vector<NextRequest> mNextRequests; 821 822 // To protect flush() and sending a request batch to HAL. 823 Mutex mFlushLock; 824 825 bool mReconfigured; 826 827 // Used by waitIfPaused, waitForNextRequest, and waitUntilPaused 828 Mutex mPauseLock; 829 bool mDoPause; 830 Condition mDoPauseSignal; 831 bool mPaused; 832 Condition mPausedSignal; 833 834 sp<CaptureRequest> mPrevRequest; 835 int32_t mPrevTriggers; 836 837 uint32_t mFrameNumber; 838 839 mutable Mutex mLatestRequestMutex; 840 Condition mLatestRequestSignal; 841 // android.request.id for latest process_capture_request 842 int32_t mLatestRequestId; 843 CameraMetadata mLatestRequest; 844 845 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap; 846 Mutex mTriggerMutex; 847 TriggerMap mTriggerMap; 848 TriggerMap mTriggerRemovedMap; 849 TriggerMap mTriggerReplacedMap; 850 uint32_t mCurrentAfTriggerId; 851 uint32_t mCurrentPreCaptureTriggerId; 852 853 int64_t mRepeatingLastFrameNumber; 854 855 // Whether the device supports AE lock 856 bool mAeLockAvailable; 857 858 // Flag indicating if we should prepare video stream for video requests. 859 bool mPrepareVideoStream; 860 }; 861 sp<RequestThread> mRequestThread; 862 863 /** 864 * In-flight queue for tracking completion of capture requests. 865 */ 866 867 struct InFlightRequest { 868 // Set by notify() SHUTTER call. 869 nsecs_t shutterTimestamp; 870 // Set by process_capture_result(). 871 nsecs_t sensorTimestamp; 872 int requestStatus; 873 // Set by process_capture_result call with valid metadata 874 bool haveResultMetadata; 875 // Decremented by calls to process_capture_result with valid output 876 // and input buffers 877 int numBuffersLeft; 878 CaptureResultExtras resultExtras; 879 // If this request has any input buffer 880 bool hasInputBuffer; 881 882 // The last metadata that framework receives from HAL and 883 // not yet send out because the shutter event hasn't arrived. 884 // It's added by process_capture_result and sent when framework 885 // receives the shutter event. 886 CameraMetadata pendingMetadata; 887 888 // The metadata of the partial results that framework receives from HAL so far 889 // and has sent out. 890 CameraMetadata collectedPartialResult; 891 892 // Buffers are added by process_capture_result when output buffers 893 // return from HAL but framework has not yet received the shutter 894 // event. They will be returned to the streams when framework receives 895 // the shutter event. 896 Vector<camera3_stream_buffer_t> pendingOutputBuffers; 897 898 // Used to cancel AE precapture trigger for devices doesn't support 899 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL 900 AeTriggerCancelOverride_t aeTriggerCancelOverride; 901 902 // Whether this inflight request's shutter and result callback are to be 903 // called. The policy is that if the request is the last one in the constrained 904 // high speed recording request list, this flag will be true. If the request list 905 // is not for constrained high speed recording, this flag will also be true. 906 bool hasCallback; 907 908 // Default constructor needed by KeyedVector 909 InFlightRequest() : 910 shutterTimestamp(0), 911 sensorTimestamp(0), 912 requestStatus(OK), 913 haveResultMetadata(false), 914 numBuffersLeft(0), 915 hasInputBuffer(false), 916 aeTriggerCancelOverride({false, 0, false, 0}), 917 hasCallback(true) { 918 } 919 920 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput, 921 AeTriggerCancelOverride aeTriggerCancelOverride, bool hasAppCallback) : 922 shutterTimestamp(0), 923 sensorTimestamp(0), 924 requestStatus(OK), 925 haveResultMetadata(false), 926 numBuffersLeft(numBuffers), 927 resultExtras(extras), 928 hasInputBuffer(hasInput), 929 aeTriggerCancelOverride(aeTriggerCancelOverride), 930 hasCallback(hasAppCallback) { 931 } 932 }; 933 934 // Map from frame number to the in-flight request state 935 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap; 936 937 Mutex mInFlightLock; // Protects mInFlightMap 938 InFlightMap mInFlightMap; 939 int mInFlightStatusId; 940 941 status_t registerInFlight(uint32_t frameNumber, 942 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput, 943 const AeTriggerCancelOverride_t &aeTriggerCancelOverride, bool callback); 944 945 /** 946 * Override result metadata for cancelling AE precapture trigger applied in 947 * handleAePrecaptureCancelRequest(). 948 */ 949 void overrideResultForPrecaptureCancel(CameraMetadata* result, 950 const AeTriggerCancelOverride_t &aeTriggerCancelOverride); 951 952 /** 953 * Tracking for idle detection 954 */ 955 sp<camera3::StatusTracker> mStatusTracker; 956 957 /** 958 * Graphic buffer manager for output streams. Each device has a buffer manager, which is used 959 * by the output streams to get and return buffers if these streams are registered to this 960 * buffer manager. 961 */ 962 sp<camera3::Camera3BufferManager> mBufferManager; 963 964 /** 965 * Thread for preparing streams 966 */ 967 class PreparerThread : private Thread, public virtual RefBase { 968 public: 969 PreparerThread(); 970 ~PreparerThread(); 971 972 void setNotificationListener(wp<NotificationListener> listener); 973 974 /** 975 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO 976 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed 977 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX. 978 */ 979 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream); 980 981 /** 982 * Cancel all current and pending stream preparation 983 */ 984 status_t clear(); 985 986 private: 987 Mutex mLock; 988 989 virtual bool threadLoop(); 990 991 // Guarded by mLock 992 993 wp<NotificationListener> mListener; 994 List<sp<camera3::Camera3StreamInterface> > mPendingStreams; 995 bool mActive; 996 bool mCancelNow; 997 998 // Only accessed by threadLoop and the destructor 999 1000 sp<camera3::Camera3StreamInterface> mCurrentStream; 1001 }; 1002 sp<PreparerThread> mPreparerThread; 1003 1004 /** 1005 * Output result queue and current HAL device 3A state 1006 */ 1007 1008 // Lock for output side of device 1009 Mutex mOutputLock; 1010 1011 /**** Scope for mOutputLock ****/ 1012 // the minimal frame number of the next non-reprocess result 1013 uint32_t mNextResultFrameNumber; 1014 // the minimal frame number of the next reprocess result 1015 uint32_t mNextReprocessResultFrameNumber; 1016 // the minimal frame number of the next non-reprocess shutter 1017 uint32_t mNextShutterFrameNumber; 1018 // the minimal frame number of the next reprocess shutter 1019 uint32_t mNextReprocessShutterFrameNumber; 1020 List<CaptureResult> mResultQueue; 1021 Condition mResultSignal; 1022 wp<NotificationListener> mListener; 1023 1024 /**** End scope for mOutputLock ****/ 1025 1026 /** 1027 * Callback functions from HAL device 1028 */ 1029 void processCaptureResult(const camera3_capture_result *result); 1030 1031 void notify(const camera3_notify_msg *msg); 1032 1033 // Specific notify handlers 1034 void notifyError(const camera3_error_msg_t &msg, 1035 sp<NotificationListener> listener); 1036 void notifyShutter(const camera3_shutter_msg_t &msg, 1037 sp<NotificationListener> listener); 1038 1039 // helper function to return the output buffers to the streams. 1040 void returnOutputBuffers(const camera3_stream_buffer_t *outputBuffers, 1041 size_t numBuffers, nsecs_t timestamp); 1042 1043 // Send a partial capture result. 1044 void sendPartialCaptureResult(const camera_metadata_t * partialResult, 1045 const CaptureResultExtras &resultExtras, uint32_t frameNumber, 1046 const AeTriggerCancelOverride_t &aeTriggerCancelOverride); 1047 1048 // Send a total capture result given the pending metadata and result extras, 1049 // partial results, and the frame number to the result queue. 1050 void sendCaptureResult(CameraMetadata &pendingMetadata, 1051 CaptureResultExtras &resultExtras, 1052 CameraMetadata &collectedPartialResult, uint32_t frameNumber, 1053 bool reprocess, const AeTriggerCancelOverride_t &aeTriggerCancelOverride); 1054 1055 // Insert the result to the result queue after updating frame number and overriding AE 1056 // trigger cancel. 1057 // mOutputLock must be held when calling this function. 1058 void insertResultLocked(CaptureResult *result, uint32_t frameNumber, 1059 const AeTriggerCancelOverride_t &aeTriggerCancelOverride); 1060 1061 /**** Scope for mInFlightLock ****/ 1062 1063 // Remove the in-flight map entry of the given index from mInFlightMap. 1064 // It must only be called with mInFlightLock held. 1065 void removeInFlightMapEntryLocked(int idx); 1066 // Remove the in-flight request of the given index from mInFlightMap 1067 // if it's no longer needed. It must only be called with mInFlightLock held. 1068 void removeInFlightRequestIfReadyLocked(int idx); 1069 1070 /**** End scope for mInFlightLock ****/ 1071 1072 // Debug tracker for metadata tag value changes 1073 // - Enabled with the -m <taglist> option to dumpsys, such as 1074 // dumpsys -m android.control.aeState,android.control.aeMode 1075 // - Disabled with -m off 1076 // - dumpsys -m 3a is a shortcut for ae/af/awbMode, State, and Triggers 1077 TagMonitor mTagMonitor; 1078 1079 void monitorMetadata(TagMonitor::eventSource source, int64_t frameNumber, 1080 nsecs_t timestamp, const CameraMetadata& metadata); 1081 1082 metadata_vendor_id_t mVendorTagId; 1083 1084 /** 1085 * Static callback forwarding methods from HAL to instance 1086 */ 1087 static callbacks_process_capture_result_t sProcessCaptureResult; 1088 1089 static callbacks_notify_t sNotify; 1090 1091}; // class Camera3Device 1092 1093}; // namespace android 1094 1095#endif 1096