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