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