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