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