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