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