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