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