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