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