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