Camera3Device.h revision 57ea29251d93c9423030de387573142064366a30
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 and put them in mNextRequests. mNextRequests will 523 // be empty if it times out. 524 void waitForNextRequestBatch(); 525 526 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold. 527 sp<CaptureRequest> waitForNextRequestLocked(); 528 529 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any 530 // output buffer timed out. If an error is returned, the caller should clean up the pending 531 // request batch. 532 status_t prepareHalRequests(); 533 534 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and 535 // send request errors if sendRequestError is true. The buffers will be returned in the 536 // ERROR state to mark them as not having valid data. mNextRequests will be cleared. 537 void cleanUpFailedRequests(bool sendRequestError); 538 539 // Pause handling 540 bool waitIfPaused(); 541 void unpauseForNewRequests(); 542 543 // Relay error to parent device object setErrorState 544 void setErrorState(const char *fmt, ...); 545 546 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold 547 bool isRepeatingRequestLocked(const sp<CaptureRequest>); 548 549 // Handle AE precapture trigger cancel for devices <= CAMERA_DEVICE_API_VERSION_3_2. 550 void handleAePrecaptureCancelRequest(sp<CaptureRequest> request); 551 552 wp<Camera3Device> mParent; 553 wp<camera3::StatusTracker> mStatusTracker; 554 camera3_device_t *mHal3Device; 555 556 NotificationListener *mListener; 557 558 const int mId; // The camera ID 559 int mStatusId; // The RequestThread's component ID for 560 // status tracking 561 562 Mutex mRequestLock; 563 Condition mRequestSignal; 564 RequestList mRequestQueue; 565 RequestList mRepeatingRequests; 566 // The next batch of requests being prepped for submission to the HAL, no longer 567 // on the request queue. Read-only even with mRequestLock held, outside 568 // of threadLoop 569 Vector<NextRequest> mNextRequests; 570 571 // To protect flush() and sending a request batch to HAL. 572 Mutex mFlushLock; 573 574 bool mReconfigured; 575 576 // Used by waitIfPaused, waitForNextRequest, and waitUntilPaused 577 Mutex mPauseLock; 578 bool mDoPause; 579 Condition mDoPauseSignal; 580 bool mPaused; 581 Condition mPausedSignal; 582 583 sp<CaptureRequest> mPrevRequest; 584 int32_t mPrevTriggers; 585 586 uint32_t mFrameNumber; 587 588 mutable Mutex mLatestRequestMutex; 589 Condition mLatestRequestSignal; 590 // android.request.id for latest process_capture_request 591 int32_t mLatestRequestId; 592 CameraMetadata mLatestRequest; 593 594 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap; 595 Mutex mTriggerMutex; 596 TriggerMap mTriggerMap; 597 TriggerMap mTriggerRemovedMap; 598 TriggerMap mTriggerReplacedMap; 599 uint32_t mCurrentAfTriggerId; 600 uint32_t mCurrentPreCaptureTriggerId; 601 602 int64_t mRepeatingLastFrameNumber; 603 604 // Whether the device supports AE lock 605 bool mAeLockAvailable; 606 }; 607 sp<RequestThread> mRequestThread; 608 609 /** 610 * In-flight queue for tracking completion of capture requests. 611 */ 612 613 struct InFlightRequest { 614 // Set by notify() SHUTTER call. 615 nsecs_t shutterTimestamp; 616 // Set by process_capture_result(). 617 nsecs_t sensorTimestamp; 618 int requestStatus; 619 // Set by process_capture_result call with valid metadata 620 bool haveResultMetadata; 621 // Decremented by calls to process_capture_result with valid output 622 // and input buffers 623 int numBuffersLeft; 624 CaptureResultExtras resultExtras; 625 // If this request has any input buffer 626 bool hasInputBuffer; 627 628 // The last metadata that framework receives from HAL and 629 // not yet send out because the shutter event hasn't arrived. 630 // It's added by process_capture_result and sent when framework 631 // receives the shutter event. 632 CameraMetadata pendingMetadata; 633 634 // Buffers are added by process_capture_result when output buffers 635 // return from HAL but framework has not yet received the shutter 636 // event. They will be returned to the streams when framework receives 637 // the shutter event. 638 Vector<camera3_stream_buffer_t> pendingOutputBuffers; 639 640 // Used to cancel AE precapture trigger for devices doesn't support 641 // CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL 642 AeTriggerCancelOverride_t aeTriggerCancelOverride; 643 644 645 // Fields used by the partial result only 646 struct PartialResultInFlight { 647 // Set by process_capture_result once 3A has been sent to clients 648 bool haveSent3A; 649 // Result metadata collected so far, when partial results are in use 650 CameraMetadata collectedResult; 651 652 PartialResultInFlight(): 653 haveSent3A(false) { 654 } 655 } partialResult; 656 657 // Default constructor needed by KeyedVector 658 InFlightRequest() : 659 shutterTimestamp(0), 660 sensorTimestamp(0), 661 requestStatus(OK), 662 haveResultMetadata(false), 663 numBuffersLeft(0), 664 hasInputBuffer(false), 665 aeTriggerCancelOverride({false, 0, false, 0}){ 666 } 667 668 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput, 669 AeTriggerCancelOverride aeTriggerCancelOverride) : 670 shutterTimestamp(0), 671 sensorTimestamp(0), 672 requestStatus(OK), 673 haveResultMetadata(false), 674 numBuffersLeft(numBuffers), 675 resultExtras(extras), 676 hasInputBuffer(hasInput), 677 aeTriggerCancelOverride(aeTriggerCancelOverride){ 678 } 679 }; 680 681 // Map from frame number to the in-flight request state 682 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap; 683 684 Mutex mInFlightLock; // Protects mInFlightMap 685 InFlightMap mInFlightMap; 686 687 status_t registerInFlight(uint32_t frameNumber, 688 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput, 689 const AeTriggerCancelOverride_t &aeTriggerCancelOverride); 690 691 /** 692 * For the partial result, check if all 3A state fields are available 693 * and if so, queue up 3A-only result to the client. Returns true if 3A 694 * is sent. 695 */ 696 bool processPartial3AResult(uint32_t frameNumber, 697 const CameraMetadata& partial, const CaptureResultExtras& resultExtras); 698 699 // Helpers for reading and writing 3A metadata into to/from partial results 700 template<typename T> 701 bool get3AResult(const CameraMetadata& result, int32_t tag, 702 T* value, uint32_t frameNumber); 703 704 template<typename T> 705 bool insert3AResult(CameraMetadata &result, int32_t tag, const T* value, 706 uint32_t frameNumber); 707 708 /** 709 * Override result metadata for cancelling AE precapture trigger applied in 710 * handleAePrecaptureCancelRequest(). 711 */ 712 void overrideResultForPrecaptureCancel(CameraMetadata* result, 713 const AeTriggerCancelOverride_t &aeTriggerCancelOverride); 714 715 /** 716 * Tracking for idle detection 717 */ 718 sp<camera3::StatusTracker> mStatusTracker; 719 720 /** 721 * Thread for preparing streams 722 */ 723 class PreparerThread : private Thread, public virtual RefBase { 724 public: 725 PreparerThread(); 726 ~PreparerThread(); 727 728 void setNotificationListener(NotificationListener *listener); 729 730 /** 731 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO 732 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed 733 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX. 734 */ 735 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream); 736 737 /** 738 * Cancel all current and pending stream preparation 739 */ 740 status_t clear(); 741 742 private: 743 Mutex mLock; 744 745 virtual bool threadLoop(); 746 747 // Guarded by mLock 748 749 NotificationListener *mListener; 750 List<sp<camera3::Camera3StreamInterface> > mPendingStreams; 751 bool mActive; 752 bool mCancelNow; 753 754 // Only accessed by threadLoop and the destructor 755 756 sp<camera3::Camera3StreamInterface> mCurrentStream; 757 }; 758 sp<PreparerThread> mPreparerThread; 759 760 /** 761 * Output result queue and current HAL device 3A state 762 */ 763 764 // Lock for output side of device 765 Mutex mOutputLock; 766 767 /**** Scope for mOutputLock ****/ 768 // the minimal frame number of the next non-reprocess result 769 uint32_t mNextResultFrameNumber; 770 // the minimal frame number of the next reprocess result 771 uint32_t mNextReprocessResultFrameNumber; 772 uint32_t mNextShutterFrameNumber; 773 List<CaptureResult> mResultQueue; 774 Condition mResultSignal; 775 NotificationListener *mListener; 776 777 /**** End scope for mOutputLock ****/ 778 779 /** 780 * Callback functions from HAL device 781 */ 782 void processCaptureResult(const camera3_capture_result *result); 783 784 void notify(const camera3_notify_msg *msg); 785 786 // Specific notify handlers 787 void notifyError(const camera3_error_msg_t &msg, 788 NotificationListener *listener); 789 void notifyShutter(const camera3_shutter_msg_t &msg, 790 NotificationListener *listener); 791 792 // helper function to return the output buffers to the streams. 793 void returnOutputBuffers(const camera3_stream_buffer_t *outputBuffers, 794 size_t numBuffers, nsecs_t timestamp); 795 796 // Insert the capture result given the pending metadata, result extras, 797 // partial results, and the frame number to the result queue. 798 void sendCaptureResult(CameraMetadata &pendingMetadata, 799 CaptureResultExtras &resultExtras, 800 CameraMetadata &collectedPartialResult, uint32_t frameNumber, 801 bool reprocess, const AeTriggerCancelOverride_t &aeTriggerCancelOverride); 802 803 /**** Scope for mInFlightLock ****/ 804 805 // Remove the in-flight request of the given index from mInFlightMap 806 // if it's no longer needed. It must only be called with mInFlightLock held. 807 void removeInFlightRequestIfReadyLocked(int idx); 808 809 /**** End scope for mInFlightLock ****/ 810 811 /** 812 * Static callback forwarding methods from HAL to instance 813 */ 814 static callbacks_process_capture_result_t sProcessCaptureResult; 815 816 static callbacks_notify_t sNotify; 817 818}; // class Camera3Device 819 820}; // namespace android 821 822#endif 823