Camera3Device.h revision c98bd8d9bf81663b5cd9c79e79d6e7869c1146e6
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(camera_module_t *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. Note that, for JPEG stream, the 97 // buffer size may be overwritten by an more accurate value calculated by Camera3Device. 98 virtual status_t createStream(sp<ANativeWindow> consumer, 99 uint32_t width, uint32_t height, int format, size_t size, 100 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, uint32_t *format); 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 createDefaultRequest(int templateId, CameraMetadata *request); 120 121 // Transitions to the idle state on success 122 virtual status_t waitUntilDrained(); 123 124 virtual status_t setNotifyCallback(NotificationListener *listener); 125 virtual bool willNotify3A(); 126 virtual status_t waitForNextFrame(nsecs_t timeout); 127 virtual status_t getNextResult(CaptureResult *frame); 128 129 virtual status_t triggerAutofocus(uint32_t id); 130 virtual status_t triggerCancelAutofocus(uint32_t id); 131 virtual status_t triggerPrecaptureMetering(uint32_t id); 132 133 virtual status_t pushReprocessBuffer(int reprocessStreamId, 134 buffer_handle_t *buffer, wp<BufferReleasedListener> listener); 135 136 virtual status_t flush(int64_t *lastFrameNumber = NULL); 137 138 // Methods called by subclasses 139 void notifyStatus(bool idle); // updates from StatusTracker 140 141 private: 142 static const size_t kDumpLockAttempts = 10; 143 static const size_t kDumpSleepDuration = 100000; // 0.10 sec 144 static const size_t kInFlightWarnLimit = 20; 145 static const nsecs_t kShutdownTimeout = 5000000000; // 5 sec 146 static const nsecs_t kActiveTimeout = 500000000; // 500 ms 147 struct RequestTrigger; 148 // minimal jpeg buffer size: 256KB + blob header 149 static const ssize_t kMinJpegBufferSize = 256 * 1024 + sizeof(camera3_jpeg_blob); 150 151 // A lock to enforce serialization on the input/configure side 152 // of the public interface. 153 // Only locked by public methods inherited from CameraDeviceBase. 154 // Not locked by methods guarded by mOutputLock, since they may act 155 // concurrently to the input/configure side of the interface. 156 // Must be locked before mLock if both will be locked by a method 157 Mutex mInterfaceLock; 158 159 // The main lock on internal state 160 Mutex mLock; 161 162 // Camera device ID 163 const int mId; 164 165 /**** Scope for mLock ****/ 166 167 camera3_device_t *mHal3Device; 168 169 CameraMetadata mDeviceInfo; 170 171 int mDeviceVersion; 172 173 enum Status { 174 STATUS_ERROR, 175 STATUS_UNINITIALIZED, 176 STATUS_UNCONFIGURED, 177 STATUS_CONFIGURED, 178 STATUS_ACTIVE 179 } mStatus; 180 Vector<Status> mRecentStatusUpdates; 181 Condition mStatusChanged; 182 183 // Tracking cause of fatal errors when in STATUS_ERROR 184 String8 mErrorCause; 185 186 // Mapping of stream IDs to stream instances 187 typedef KeyedVector<int, sp<camera3::Camera3OutputStreamInterface> > 188 StreamSet; 189 190 StreamSet mOutputStreams; 191 sp<camera3::Camera3Stream> mInputStream; 192 int mNextStreamId; 193 bool mNeedConfig; 194 195 // Whether to send state updates upstream 196 // Pause when doing transparent reconfiguration 197 bool mPauseStateNotify; 198 199 // Need to hold on to stream references until configure completes. 200 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams; 201 202 // Whether quirk ANDROID_QUIRKS_USE_PARTIAL_RESULT is enabled 203 bool mUsePartialResultQuirk; 204 205 /**** End scope for mLock ****/ 206 207 class CaptureRequest : public LightRefBase<CaptureRequest> { 208 public: 209 CameraMetadata mSettings; 210 sp<camera3::Camera3Stream> mInputStream; 211 Vector<sp<camera3::Camera3OutputStreamInterface> > 212 mOutputStreams; 213 CaptureResultExtras mResultExtras; 214 }; 215 typedef List<sp<CaptureRequest> > RequestList; 216 217 status_t checkStatusOkToCaptureLocked(); 218 219 status_t convertMetadataListToRequestListLocked( 220 const List<const CameraMetadata> &metadataList, 221 /*out*/ 222 RequestList *requestList); 223 224 status_t submitRequestsHelper(const List<const CameraMetadata> &requests, bool repeating, 225 int64_t *lastFrameNumber = NULL); 226 227 /** 228 * Get the last request submitted to the hal by the request thread. 229 * 230 * Takes mLock. 231 */ 232 virtual CameraMetadata getLatestRequestLocked(); 233 234 /** 235 * Pause processing and flush everything, but don't tell the clients. 236 * This is for reconfiguring outputs transparently when according to the 237 * CameraDeviceBase interface we shouldn't need to. 238 * Must be called with mLock and mInterfaceLock both held. 239 */ 240 status_t internalPauseAndWaitLocked(); 241 242 /** 243 * Resume work after internalPauseAndWaitLocked() 244 * Must be called with mLock and mInterfaceLock both held. 245 */ 246 status_t internalResumeLocked(); 247 248 /** 249 * Wait until status tracker tells us we've transitioned to the target state 250 * set, which is either ACTIVE when active==true or IDLE (which is any 251 * non-ACTIVE state) when active==false. 252 * 253 * Needs to be called with mLock and mInterfaceLock held. This means there 254 * can ever only be one waiter at most. 255 * 256 * During the wait mLock is released. 257 * 258 */ 259 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout); 260 261 /** 262 * Implementation of waitUntilDrained. On success, will transition to IDLE state. 263 * 264 * Need to be called with mLock and mInterfaceLock held. 265 */ 266 status_t waitUntilDrainedLocked(); 267 268 /** 269 * Do common work for setting up a streaming or single capture request. 270 * On success, will transition to ACTIVE if in IDLE. 271 */ 272 sp<CaptureRequest> setUpRequestLocked(const CameraMetadata &request); 273 274 /** 275 * Build a CaptureRequest request from the CameraDeviceBase request 276 * settings. 277 */ 278 sp<CaptureRequest> createCaptureRequest(const CameraMetadata &request); 279 280 /** 281 * Take the currently-defined set of streams and configure the HAL to use 282 * them. This is a long-running operation (may be several hundered ms). 283 */ 284 status_t configureStreamsLocked(); 285 286 /** 287 * Set device into an error state due to some fatal failure, and set an 288 * error message to indicate why. Only the first call's message will be 289 * used. The message is also sent to the log. 290 */ 291 void setErrorState(const char *fmt, ...); 292 void setErrorStateV(const char *fmt, va_list args); 293 void setErrorStateLocked(const char *fmt, ...); 294 void setErrorStateLockedV(const char *fmt, va_list args); 295 296 /** 297 * Debugging trylock/spin method 298 * Try to acquire a lock a few times with sleeps between before giving up. 299 */ 300 bool tryLockSpinRightRound(Mutex& lock); 301 302 struct Size { 303 int width; 304 int height; 305 Size(int w, int h) : width(w), height(h){} 306 }; 307 308 /** 309 * Helper function to get the largest Jpeg resolution (in area) 310 * Return Size(0, 0) if static metatdata is invalid 311 */ 312 Size getMaxJpegResolution() const; 313 314 /** 315 * Get Jpeg buffer size for a given jpeg resolution. 316 * Negative values are error codes. 317 */ 318 ssize_t getJpegBufferSize(uint32_t width, uint32_t height) const; 319 320 struct RequestTrigger { 321 // Metadata tag number, e.g. android.control.aePrecaptureTrigger 322 uint32_t metadataTag; 323 // Metadata value, e.g. 'START' or the trigger ID 324 int32_t entryValue; 325 326 // The last part of the fully qualified path, e.g. afTrigger 327 const char *getTagName() const { 328 return get_camera_metadata_tag_name(metadataTag) ?: "NULL"; 329 } 330 331 // e.g. TYPE_BYTE, TYPE_INT32, etc. 332 int getTagType() const { 333 return get_camera_metadata_tag_type(metadataTag); 334 } 335 }; 336 337 /** 338 * Thread for managing capture request submission to HAL device. 339 */ 340 class RequestThread : public Thread { 341 342 public: 343 344 RequestThread(wp<Camera3Device> parent, 345 sp<camera3::StatusTracker> statusTracker, 346 camera3_device_t *hal3Device); 347 348 /** 349 * Call after stream (re)-configuration is completed. 350 */ 351 void configurationComplete(); 352 353 /** 354 * Set or clear the list of repeating requests. Does not block 355 * on either. Use waitUntilPaused to wait until request queue 356 * has emptied out. 357 */ 358 status_t setRepeatingRequests(const RequestList& requests, 359 /*out*/ 360 int64_t *lastFrameNumber = NULL); 361 status_t clearRepeatingRequests(/*out*/ 362 int64_t *lastFrameNumber = NULL); 363 364 status_t queueRequestList(List<sp<CaptureRequest> > &requests, 365 /*out*/ 366 int64_t *lastFrameNumber = NULL); 367 368 /** 369 * Remove all queued and repeating requests, and pending triggers 370 */ 371 status_t clear(/*out*/ 372 int64_t *lastFrameNumber = NULL); 373 374 /** 375 * Queue a trigger to be dispatched with the next outgoing 376 * process_capture_request. The settings for that request only 377 * will be temporarily rewritten to add the trigger tag/value. 378 * Subsequent requests will not be rewritten (for this tag). 379 */ 380 status_t queueTrigger(RequestTrigger trigger[], size_t count); 381 382 /** 383 * Pause/unpause the capture thread. Doesn't block, so use 384 * waitUntilPaused to wait until the thread is paused. 385 */ 386 void setPaused(bool paused); 387 388 /** 389 * Wait until thread processes the capture request with settings' 390 * android.request.id == requestId. 391 * 392 * Returns TIMED_OUT in case the thread does not process the request 393 * within the timeout. 394 */ 395 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout); 396 397 /** 398 * Shut down the thread. Shutdown is asynchronous, so thread may 399 * still be running once this method returns. 400 */ 401 virtual void requestExit(); 402 403 /** 404 * Get the latest request that was sent to the HAL 405 * with process_capture_request. 406 */ 407 CameraMetadata getLatestRequest() const; 408 409 protected: 410 411 virtual bool threadLoop(); 412 413 private: 414 static int getId(const wp<Camera3Device> &device); 415 416 status_t queueTriggerLocked(RequestTrigger trigger); 417 // Mix-in queued triggers into this request 418 int32_t insertTriggers(const sp<CaptureRequest> &request); 419 // Purge the queued triggers from this request, 420 // restoring the old field values for those tags. 421 status_t removeTriggers(const sp<CaptureRequest> &request); 422 423 // HAL workaround: Make sure a trigger ID always exists if 424 // a trigger does 425 status_t addDummyTriggerIds(const sp<CaptureRequest> &request); 426 427 static const nsecs_t kRequestTimeout = 50e6; // 50 ms 428 429 // Waits for a request, or returns NULL if times out. 430 sp<CaptureRequest> waitForNextRequest(); 431 432 // Return buffers, etc, for a request that couldn't be fully 433 // constructed. The buffers will be returned in the ERROR state 434 // to mark them as not having valid data. 435 // All arguments will be modified. 436 void cleanUpFailedRequest(camera3_capture_request_t &request, 437 sp<CaptureRequest> &nextRequest, 438 Vector<camera3_stream_buffer_t> &outputBuffers); 439 440 // Pause handling 441 bool waitIfPaused(); 442 void unpauseForNewRequests(); 443 444 // Relay error to parent device object setErrorState 445 void setErrorState(const char *fmt, ...); 446 447 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold 448 bool isRepeatingRequestLocked(const sp<CaptureRequest>); 449 450 wp<Camera3Device> mParent; 451 wp<camera3::StatusTracker> mStatusTracker; 452 camera3_device_t *mHal3Device; 453 454 const int mId; // The camera ID 455 int mStatusId; // The RequestThread's component ID for 456 // status tracking 457 458 Mutex mRequestLock; 459 Condition mRequestSignal; 460 RequestList mRequestQueue; 461 RequestList mRepeatingRequests; 462 463 bool mReconfigured; 464 465 // Used by waitIfPaused, waitForNextRequest, and waitUntilPaused 466 Mutex mPauseLock; 467 bool mDoPause; 468 Condition mDoPauseSignal; 469 bool mPaused; 470 Condition mPausedSignal; 471 472 sp<CaptureRequest> mPrevRequest; 473 int32_t mPrevTriggers; 474 475 uint32_t mFrameNumber; 476 477 mutable Mutex mLatestRequestMutex; 478 Condition mLatestRequestSignal; 479 // android.request.id for latest process_capture_request 480 int32_t mLatestRequestId; 481 CameraMetadata mLatestRequest; 482 483 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap; 484 Mutex mTriggerMutex; 485 TriggerMap mTriggerMap; 486 TriggerMap mTriggerRemovedMap; 487 TriggerMap mTriggerReplacedMap; 488 489 int64_t mRepeatingLastFrameNumber; 490 }; 491 sp<RequestThread> mRequestThread; 492 493 /** 494 * In-flight queue for tracking completion of capture requests. 495 */ 496 497 struct InFlightRequest { 498 // Set by notify() SHUTTER call. 499 nsecs_t captureTimestamp; 500 int requestStatus; 501 // Set by process_capture_result call with valid metadata 502 bool haveResultMetadata; 503 // Decremented by calls to process_capture_result with valid output 504 // and input buffers 505 int numBuffersLeft; 506 CaptureResultExtras resultExtras; 507 // If this request has any input buffer 508 bool hasInputBuffer; 509 510 // Fields used by the partial result quirk only 511 struct PartialResultQuirkInFlight { 512 // Set by process_capture_result once 3A has been sent to clients 513 bool haveSent3A; 514 // Result metadata collected so far, when partial results are in use 515 CameraMetadata collectedResult; 516 517 PartialResultQuirkInFlight(): 518 haveSent3A(false) { 519 } 520 } partialResultQuirk; 521 522 // Default constructor needed by KeyedVector 523 InFlightRequest() : 524 captureTimestamp(0), 525 requestStatus(OK), 526 haveResultMetadata(false), 527 numBuffersLeft(0), 528 hasInputBuffer(false){ 529 } 530 531 InFlightRequest(int numBuffers) : 532 captureTimestamp(0), 533 requestStatus(OK), 534 haveResultMetadata(false), 535 numBuffersLeft(numBuffers), 536 hasInputBuffer(false){ 537 } 538 539 InFlightRequest(int numBuffers, CaptureResultExtras extras) : 540 captureTimestamp(0), 541 requestStatus(OK), 542 haveResultMetadata(false), 543 numBuffersLeft(numBuffers), 544 resultExtras(extras), 545 hasInputBuffer(false){ 546 } 547 548 InFlightRequest(int numBuffers, CaptureResultExtras extras, bool hasInput) : 549 captureTimestamp(0), 550 requestStatus(OK), 551 haveResultMetadata(false), 552 numBuffersLeft(numBuffers), 553 resultExtras(extras), 554 hasInputBuffer(hasInput){ 555 } 556}; 557 // Map from frame number to the in-flight request state 558 typedef KeyedVector<uint32_t, InFlightRequest> InFlightMap; 559 560 Mutex mInFlightLock; // Protects mInFlightMap 561 InFlightMap mInFlightMap; 562 563 status_t registerInFlight(uint32_t frameNumber, 564 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput); 565 566 /** 567 * For the partial result quirk, check if all 3A state fields are available 568 * and if so, queue up 3A-only result to the client. Returns true if 3A 569 * is sent. 570 */ 571 bool processPartial3AQuirk(uint32_t frameNumber, 572 const CameraMetadata& partial, const CaptureResultExtras& resultExtras); 573 574 // Helpers for reading and writing 3A metadata into to/from partial results 575 template<typename T> 576 bool get3AResult(const CameraMetadata& result, int32_t tag, 577 T* value, uint32_t frameNumber); 578 579 template<typename T> 580 bool insert3AResult(CameraMetadata &result, int32_t tag, const T* value, 581 uint32_t frameNumber); 582 /** 583 * Tracking for idle detection 584 */ 585 sp<camera3::StatusTracker> mStatusTracker; 586 587 /** 588 * Output result queue and current HAL device 3A state 589 */ 590 591 // Lock for output side of device 592 Mutex mOutputLock; 593 594 /**** Scope for mOutputLock ****/ 595 596 uint32_t mNextResultFrameNumber; 597 uint32_t mNextShutterFrameNumber; 598 List<CaptureResult> mResultQueue; 599 Condition mResultSignal; 600 NotificationListener *mListener; 601 602 /**** End scope for mOutputLock ****/ 603 604 /** 605 * Callback functions from HAL device 606 */ 607 void processCaptureResult(const camera3_capture_result *result); 608 609 void notify(const camera3_notify_msg *msg); 610 611 /** 612 * Static callback forwarding methods from HAL to instance 613 */ 614 static callbacks_process_capture_result_t sProcessCaptureResult; 615 616 static callbacks_notify_t sNotify; 617 618}; // class Camera3Device 619 620}; // namespace android 621 622#endif 623