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