1 /* 2 * Copyright (C) 2013-2018 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 <utility> 21 #include <unordered_map> 22 #include <set> 23 24 #include <utils/Condition.h> 25 #include <utils/Errors.h> 26 #include <utils/List.h> 27 #include <utils/Mutex.h> 28 #include <utils/Thread.h> 29 #include <utils/KeyedVector.h> 30 #include <utils/Timers.h> 31 32 #include <camera/CaptureResult.h> 33 34 #include "CameraServiceWatchdog.h" 35 #include <aidl/android/hardware/camera/device/CameraBlob.h> 36 37 #include "common/CameraDeviceBase.h" 38 #include "device3/BufferUtils.h" 39 #include "device3/StatusTracker.h" 40 #include "device3/Camera3BufferManager.h" 41 #include "device3/DistortionMapper.h" 42 #include "device3/ZoomRatioMapper.h" 43 #include "device3/RotateAndCropMapper.h" 44 #include "device3/UHRCropAndMeteringRegionMapper.h" 45 #include "device3/InFlightRequest.h" 46 #include "device3/Camera3OutputInterface.h" 47 #include "device3/Camera3OfflineSession.h" 48 #include "device3/Camera3StreamInterface.h" 49 #include "utils/TagMonitor.h" 50 #include "utils/IPCTransport.h" 51 #include "utils/LatencyHistogram.h" 52 #include <camera_metadata_hidden.h> 53 54 using android::camera3::camera_capture_request_t; 55 using android::camera3::camera_request_template; 56 using android::camera3::camera_stream_buffer_t; 57 using android::camera3::camera_stream_configuration_t; 58 using android::camera3::camera_stream_configuration_mode_t; 59 using android::camera3::CAMERA_TEMPLATE_COUNT; 60 using android::camera3::OutputStreamInfo; 61 62 namespace android { 63 64 namespace camera3 { 65 66 class Camera3Stream; 67 class Camera3ZslStream; 68 class Camera3StreamInterface; 69 70 } // namespace camera3 71 72 /** 73 * CameraDevice for HAL devices with version CAMERA_DEVICE_API_VERSION_3_0 or higher. 74 */ 75 class Camera3Device : 76 public CameraDeviceBase, 77 public camera3::SetErrorInterface, 78 public camera3::InflightRequestUpdateInterface, 79 public camera3::RequestBufferInterface, 80 public camera3::FlushBufferInterface { 81 friend class HidlCamera3Device; 82 friend class AidlCamera3Device; 83 public: 84 85 explicit Camera3Device(const String8& id, bool overrideForPerfClass, bool overrideToPortrait, 86 bool legacyClient = false); 87 88 virtual ~Camera3Device(); 89 // Delete and optionally close native handles and clear the input vector afterward 90 static void cleanupNativeHandles( 91 std::vector<native_handle_t*> *handles, bool closeFd = false); 92 getTransportType()93 virtual IPCTransport getTransportType() const override { 94 return mInterface->getTransportType(); 95 } 96 97 /** 98 * CameraDeviceBase interface 99 */ 100 101 const String8& getId() const override; 102 getVendorTagId()103 metadata_vendor_id_t getVendorTagId() const override { return mVendorTagId; } 104 105 // Watchdog thread 106 sp<CameraServiceWatchdog> mCameraServiceWatchdog; 107 108 // Transitions to idle state on success. 109 virtual status_t initialize(sp<CameraProviderManager> /*manager*/, 110 const String8& /*monitorTags*/) = 0; 111 112 status_t disconnect() override; 113 status_t dump(int fd, const Vector<String16> &args) override; 114 status_t startWatchingTags(const String8 &tags) override; 115 status_t stopWatchingTags() override; 116 status_t dumpWatchedEventsToVector(std::vector<std::string> &out) override; 117 const CameraMetadata& info() const override; 118 const CameraMetadata& infoPhysical(const String8& physicalId) const override; 119 120 // Capture and setStreamingRequest will configure streams if currently in 121 // idle state 122 status_t capture(CameraMetadata &request, int64_t *lastFrameNumber = NULL) override; 123 status_t captureList(const List<const PhysicalCameraSettingsList> &requestsList, 124 const std::list<const SurfaceMap> &surfaceMaps, 125 int64_t *lastFrameNumber = NULL) override; 126 status_t setStreamingRequest(const CameraMetadata &request, 127 int64_t *lastFrameNumber = NULL) override; 128 status_t setStreamingRequestList(const List<const PhysicalCameraSettingsList> &requestsList, 129 const std::list<const SurfaceMap> &surfaceMaps, 130 int64_t *lastFrameNumber = NULL) override; 131 status_t clearStreamingRequest(int64_t *lastFrameNumber = NULL) override; 132 133 status_t waitUntilRequestReceived(int32_t requestId, nsecs_t timeout) override; 134 135 // Actual stream creation/deletion is delayed until first request is submitted 136 // If adding streams while actively capturing, will pause device before adding 137 // stream, reconfiguring device, and unpausing. If the client create a stream 138 // with nullptr consumer surface, the client must then call setConsumers() 139 // and finish the stream configuration before starting output streaming. 140 status_t createStream(sp<Surface> consumer, 141 uint32_t width, uint32_t height, int format, 142 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id, 143 const String8& physicalCameraId, 144 const std::unordered_set<int32_t> &sensorPixelModesUsed, 145 std::vector<int> *surfaceIds = nullptr, 146 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID, 147 bool isShared = false, bool isMultiResolution = false, 148 uint64_t consumerUsage = 0, 149 int64_t dynamicRangeProfile = 150 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD, 151 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT, 152 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT, 153 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO) override; 154 155 status_t createStream(const std::vector<sp<Surface>>& consumers, 156 bool hasDeferredConsumer, uint32_t width, uint32_t height, int format, 157 android_dataspace dataSpace, camera_stream_rotation_t rotation, int *id, 158 const String8& physicalCameraId, 159 const std::unordered_set<int32_t> &sensorPixelModesUsed, 160 std::vector<int> *surfaceIds = nullptr, 161 int streamSetId = camera3::CAMERA3_STREAM_SET_ID_INVALID, 162 bool isShared = false, bool isMultiResolution = false, 163 uint64_t consumerUsage = 0, 164 int64_t dynamicRangeProfile = 165 ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD, 166 int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT, 167 int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT, 168 int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO) override; 169 170 status_t createInputStream( 171 uint32_t width, uint32_t height, int format, bool isMultiResolution, 172 int *id) override; 173 174 status_t getStreamInfo(int id, StreamInfo *streamInfo) override; 175 status_t setStreamTransform(int id, int transform) override; 176 177 status_t deleteStream(int id) override; 178 179 status_t configureStreams(const CameraMetadata& sessionParams, 180 int operatingMode = 181 camera_stream_configuration_mode_t::CAMERA_STREAM_CONFIGURATION_NORMAL_MODE) override; 182 status_t getInputBufferProducer( 183 sp<IGraphicBufferProducer> *producer) override; 184 185 void getOfflineStreamIds(std::vector<int> *offlineStreamIds) override; 186 187 status_t createDefaultRequest(camera_request_template_t templateId, 188 CameraMetadata *request) override; 189 190 // Transitions to the idle state on success 191 status_t waitUntilDrained() override; 192 193 status_t setNotifyCallback(wp<NotificationListener> listener) override; 194 bool willNotify3A() override; 195 status_t waitForNextFrame(nsecs_t timeout) override; 196 status_t getNextResult(CaptureResult *frame) override; 197 198 status_t triggerAutofocus(uint32_t id) override; 199 status_t triggerCancelAutofocus(uint32_t id) override; 200 status_t triggerPrecaptureMetering(uint32_t id) override; 201 202 status_t flush(int64_t *lastFrameNumber = NULL) override; 203 204 status_t prepare(int streamId) override; 205 206 status_t tearDown(int streamId) override; 207 208 status_t addBufferListenerForStream(int streamId, 209 wp<camera3::Camera3StreamBufferListener> listener) override; 210 211 status_t prepare(int maxCount, int streamId) override; 212 213 ssize_t getJpegBufferSize(const CameraMetadata &info, uint32_t width, 214 uint32_t height) const override; 215 ssize_t getPointCloudBufferSize(const CameraMetadata &info) const; 216 ssize_t getRawOpaqueBufferSize(const CameraMetadata &info, int32_t width, int32_t height, 217 bool maxResolution) const; 218 219 // Methods called by subclasses 220 void notifyStatus(bool idle); // updates from StatusTracker 221 222 /** 223 * Set the deferred consumer surfaces to the output stream and finish the deferred 224 * consumer configuration. 225 */ 226 status_t setConsumerSurfaces( 227 int streamId, const std::vector<sp<Surface>>& consumers, 228 std::vector<int> *surfaceIds /*out*/) override; 229 230 /** 231 * Update a given stream. 232 */ 233 status_t updateStream(int streamId, const std::vector<sp<Surface>> &newSurfaces, 234 const std::vector<OutputStreamInfo> &outputInfo, 235 const std::vector<size_t> &removedSurfaceIds, 236 KeyedVector<sp<Surface>, size_t> *outputMap/*out*/); 237 238 /** 239 * Drop buffers for stream of streamId if dropping is true. If dropping is false, do not 240 * drop buffers for stream of streamId. 241 */ 242 status_t dropStreamBuffers(bool dropping, int streamId) override; 243 244 nsecs_t getExpectedInFlightDuration() override; 245 switchToOffline(const std::vector<int32_t> &,sp<CameraOfflineSessionBase> *)246 virtual status_t switchToOffline(const std::vector<int32_t>& , 247 /*out*/ sp<CameraOfflineSessionBase>* ) override { 248 return INVALID_OPERATION; 249 }; 250 251 // RequestBufferInterface 252 bool startRequestBuffer() override; 253 void endRequestBuffer() override; 254 nsecs_t getWaitDuration() override; 255 256 // FlushBufferInterface 257 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out) override; 258 void getInflightRequestBufferKeys(std::vector<uint64_t>* out) override; 259 std::vector<sp<camera3::Camera3StreamInterface>> getAllStreams() override; 260 261 /** 262 * Set the current behavior for the ROTATE_AND_CROP control when in AUTO. 263 * 264 * The value must be one of the ROTATE_AND_CROP_* values besides AUTO, 265 * and defaults to NONE. 266 */ 267 status_t setRotateAndCropAutoBehavior( 268 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue); 269 270 /** 271 * Whether camera muting (producing black-only output) is supported. 272 * 273 * Calling setCameraMute(true) when this returns false will return an 274 * INVALID_OPERATION error. 275 */ 276 bool supportsCameraMute(); 277 278 /** 279 * Mute the camera. 280 * 281 * When muted, black image data is output on all output streams. 282 */ 283 status_t setCameraMute(bool enabled); 284 285 /** 286 * Enables/disables camera service watchdog 287 */ 288 status_t setCameraServiceWatchdog(bool enabled); 289 290 // Set stream use case overrides 291 void setStreamUseCaseOverrides( 292 const std::vector<int64_t>& useCaseOverrides); 293 294 // Clear stream use case overrides 295 void clearStreamUseCaseOverrides(); 296 297 // Get the status trackeer for the camera device getStatusTracker()298 wp<camera3::StatusTracker> getStatusTracker() { return mStatusTracker; } 299 300 /** 301 * The injection camera session to replace the internal camera 302 * session. 303 */ 304 status_t injectCamera(const String8& injectedCamId, 305 sp<CameraProviderManager> manager); 306 307 /** 308 * Stop the injection camera and restore to internal camera session. 309 */ 310 status_t stopInjection(); 311 312 protected: 313 status_t disconnectImpl(); 314 static status_t removeFwkOnlyRegionKeys(CameraMetadata *request); 315 316 float getMaxPreviewFps(sp<camera3::Camera3OutputStreamInterface> stream); 317 318 static const size_t kDumpLockAttempts = 10; 319 static const size_t kDumpSleepDuration = 100000; // 0.10 sec 320 static const nsecs_t kActiveTimeout = 500000000; // 500 ms 321 static const nsecs_t kMinWarnInflightDuration = 5000000000; // 5 s 322 static const size_t kInFlightWarnLimit = 30; 323 static const size_t kInFlightWarnLimitHighSpeed = 256; // batch size 32 * pipe depth 8 324 static const nsecs_t kMinInflightDuration = 5000000000; // 5 s 325 static const nsecs_t kBaseGetBufferWait = 3000000000; // 3 sec. 326 // SCHED_FIFO priority for request submission thread in HFR mode 327 static const int kRequestThreadPriority = 1; 328 329 struct RequestTrigger; 330 // minimal jpeg buffer size: 256KB + blob header 331 static const ssize_t kMinJpegBufferSize = 332 256 * 1024 + sizeof(aidl::android::hardware::camera::device::CameraBlob); 333 // Constant to use for stream ID when one doesn't exist 334 static const int NO_STREAM = -1; 335 336 // A lock to enforce serialization on the input/configure side 337 // of the public interface. 338 // Not locked by methods guarded by mOutputLock, since they may act 339 // concurrently to the input/configure side of the interface. 340 // Must be locked before mLock if both will be locked by a method 341 Mutex mInterfaceLock; 342 343 // The main lock on internal state 344 Mutex mLock; 345 346 // Camera device ID 347 const String8 mId; 348 349 // Legacy camera client flag 350 bool mLegacyClient; 351 352 // Current stream configuration mode; 353 int mOperatingMode; 354 // Current session wide parameters 355 hardware::camera2::impl::CameraMetadataNative mSessionParams; 356 357 // Constant to use for no set operating mode 358 static const int NO_MODE = -1; 359 360 // Flag indicating is the current active stream configuration is constrained high speed. 361 bool mIsConstrainedHighSpeedConfiguration; 362 363 /**** Scope for mLock ****/ 364 365 class HalInterface : public camera3::Camera3StreamBufferFreedListener, 366 public camera3::BufferRecordsInterface { 367 public: HalInterface(bool useHalBufManager,bool supportOfflineProcessing)368 HalInterface(bool useHalBufManager, bool supportOfflineProcessing) : 369 mUseHalBufManager(useHalBufManager), 370 mIsReconfigurationQuerySupported(true), 371 mSupportOfflineProcessing(supportOfflineProcessing) 372 {}; 373 HalInterface(const HalInterface &other); 374 HalInterface(); 375 376 virtual IPCTransport getTransportType() const = 0; 377 378 // Returns true if constructed with a valid device or session, and not yet cleared 379 virtual bool valid() = 0; 380 381 // Reset this HalInterface object (does not call close()) 382 virtual void clear() = 0; 383 384 // Calls into the HAL interface 385 386 // Caller takes ownership of requestTemplate 387 virtual status_t constructDefaultRequestSettings(camera_request_template templateId, 388 /*out*/ camera_metadata_t **requestTemplate) = 0; 389 390 virtual status_t configureStreams(const camera_metadata_t * sessionParams, 391 /*inout*/ camera_stream_configuration_t * config, 392 const std::vector<uint32_t>& bufferSizes) = 0; 393 394 // The injection camera configures the streams to hal. 395 virtual status_t configureInjectedStreams( 396 const camera_metadata_t* sessionParams, 397 /*inout*/ camera_stream_configuration_t* config, 398 const std::vector<uint32_t>& bufferSizes, 399 const CameraMetadata& cameraCharacteristics) = 0; 400 401 // When the call succeeds, the ownership of acquire fences in requests is transferred to 402 // HalInterface. More specifically, the current implementation will send the fence to 403 // HAL process and close the FD in cameraserver process. When the call fails, the ownership 404 // of the acquire fence still belongs to the caller. 405 virtual status_t processBatchCaptureRequests( 406 std::vector<camera_capture_request_t*>& requests, 407 /*out*/uint32_t* numRequestProcessed) = 0; 408 409 virtual status_t flush() = 0; 410 411 virtual status_t dump(int fd) = 0; 412 413 virtual status_t close() = 0; 414 415 virtual void signalPipelineDrain(const std::vector<int>& streamIds) = 0; 416 417 virtual bool isReconfigurationRequired(CameraMetadata& oldSessionParams, 418 CameraMetadata& newSessionParams) = 0; 419 420 virtual status_t repeatingRequestEnd(uint32_t frameNumber, 421 const std::vector<int32_t> &streamIds) = 0; 422 423 ///////////////////////////////////////////////////////////////////// 424 // Implements BufferRecordsInterface 425 426 std::pair<bool, uint64_t> getBufferId( 427 const buffer_handle_t& buf, int streamId) override; 428 429 uint64_t removeOneBufferCache(int streamId, const native_handle_t* handle) override; 430 431 status_t popInflightBuffer(int32_t frameNumber, int32_t streamId, 432 /*out*/ buffer_handle_t **buffer) override; 433 434 status_t pushInflightRequestBuffer( 435 uint64_t bufferId, buffer_handle_t* buf, int32_t streamId) override; 436 437 status_t popInflightRequestBuffer(uint64_t bufferId, 438 /*out*/ buffer_handle_t** buffer, 439 /*optional out*/ int32_t* streamId = nullptr) override; 440 441 ///////////////////////////////////////////////////////////////////// 442 443 // Get a vector of (frameNumber, streamId) pair of currently inflight 444 // buffers 445 void getInflightBufferKeys(std::vector<std::pair<int32_t, int32_t>>* out); 446 447 // Get a vector of bufferId of currently inflight buffers 448 void getInflightRequestBufferKeys(std::vector<uint64_t>* out); 449 450 void onStreamReConfigured(int streamId); 451 452 protected: 453 454 // Return true if the input caches match what we have; otherwise false 455 bool verifyBufferIds(int32_t streamId, std::vector<uint64_t>& inBufIds); 456 457 template <typename OfflineSessionInfoT> verifyBufferCaches(const OfflineSessionInfoT * offlineSessionInfo,camera3::BufferRecords * bufferRecords)458 status_t verifyBufferCaches( 459 const OfflineSessionInfoT *offlineSessionInfo, camera3::BufferRecords *bufferRecords) { 460 // Validate buffer caches 461 std::vector<int32_t> streams; 462 streams.reserve(offlineSessionInfo->offlineStreams.size()); 463 for (auto offlineStream : offlineSessionInfo->offlineStreams) { 464 int32_t id = offlineStream.id; 465 streams.push_back(id); 466 // Verify buffer caches 467 std::vector<uint64_t> bufIds(offlineStream.circulatingBufferIds.begin(), 468 offlineStream.circulatingBufferIds.end()); 469 if (!verifyBufferIds(id, bufIds)) { 470 ALOGE("%s: stream ID %d buffer cache records mismatch!", __FUNCTION__, id); 471 return UNKNOWN_ERROR; 472 } 473 } 474 475 // Move buffer records 476 bufferRecords->takeBufferCaches(mBufferRecords, streams); 477 bufferRecords->takeInflightBufferMap(mBufferRecords); 478 bufferRecords->takeRequestedBufferMap(mBufferRecords); 479 return OK; 480 } 481 482 virtual void onBufferFreed(int streamId, const native_handle_t* handle) override; 483 484 std::mutex mFreedBuffersLock; 485 std::vector<std::pair<int, uint64_t>> mFreedBuffers; 486 487 // Keep track of buffer cache and inflight buffer records 488 camera3::BufferRecords mBufferRecords; 489 490 uint32_t mNextStreamConfigCounter = 1; 491 492 const bool mUseHalBufManager; 493 bool mIsReconfigurationQuerySupported; 494 495 const bool mSupportOfflineProcessing; 496 }; // class HalInterface 497 498 sp<HalInterface> mInterface; 499 500 CameraMetadata mDeviceInfo; 501 bool mSupportNativeZoomRatio; 502 std::unordered_map<std::string, CameraMetadata> mPhysicalDeviceInfoMap; 503 504 CameraMetadata mRequestTemplateCache[CAMERA_TEMPLATE_COUNT]; 505 506 struct Size { 507 uint32_t width; 508 uint32_t height; widthSize509 explicit Size(uint32_t w = 0, uint32_t h = 0) : width(w), height(h){} 510 }; 511 512 enum Status { 513 STATUS_ERROR, 514 STATUS_UNINITIALIZED, 515 STATUS_UNCONFIGURED, 516 STATUS_CONFIGURED, 517 STATUS_ACTIVE 518 } mStatus; 519 520 // Only clear mRecentStatusUpdates, mStatusWaiters from waitUntilStateThenRelock 521 Vector<Status> mRecentStatusUpdates; 522 int mStatusWaiters; 523 524 Condition mStatusChanged; 525 526 // Tracking cause of fatal errors when in STATUS_ERROR 527 String8 mErrorCause; 528 529 camera3::StreamSet mOutputStreams; 530 sp<camera3::Camera3Stream> mInputStream; 531 bool mIsInputStreamMultiResolution; 532 SessionStatsBuilder mSessionStatsBuilder; 533 // Map from stream group ID to physical cameras backing the stream group 534 std::map<int32_t, std::set<String8>> mGroupIdPhysicalCameraMap; 535 536 int mNextStreamId; 537 bool mNeedConfig; 538 539 int mFakeStreamId; 540 541 // Whether to send state updates upstream 542 // Pause when doing transparent reconfiguration 543 bool mPauseStateNotify; 544 545 // Need to hold on to stream references until configure completes. 546 Vector<sp<camera3::Camera3StreamInterface> > mDeletedStreams; 547 548 // Whether the HAL will send partial result 549 bool mUsePartialResult; 550 551 // Number of partial results that will be delivered by the HAL. 552 uint32_t mNumPartialResults; 553 554 /**** End scope for mLock ****/ 555 556 bool mDeviceTimeBaseIsRealtime; 557 // The offset converting from clock domain of other subsystem 558 // (video/hardware composer) to that of camera. Assumption is that this 559 // offset won't change during the life cycle of the camera device. In other 560 // words, camera device shouldn't be open during CPU suspend. 561 nsecs_t mTimestampOffset; 562 563 class CaptureRequest : public LightRefBase<CaptureRequest> { 564 public: 565 PhysicalCameraSettingsList mSettingsList; 566 sp<camera3::Camera3Stream> mInputStream; 567 camera_stream_buffer_t mInputBuffer; 568 camera3::Size mInputBufferSize; 569 Vector<sp<camera3::Camera3OutputStreamInterface> > 570 mOutputStreams; 571 SurfaceMap mOutputSurfaces; 572 CaptureResultExtras mResultExtras; 573 // The number of requests that should be submitted to HAL at a time. 574 // For example, if batch size is 8, this request and the following 7 575 // requests will be submitted to HAL at a time. The batch size for 576 // the following 7 requests will be ignored by the request thread. 577 int mBatchSize; 578 // Whether this request is from a repeating or repeating burst. 579 bool mRepeating; 580 // Whether this request has ROTATE_AND_CROP_AUTO set, so needs both 581 // overriding of ROTATE_AND_CROP value and adjustment of coordinates 582 // in several other controls in both the request and the result 583 bool mRotateAndCropAuto; 584 // Indicates that the ROTATE_AND_CROP value within 'mSettingsList' was modified 585 // irrespective of the original value. 586 bool mRotateAndCropChanged = false; 587 588 // Whether this capture request has its zoom ratio set to 1.0x before 589 // the framework overrides it for camera HAL consumption. 590 bool mZoomRatioIs1x; 591 // The systemTime timestamp when the request is created. 592 nsecs_t mRequestTimeNs; 593 594 // Whether this capture request's distortion correction update has 595 // been done. 596 bool mDistortionCorrectionUpdated = false; 597 // Whether this capture request's rotation and crop update has been 598 // done. 599 bool mRotationAndCropUpdated = false; 600 // Whether this capture request's zoom ratio update has been done. 601 bool mZoomRatioUpdated = false; 602 // Whether this max resolution capture request's crop / metering region update has been 603 // done. 604 bool mUHRCropAndMeteringRegionsUpdated = false; 605 }; 606 typedef List<sp<CaptureRequest> > RequestList; 607 608 status_t checkStatusOkToCaptureLocked(); 609 610 status_t convertMetadataListToRequestListLocked( 611 const List<const PhysicalCameraSettingsList> &metadataList, 612 const std::list<const SurfaceMap> &surfaceMaps, 613 bool repeating, nsecs_t requestTimeNs, 614 /*out*/ 615 RequestList *requestList); 616 617 void convertToRequestList(List<const PhysicalCameraSettingsList>& requestsList, 618 std::list<const SurfaceMap>& surfaceMaps, 619 const CameraMetadata& request); 620 621 status_t submitRequestsHelper(const List<const PhysicalCameraSettingsList> &requestsList, 622 const std::list<const SurfaceMap> &surfaceMaps, 623 bool repeating, 624 int64_t *lastFrameNumber = NULL); 625 626 // lock to ensure only one processCaptureResult is called at a time. 627 Mutex mProcessCaptureResultLock; 628 629 /** 630 * Common initialization code shared by both HAL paths 631 * 632 * Must be called with mLock and mInterfaceLock held. 633 */ 634 status_t initializeCommonLocked(); 635 636 /** 637 * Get the last request submitted to the hal by the request thread. 638 * 639 * Must be called with mLock held. 640 */ 641 virtual CameraMetadata getLatestRequestLocked(); 642 643 virtual status_t injectionCameraInitialize(const String8 &injectCamId, 644 sp<CameraProviderManager> manager) = 0; 645 646 /** 647 * Update the current device status and wake all waiting threads. 648 * 649 * Must be called with mLock held. 650 */ 651 void internalUpdateStatusLocked(Status status); 652 653 /** 654 * Pause processing and flush everything, but don't tell the clients. 655 * This is for reconfiguring outputs transparently when according to the 656 * CameraDeviceBase interface we shouldn't need to. 657 * Must be called with mLock and mInterfaceLock both held. 658 */ 659 status_t internalPauseAndWaitLocked(nsecs_t maxExpectedDuration); 660 661 /** 662 * Resume work after internalPauseAndWaitLocked() 663 * Must be called with mLock and mInterfaceLock both held. 664 */ 665 status_t internalResumeLocked(); 666 667 /** 668 * Wait until status tracker tells us we've transitioned to the target state 669 * set, which is either ACTIVE when active==true or IDLE (which is any 670 * non-ACTIVE state) when active==false. 671 * 672 * Needs to be called with mLock and mInterfaceLock held. This means there 673 * can ever only be one waiter at most. 674 * 675 * During the wait mLock is released. 676 * 677 */ 678 status_t waitUntilStateThenRelock(bool active, nsecs_t timeout); 679 680 /** 681 * Implementation of waitUntilDrained. On success, will transition to IDLE state. 682 * 683 * Need to be called with mLock and mInterfaceLock held. 684 */ 685 status_t waitUntilDrainedLocked(nsecs_t maxExpectedDuration); 686 687 /** 688 * Do common work for setting up a streaming or single capture request. 689 * On success, will transition to ACTIVE if in IDLE. 690 */ 691 sp<CaptureRequest> setUpRequestLocked(const PhysicalCameraSettingsList &request, 692 const SurfaceMap &surfaceMap); 693 694 /** 695 * Build a CaptureRequest request from the CameraDeviceBase request 696 * settings. 697 */ 698 sp<CaptureRequest> createCaptureRequest(const PhysicalCameraSettingsList &request, 699 const SurfaceMap &surfaceMap); 700 701 /** 702 * Internally re-configure camera device using new session parameters. 703 * This will get triggered by the request thread. 704 */ 705 bool reconfigureCamera(const CameraMetadata& sessionParams, int clientStatusId); 706 707 /** 708 * Return true in case of any output or input abandoned streams, 709 * otherwise return false. 710 */ 711 bool checkAbandonedStreamsLocked(); 712 713 /** 714 * Filter stream session parameters and configure camera HAL. 715 */ 716 status_t filterParamsAndConfigureLocked(const CameraMetadata& sessionParams, 717 int operatingMode); 718 719 /** 720 * Take the currently-defined set of streams and configure the HAL to use 721 * them. This is a long-running operation (may be several hundered ms). 722 */ 723 status_t configureStreamsLocked(int operatingMode, 724 const CameraMetadata& sessionParams, bool notifyRequestThread = true); 725 726 /** 727 * Cancel stream configuration that did not finish successfully. 728 */ 729 void cancelStreamsConfigurationLocked(); 730 731 /** 732 * Add a fake stream to the current stream set as a workaround for 733 * not allowing 0 streams in the camera HAL spec. 734 */ 735 status_t addFakeStreamLocked(); 736 737 /** 738 * Remove a fake stream if the current config includes real streams. 739 */ 740 status_t tryRemoveFakeStreamLocked(); 741 742 /** 743 * Set device into an error state due to some fatal failure, and set an 744 * error message to indicate why. Only the first call's message will be 745 * used. The message is also sent to the log. 746 */ 747 void setErrorState(const char *fmt, ...) override; 748 void setErrorStateLocked(const char *fmt, ...) override; 749 void setErrorStateV(const char *fmt, va_list args); 750 void setErrorStateLockedV(const char *fmt, va_list args); 751 752 ///////////////////////////////////////////////////////////////////// 753 // Implements InflightRequestUpdateInterface 754 755 void onInflightEntryRemovedLocked(nsecs_t duration) override; 756 void checkInflightMapLengthLocked() override; 757 void onInflightMapFlushedLocked() override; 758 759 ///////////////////////////////////////////////////////////////////// 760 761 /** 762 * Debugging trylock/spin method 763 * Try to acquire a lock a few times with sleeps between before giving up. 764 */ 765 bool tryLockSpinRightRound(Mutex& lock); 766 767 /** 768 * Helper function to get the offset between MONOTONIC and BOOTTIME 769 * timestamp. 770 */ 771 static nsecs_t getMonoToBoottimeOffset(); 772 773 // Override rotate_and_crop control if needed 774 static bool overrideAutoRotateAndCrop(const sp<CaptureRequest> &request /*out*/, 775 bool overrideToPortrait, 776 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropOverride); 777 778 struct RequestTrigger { 779 // Metadata tag number, e.g. android.control.aePrecaptureTrigger 780 uint32_t metadataTag; 781 // Metadata value, e.g. 'START' or the trigger ID 782 int32_t entryValue; 783 784 // The last part of the fully qualified path, e.g. afTrigger getTagNameRequestTrigger785 const char *getTagName() const { 786 return get_camera_metadata_tag_name(metadataTag) ?: "NULL"; 787 } 788 789 // e.g. TYPE_BYTE, TYPE_INT32, etc. getTagTypeRequestTrigger790 int getTagType() const { 791 return get_camera_metadata_tag_type(metadataTag); 792 } 793 }; 794 795 /** 796 * Thread for managing capture request submission to HAL device. 797 */ 798 class RequestThread : public Thread { 799 800 public: 801 802 RequestThread(wp<Camera3Device> parent, 803 sp<camera3::StatusTracker> statusTracker, 804 sp<HalInterface> interface, 805 const Vector<int32_t>& sessionParamKeys, 806 bool useHalBufManager, 807 bool supportCameraMute, 808 bool overrideToPortrait); 809 ~RequestThread(); 810 811 void setNotificationListener(wp<NotificationListener> listener); 812 813 /** 814 * Call after stream (re)-configuration is completed. 815 */ 816 void configurationComplete(bool isConstrainedHighSpeed, 817 const CameraMetadata& sessionParams, 818 const std::map<int32_t, std::set<String8>>& groupIdPhysicalCameraMap); 819 820 /** 821 * Set or clear the list of repeating requests. Does not block 822 * on either. Use waitUntilPaused to wait until request queue 823 * has emptied out. 824 */ 825 status_t setRepeatingRequests(const RequestList& requests, 826 /*out*/ 827 int64_t *lastFrameNumber = NULL); 828 status_t clearRepeatingRequests(/*out*/ 829 int64_t *lastFrameNumber = NULL); 830 831 status_t queueRequestList(List<sp<CaptureRequest> > &requests, 832 /*out*/ 833 int64_t *lastFrameNumber = NULL); 834 835 /** 836 * Remove all queued and repeating requests, and pending triggers 837 */ 838 status_t clear(/*out*/int64_t *lastFrameNumber = NULL); 839 840 /** 841 * Flush all pending requests in HAL. 842 */ 843 status_t flush(); 844 845 /** 846 * Queue a trigger to be dispatched with the next outgoing 847 * process_capture_request. The settings for that request only 848 * will be temporarily rewritten to add the trigger tag/value. 849 * Subsequent requests will not be rewritten (for this tag). 850 */ 851 status_t queueTrigger(RequestTrigger trigger[], size_t count); 852 853 /** 854 * Pause/unpause the capture thread. Doesn't block, so use 855 * waitUntilPaused to wait until the thread is paused. 856 */ 857 void setPaused(bool paused); 858 859 /** 860 * Wait until thread processes the capture request with settings' 861 * android.request.id == requestId. 862 * 863 * Returns TIMED_OUT in case the thread does not process the request 864 * within the timeout. 865 */ 866 status_t waitUntilRequestProcessed(int32_t requestId, nsecs_t timeout); 867 868 /** 869 * Shut down the thread. Shutdown is asynchronous, so thread may 870 * still be running once this method returns. 871 */ 872 virtual void requestExit(); 873 874 /** 875 * Get the latest request that was sent to the HAL 876 * with process_capture_request. 877 */ 878 CameraMetadata getLatestRequest() const; 879 880 /** 881 * Returns true if the stream is a target of any queued or repeating 882 * capture request 883 */ 884 bool isStreamPending(sp<camera3::Camera3StreamInterface>& stream); 885 886 /** 887 * Returns true if the surface is a target of any queued or repeating 888 * capture request 889 */ 890 bool isOutputSurfacePending(int streamId, size_t surfaceId); 891 892 // dump processCaptureRequest latency dumpCaptureRequestLatency(int fd,const char * name)893 void dumpCaptureRequestLatency(int fd, const char* name) { 894 mRequestLatency.dump(fd, name); 895 } 896 897 void signalPipelineDrain(const std::vector<int>& streamIds); 898 void resetPipelineDrain(); 899 900 void clearPreviousRequest(); 901 902 status_t setRotateAndCropAutoBehavior( 903 camera_metadata_enum_android_scaler_rotate_and_crop_t rotateAndCropValue); 904 status_t setComposerSurface(bool composerSurfacePresent); 905 906 status_t setCameraMute(int32_t muteMode); 907 908 status_t setHalInterface(sp<HalInterface> newHalInterface); 909 910 protected: 911 912 virtual bool threadLoop(); 913 914 static const String8& getId(const wp<Camera3Device> &device); 915 916 status_t queueTriggerLocked(RequestTrigger trigger); 917 // Mix-in queued triggers into this request 918 int32_t insertTriggers(const sp<CaptureRequest> &request); 919 // Purge the queued triggers from this request, 920 // restoring the old field values for those tags. 921 status_t removeTriggers(const sp<CaptureRequest> &request); 922 923 // HAL workaround: Make sure a trigger ID always exists if 924 // a trigger does 925 status_t addFakeTriggerIds(const sp<CaptureRequest> &request); 926 927 // Override rotate_and_crop control if needed; returns true if the current value was changed 928 bool overrideAutoRotateAndCrop(const sp<CaptureRequest> &request /*out*/); 929 930 // Override test_pattern control if needed for camera mute; returns true 931 // if the current value was changed 932 bool overrideTestPattern(const sp<CaptureRequest> &request); 933 934 static const nsecs_t kRequestTimeout = 50e6; // 50 ms 935 936 // TODO: does this need to be adjusted for long exposure requests? 937 static const nsecs_t kRequestSubmitTimeout = 200e6; // 200 ms 938 939 // Used to prepare a batch of requests. 940 struct NextRequest { 941 sp<CaptureRequest> captureRequest; 942 camera_capture_request_t halRequest; 943 Vector<camera_stream_buffer_t> outputBuffers; 944 bool submitted; 945 }; 946 947 // Wait for the next batch of requests and put them in mNextRequests. mNextRequests will 948 // be empty if it times out. 949 void waitForNextRequestBatch(); 950 951 // Waits for a request, or returns NULL if times out. Must be called with mRequestLock hold. 952 sp<CaptureRequest> waitForNextRequestLocked(); 953 954 // Prepare HAL requests and output buffers in mNextRequests. Return TIMED_OUT if getting any 955 // output buffer timed out. If an error is returned, the caller should clean up the pending 956 // request batch. 957 status_t prepareHalRequests(); 958 959 // Return buffers, etc, for requests in mNextRequests that couldn't be fully constructed and 960 // send request errors if sendRequestError is true. The buffers will be returned in the 961 // ERROR state to mark them as not having valid data. mNextRequests will be cleared. 962 void cleanUpFailedRequests(bool sendRequestError); 963 964 // Stop the repeating request if any of its output streams is abandoned. 965 void checkAndStopRepeatingRequest(); 966 967 // Release physical camera settings and camera id resources. 968 void cleanupPhysicalSettings(sp<CaptureRequest> request, 969 /*out*/camera_capture_request_t *halRequest); 970 971 // Pause handling 972 bool waitIfPaused(); 973 void unpauseForNewRequests(); 974 975 // Relay error to parent device object setErrorState 976 void setErrorState(const char *fmt, ...); 977 978 // If the input request is in mRepeatingRequests. Must be called with mRequestLock hold 979 bool isRepeatingRequestLocked(const sp<CaptureRequest>&); 980 981 // Clear repeating requests. Must be called with mRequestLock held. 982 status_t clearRepeatingRequestsLocked(/*out*/ int64_t *lastFrameNumber = NULL); 983 984 // send request in mNextRequests to HAL in a batch. Return true = sucssess 985 bool sendRequestsBatch(); 986 987 // Calculate the expected (minimum, maximum, isFixedFps) duration info for a request 988 struct ExpectedDurationInfo { 989 nsecs_t minDuration; 990 nsecs_t maxDuration; 991 bool isFixedFps; 992 }; 993 ExpectedDurationInfo calculateExpectedDurationRange( 994 const camera_metadata_t *request); 995 996 // Check and update latest session parameters based on the current request settings. 997 bool updateSessionParameters(const CameraMetadata& settings); 998 999 // Check whether FPS range session parameter re-configuration is needed in constrained 1000 // high speed recording camera sessions. 1001 bool skipHFRTargetFPSUpdate(int32_t tag, const camera_metadata_ro_entry_t& newEntry, 1002 const camera_metadata_entry_t& currentEntry); 1003 1004 // Update next request sent to HAL 1005 void updateNextRequest(NextRequest& nextRequest); 1006 1007 wp<Camera3Device> mParent; 1008 wp<camera3::StatusTracker> mStatusTracker; 1009 sp<HalInterface> mInterface; 1010 1011 wp<NotificationListener> mListener; 1012 1013 const String8& mId; // The camera ID 1014 int mStatusId; // The RequestThread's component ID for 1015 // status tracking 1016 1017 Mutex mRequestLock; 1018 Condition mRequestSignal; 1019 bool mRequestClearing; 1020 1021 Condition mRequestSubmittedSignal; 1022 RequestList mRequestQueue; 1023 RequestList mRepeatingRequests; 1024 bool mFirstRepeating; 1025 // The next batch of requests being prepped for submission to the HAL, no longer 1026 // on the request queue. Read-only even with mRequestLock held, outside 1027 // of threadLoop 1028 Vector<NextRequest> mNextRequests; 1029 1030 // To protect flush() and sending a request batch to HAL. 1031 Mutex mFlushLock; 1032 1033 bool mReconfigured; 1034 1035 // Used by waitIfPaused, waitForNextRequest, waitUntilPaused, and signalPipelineDrain 1036 Mutex mPauseLock; 1037 bool mDoPause; 1038 Condition mDoPauseSignal; 1039 bool mPaused; 1040 bool mNotifyPipelineDrain; 1041 std::vector<int> mStreamIdsToBeDrained; 1042 1043 sp<CaptureRequest> mPrevRequest; 1044 int32_t mPrevTriggers; 1045 std::set<std::string> mPrevCameraIdsWithZoom; 1046 1047 uint32_t mFrameNumber; 1048 1049 mutable Mutex mLatestRequestMutex; 1050 Condition mLatestRequestSignal; 1051 // android.request.id for latest process_capture_request 1052 int32_t mLatestRequestId; 1053 CameraMetadata mLatestRequest; 1054 std::unordered_map<std::string, CameraMetadata> mLatestPhysicalRequest; 1055 1056 typedef KeyedVector<uint32_t/*tag*/, RequestTrigger> TriggerMap; 1057 Mutex mTriggerMutex; 1058 TriggerMap mTriggerMap; 1059 TriggerMap mTriggerRemovedMap; 1060 TriggerMap mTriggerReplacedMap; 1061 uint32_t mCurrentAfTriggerId; 1062 uint32_t mCurrentPreCaptureTriggerId; 1063 camera_metadata_enum_android_scaler_rotate_and_crop_t mRotateAndCropOverride; 1064 bool mComposerOutput; 1065 int32_t mCameraMute; // 0 = no mute, otherwise the TEST_PATTERN_MODE to use 1066 bool mCameraMuteChanged; 1067 1068 int64_t mRepeatingLastFrameNumber; 1069 1070 // Flag indicating if we should prepare video stream for video requests. 1071 bool mPrepareVideoStream; 1072 1073 bool mConstrainedMode; 1074 1075 static const int32_t kRequestLatencyBinSize = 40; // in ms 1076 CameraLatencyHistogram mRequestLatency; 1077 1078 Vector<int32_t> mSessionParamKeys; 1079 CameraMetadata mLatestSessionParams; 1080 1081 std::map<int32_t, std::set<String8>> mGroupIdPhysicalCameraMap; 1082 1083 const bool mUseHalBufManager; 1084 const bool mSupportCameraMute; 1085 const bool mOverrideToPortrait; 1086 }; 1087 1088 virtual sp<RequestThread> createNewRequestThread(wp<Camera3Device> /*parent*/, 1089 sp<camera3::StatusTracker> /*statusTracker*/, 1090 sp<HalInterface> /*interface*/, 1091 const Vector<int32_t>& /*sessionParamKeys*/, 1092 bool /*useHalBufManager*/, 1093 bool /*supportCameraMute*/, 1094 bool /*overrideToPortrait*/) = 0; 1095 1096 sp<RequestThread> mRequestThread; 1097 1098 /** 1099 * In-flight queue for tracking completion of capture requests. 1100 */ 1101 std::mutex mInFlightLock; 1102 camera3::InFlightRequestMap mInFlightMap; 1103 nsecs_t mExpectedInflightDuration = 0; 1104 int64_t mLastCompletedRegularFrameNumber = -1; 1105 int64_t mLastCompletedReprocessFrameNumber = -1; 1106 int64_t mLastCompletedZslFrameNumber = -1; 1107 // End of mInFlightLock protection scope 1108 1109 int mInFlightStatusId; // const after initialize 1110 1111 status_t registerInFlight(uint32_t frameNumber, 1112 int32_t numBuffers, CaptureResultExtras resultExtras, bool hasInput, 1113 bool callback, nsecs_t minExpectedDuration, nsecs_t maxExpectedDuration, 1114 bool isFixedFps, const std::set<std::set<String8>>& physicalCameraIds, 1115 bool isStillCapture, bool isZslCapture, bool rotateAndCropAuto, 1116 const std::set<std::string>& cameraIdsWithZoom, const SurfaceMap& outputSurfaces, 1117 nsecs_t requestTimeNs); 1118 1119 /** 1120 * Tracking for idle detection 1121 */ 1122 sp<camera3::StatusTracker> mStatusTracker; 1123 1124 /** 1125 * Graphic buffer manager for output streams. Each device has a buffer manager, which is used 1126 * by the output streams to get and return buffers if these streams are registered to this 1127 * buffer manager. 1128 */ 1129 sp<camera3::Camera3BufferManager> mBufferManager; 1130 1131 /** 1132 * Thread for preparing streams 1133 */ 1134 class PreparerThread : private Thread, public virtual RefBase { 1135 public: 1136 PreparerThread(); 1137 ~PreparerThread(); 1138 1139 void setNotificationListener(wp<NotificationListener> listener); 1140 1141 /** 1142 * Queue up a stream to be prepared. Streams are processed by a background thread in FIFO 1143 * order. Pre-allocate up to maxCount buffers for the stream, or the maximum number needed 1144 * for the pipeline if maxCount is ALLOCATE_PIPELINE_MAX. 1145 */ 1146 status_t prepare(int maxCount, sp<camera3::Camera3StreamInterface>& stream); 1147 1148 /** 1149 * Cancel all current and pending stream preparation 1150 */ 1151 status_t clear(); 1152 1153 /** 1154 * Pause all preparation activities 1155 */ 1156 void pause(); 1157 1158 /** 1159 * Resume preparation activities 1160 */ 1161 status_t resume(); 1162 1163 private: 1164 Mutex mLock; 1165 Condition mThreadActiveSignal; 1166 1167 virtual bool threadLoop(); 1168 1169 // Guarded by mLock 1170 1171 wp<NotificationListener> mListener; 1172 std::unordered_map<int, sp<camera3::Camera3StreamInterface> > mPendingStreams; 1173 bool mActive; 1174 bool mCancelNow; 1175 1176 // Only accessed by threadLoop and the destructor 1177 1178 sp<camera3::Camera3StreamInterface> mCurrentStream; 1179 int mCurrentMaxCount; 1180 bool mCurrentPrepareComplete; 1181 }; 1182 sp<PreparerThread> mPreparerThread; 1183 1184 /** 1185 * Output result queue and current HAL device 3A state 1186 */ 1187 1188 // Lock for output side of device 1189 std::mutex mOutputLock; 1190 1191 /**** Scope for mOutputLock ****/ 1192 // the minimal frame number of the next non-reprocess result 1193 uint32_t mNextResultFrameNumber; 1194 // the minimal frame number of the next reprocess result 1195 uint32_t mNextReprocessResultFrameNumber; 1196 // the minimal frame number of the next ZSL still capture result 1197 uint32_t mNextZslStillResultFrameNumber; 1198 // the minimal frame number of the next non-reprocess shutter 1199 uint32_t mNextShutterFrameNumber; 1200 // the minimal frame number of the next reprocess shutter 1201 uint32_t mNextReprocessShutterFrameNumber; 1202 // the minimal frame number of the next ZSL still capture shutter 1203 uint32_t mNextZslStillShutterFrameNumber; 1204 std::list<CaptureResult> mResultQueue; 1205 std::condition_variable mResultSignal; 1206 wp<NotificationListener> mListener; 1207 1208 /**** End scope for mOutputLock ****/ 1209 1210 /**** Scope for mInFlightLock ****/ 1211 1212 // Remove the in-flight map entry of the given index from mInFlightMap. 1213 // It must only be called with mInFlightLock held. 1214 void removeInFlightMapEntryLocked(int idx); 1215 1216 // Remove all in-flight requests and return all buffers. 1217 // This is used after HAL interface is closed to cleanup any request/buffers 1218 // not returned by HAL. 1219 void flushInflightRequests(); 1220 1221 /**** End scope for mInFlightLock ****/ 1222 1223 /** 1224 * Distortion correction support 1225 */ 1226 // Map from camera IDs to its corresponding distortion mapper. Only contains 1227 // 1 ID if the device isn't a logical multi-camera. Otherwise contains both 1228 // logical camera and its physical subcameras. 1229 std::unordered_map<std::string, camera3::DistortionMapper> mDistortionMappers; 1230 1231 /** 1232 * Zoom ratio mapper support 1233 */ 1234 std::unordered_map<std::string, camera3::ZoomRatioMapper> mZoomRatioMappers; 1235 1236 /** 1237 * UHR request crop / metering region mapper support 1238 */ 1239 std::unordered_map<std::string, camera3::UHRCropAndMeteringRegionMapper> 1240 mUHRCropAndMeteringRegionMappers; 1241 1242 /** 1243 * RotateAndCrop mapper support 1244 */ 1245 std::unordered_map<std::string, camera3::RotateAndCropMapper> mRotateAndCropMappers; 1246 1247 // Debug tracker for metadata tag value changes 1248 // - Enabled with the -m <taglist> option to dumpsys, such as 1249 // dumpsys -m android.control.aeState,android.control.aeMode 1250 // - Disabled with -m off 1251 // - dumpsys -m 3a is a shortcut for ae/af/awbMode, State, and Triggers 1252 TagMonitor mTagMonitor; 1253 1254 void monitorMetadata(TagMonitor::eventSource source, int64_t frameNumber, 1255 nsecs_t timestamp, const CameraMetadata& metadata, 1256 const std::unordered_map<std::string, CameraMetadata>& physicalMetadata, 1257 const camera_stream_buffer_t *outputBuffers, uint32_t numOutputBuffers, 1258 int32_t inputStreamId); 1259 1260 metadata_vendor_id_t mVendorTagId; 1261 1262 // Cached last requested template id 1263 int mLastTemplateId; 1264 1265 // Synchronizes access to status tracker between inflight updates and disconnect. 1266 // b/79972865 1267 Mutex mTrackerLock; 1268 1269 // Whether HAL request buffers through requestStreamBuffers API 1270 bool mUseHalBufManager = false; 1271 1272 // Lock to ensure requestStreamBuffers() callbacks are serialized 1273 std::mutex mRequestBufferInterfaceLock; 1274 1275 // The state machine to control when requestStreamBuffers should allow 1276 // HAL to request buffers. 1277 enum RequestBufferState { 1278 /** 1279 * This is the initial state. 1280 * requestStreamBuffers call will return FAILED_CONFIGURING in this state. 1281 * Will switch to RB_STATUS_READY after a successful configureStreams or 1282 * processCaptureRequest call. 1283 */ 1284 RB_STATUS_STOPPED, 1285 1286 /** 1287 * requestStreamBuffers call will proceed in this state. 1288 * When device is asked to stay idle via waitUntilStateThenRelock() call: 1289 * - Switch to RB_STATUS_STOPPED if there is no inflight requests and 1290 * request thread is paused. 1291 * - Switch to RB_STATUS_PENDING_STOP otherwise 1292 */ 1293 RB_STATUS_READY, 1294 1295 /** 1296 * requestStreamBuffers call will proceed in this state. 1297 * Switch to RB_STATUS_STOPPED when all inflight requests are fulfilled 1298 * and request thread is paused 1299 */ 1300 RB_STATUS_PENDING_STOP, 1301 }; 1302 1303 class RequestBufferStateMachine { 1304 public: 1305 status_t initialize(sp<camera3::StatusTracker> statusTracker); 1306 1307 // Return if the state machine currently allows for requestBuffers 1308 // If the state allows for it, mRequestBufferOngoing will be set to true 1309 // and caller must call endRequestBuffer() later to unset the flag 1310 bool startRequestBuffer(); 1311 void endRequestBuffer(); 1312 1313 // Events triggered by application API call 1314 void onStreamsConfigured(); 1315 void onWaitUntilIdle(); 1316 1317 // Events usually triggered by hwBinder processCaptureResult callback thread 1318 // But can also be triggered on request thread for failed request, or on 1319 // hwbinder notify callback thread for shutter/error callbacks 1320 void onInflightMapEmpty(); 1321 1322 // Events triggered by RequestThread 1323 void onSubmittingRequest(); 1324 void onRequestThreadPaused(); 1325 1326 // Events triggered by successful switchToOffline call 1327 // Return true is there is no ongoing requestBuffer call. 1328 bool onSwitchToOfflineSuccess(); 1329 1330 private: 1331 void notifyTrackerLocked(bool active); 1332 1333 // Switch to STOPPED state and return true if all conditions allows for it. 1334 // Otherwise do nothing and return false. 1335 bool checkSwitchToStopLocked(); 1336 1337 std::mutex mLock; 1338 RequestBufferState mStatus = RB_STATUS_STOPPED; 1339 1340 bool mRequestThreadPaused = true; 1341 bool mInflightMapEmpty = true; 1342 bool mRequestBufferOngoing = false; 1343 bool mSwitchedToOffline = false; 1344 1345 wp<camera3::StatusTracker> mStatusTracker; 1346 int mRequestBufferStatusId; 1347 } mRequestBufferSM; 1348 1349 // Fix up result metadata for monochrome camera. 1350 bool mNeedFixupMonochromeTags; 1351 1352 // Whether HAL supports offline processing capability. 1353 bool mSupportOfflineProcessing = false; 1354 1355 // Whether the HAL supports camera muting via test pattern 1356 bool mSupportCameraMute = false; 1357 // Whether the HAL supports SOLID_COLOR or BLACK if mSupportCameraMute is true 1358 bool mSupportTestPatternSolidColor = false; 1359 1360 // Whether the camera framework overrides the device characteristics for 1361 // performance class. 1362 bool mOverrideForPerfClass; 1363 1364 // Whether the camera framework overrides the device characteristics for 1365 // app compatibility reasons. 1366 bool mOverrideToPortrait; 1367 camera_metadata_enum_android_scaler_rotate_and_crop_t mRotateAndCropOverride; 1368 bool mComposerOutput; 1369 1370 // Current active physical id of the logical multi-camera, if any 1371 std::string mActivePhysicalId; 1372 1373 // The current minimum expected frame duration based on AE_TARGET_FPS_RANGE 1374 nsecs_t mMinExpectedDuration = 0; 1375 // Whether the camera device runs at fixed frame rate based on AE_MODE and 1376 // AE_TARGET_FPS_RANGE 1377 bool mIsFixedFps = false; 1378 1379 // Injection camera related methods. 1380 class Camera3DeviceInjectionMethods : public virtual RefBase { 1381 public: 1382 Camera3DeviceInjectionMethods(wp<Camera3Device> parent); 1383 1384 ~Camera3DeviceInjectionMethods(); 1385 1386 // Injection camera will replace the internal camera and configure streams 1387 // when device is IDLE and request thread is paused. 1388 status_t injectCamera( 1389 camera3::camera_stream_configuration& injectionConfig, 1390 const std::vector<uint32_t>& injectionBufferSizes); 1391 1392 // Stop the injection camera and switch back to backup hal interface. 1393 status_t stopInjection(); 1394 1395 bool isInjecting(); 1396 1397 bool isStreamConfigCompleteButNotInjected(); 1398 1399 const String8& getInjectedCamId() const; 1400 1401 void getInjectionConfig(/*out*/ camera3::camera_stream_configuration* injectionConfig, 1402 /*out*/ std::vector<uint32_t>* injectionBufferSizes); 1403 1404 // When the streaming configuration is completed and the camera device is active, but the 1405 // injection camera has not yet been injected, the streaming configuration of the internal 1406 // camera will be stored first. 1407 void storeInjectionConfig( 1408 const camera3::camera_stream_configuration& injectionConfig, 1409 const std::vector<uint32_t>& injectionBufferSizes); 1410 1411 protected: 1412 // Configure the streams of injection camera, it need wait until the 1413 // output streams are created and configured to the original camera before 1414 // proceeding. 1415 status_t injectionConfigureStreams( 1416 camera3::camera_stream_configuration& injectionConfig, 1417 const std::vector<uint32_t>& injectionBufferSizes); 1418 1419 // Disconnect the injection camera and delete the hal interface. 1420 void injectionDisconnectImpl(); 1421 1422 // Use injection camera hal interface to replace and backup original 1423 // camera hal interface. 1424 virtual status_t replaceHalInterface(sp<HalInterface> /*newHalInterface*/, 1425 bool /*keepBackup*/) = 0; 1426 1427 wp<Camera3Device> mParent; 1428 1429 // Backup of the original camera hal interface. 1430 sp<HalInterface> mBackupHalInterface; 1431 1432 // Generated injection camera hal interface. 1433 sp<HalInterface> mInjectedCamHalInterface; 1434 1435 // The flag indicates that the stream configuration is complete, the camera device is 1436 // active, but the injection camera has not yet been injected. 1437 bool mIsStreamConfigCompleteButNotInjected = false; 1438 1439 // Copy the configuration of the internal camera. 1440 camera3::camera_stream_configuration mInjectionConfig; 1441 1442 // Copy the streams of the internal camera. 1443 Vector<camera3::camera_stream_t*> mInjectionStreams; 1444 1445 // Copy the bufferSizes of the output streams of the internal camera. 1446 std::vector<uint32_t> mInjectionBufferSizes; 1447 1448 // Synchronizes access to injection camera between initialize and 1449 // disconnect. 1450 Mutex mInjectionLock; 1451 1452 // The injection camera ID. 1453 String8 mInjectedCamId; 1454 }; 1455 1456 virtual sp<Camera3DeviceInjectionMethods> 1457 createCamera3DeviceInjectionMethods(wp<Camera3Device>) = 0; 1458 1459 sp<Camera3DeviceInjectionMethods> mInjectionMethods; 1460 1461 void overrideStreamUseCaseLocked(); 1462 1463 }; // class Camera3Device 1464 1465 }; // namespace android 1466 1467 #endif 1468