1 /* 2 * Copyright (C) 2022 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_AIDLCAMERA3DEVICE_H 18 #define ANDROID_SERVERS_AIDLCAMERA3DEVICE_H 19 20 #include "../Camera3Device.h" 21 #include "AidlCamera3OutputUtils.h" 22 #include <fmq/AidlMessageQueue.h> 23 24 #include <aidl/android/hardware/camera/device/BnCameraDeviceCallback.h> 25 #include <aidl/android/hardware/camera/device/ICameraDevice.h> 26 #include <aidl/android/hardware/camera/device/ICameraInjectionSession.h> 27 namespace android { 28 29 using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite; 30 using ::android::AidlMessageQueue; 31 32 /** 33 * CameraDevice for AIDL HAL devices. 34 */ 35 class AidlCamera3Device : 36 public Camera3Device { 37 public: 38 39 using AidlRequestMetadataQueue = AidlMessageQueue<int8_t, SynchronizedReadWrite>; 40 class AidlCameraDeviceCallbacks; 41 friend class AidlCameraDeviceCallbacks; 42 explicit AidlCamera3Device( 43 std::shared_ptr<CameraServiceProxyWrapper>& cameraServiceProxyWrapper, 44 std::shared_ptr<AttributionAndPermissionUtils> attributionAndPermissionUtils, 45 const std::string& id, bool overrideForPerfClass, int rotationOverride, 46 bool isVendorClient, bool legacyClient = false); 47 ~AidlCamera3Device()48 virtual ~AidlCamera3Device() { } 49 50 static aidl::android::hardware::graphics::common::PixelFormat mapToAidlPixelFormat( 51 int frameworkFormat); 52 static aidl::android::hardware::graphics::common::Dataspace mapToAidlDataspace( 53 android_dataspace dataSpace); 54 static aidl::android::hardware::graphics::common::BufferUsage mapToAidlConsumerUsage( 55 uint64_t usage); 56 static aidl::android::hardware::camera::device::StreamRotation 57 mapToAidlStreamRotation(camera_stream_rotation_t rotation); 58 59 static status_t mapToAidlStreamConfigurationMode( 60 camera_stream_configuration_mode_t operationMode, 61 aidl::android::hardware::camera::device::StreamConfigurationMode *mode); 62 63 static int mapToFrameworkFormat( 64 aidl::android::hardware::graphics::common::PixelFormat pixelFormat); 65 static android_dataspace mapToFrameworkDataspace( 66 aidl::android::hardware::graphics::common::Dataspace); 67 static uint64_t mapConsumerToFrameworkUsage( 68 aidl::android::hardware::graphics::common::BufferUsage usage); 69 static uint64_t mapProducerToFrameworkUsage( 70 aidl::android::hardware::graphics::common::BufferUsage usage); 71 72 virtual status_t switchToOffline(const std::vector<int32_t>& /*streamsToKeep*/, 73 /*out*/ sp<CameraOfflineSessionBase>* /*session*/) override; 74 75 virtual status_t initialize(sp<CameraProviderManager> manager, const std::string& monitorTags) 76 override; 77 virtual int32_t getCaptureResultFMQSize() override; 78 79 class AidlHalInterface : public Camera3Device::HalInterface { 80 public: 81 AidlHalInterface(std::shared_ptr< 82 aidl::android::hardware::camera::device::ICameraDeviceSession> &session, 83 std::shared_ptr<AidlRequestMetadataQueue> queue, 84 bool useHalBufManager, bool supportOfflineProcessing, 85 bool supportSessionHalBufManager); 86 AidlHalInterface( 87 std::shared_ptr<aidl::android::hardware::camera::device::ICameraDeviceSession> 88 &deviceSession, 89 std::shared_ptr< 90 aidl::android::hardware::camera::device::ICameraInjectionSession> &injectionSession, 91 std::shared_ptr<AidlRequestMetadataQueue> queue, 92 bool useHalBufManager, bool supportOfflineProcessing, 93 bool supportSessionHalBufManager); 94 getTransportType()95 virtual IPCTransport getTransportType() const override {return IPCTransport::AIDL; } 96 97 98 // Returns true if constructed with a valid device or session, and not yet cleared 99 virtual bool valid() override; 100 101 // Reset this HalInterface object (does not call close()) 102 virtual void clear() override; 103 104 // Caller takes ownership of requestTemplate 105 virtual status_t constructDefaultRequestSettings(camera_request_template templateId, 106 /*out*/ camera_metadata_t **requestTemplate) override; 107 108 virtual status_t configureStreams(const camera_metadata_t *sessionParams, 109 /*inout*/ camera_stream_configuration_t *config, 110 const std::vector<uint32_t>& bufferSizes, 111 int64_t logId) override; 112 113 // The injection camera configures the streams to hal. 114 virtual status_t configureInjectedStreams( 115 const camera_metadata_t* sessionParams, 116 /*inout*/ camera_stream_configuration_t* config, 117 const std::vector<uint32_t>& bufferSizes, 118 const CameraMetadata& cameraCharacteristics) override; 119 120 // When the call succeeds, the ownership of acquire fences in requests is transferred to 121 // HalInterface. More specifically, the current implementation will send the fence to 122 // HAL process and close the FD in cameraserver process. When the call fails, the ownership 123 // of the acquire fence still belongs to the caller. 124 virtual status_t processBatchCaptureRequests( 125 std::vector<camera_capture_request_t*>& requests, 126 /*out*/uint32_t* numRequestProcessed) override; 127 128 // Calls into the HAL interface 129 virtual status_t flush() override; 130 virtual status_t dump(int fd) override; 131 virtual status_t close() override; 132 virtual void signalPipelineDrain(const std::vector<int>& streamIds) override; 133 virtual bool isReconfigurationRequired(CameraMetadata& oldSessionParams, 134 CameraMetadata& newSessionParams) override; 135 136 virtual status_t repeatingRequestEnd(uint32_t , 137 const std::vector<int32_t> &) override; 138 139 status_t switchToOffline( 140 const std::vector<int32_t>& streamsToKeep, 141 /*out*/aidl::android::hardware::camera::device::CameraOfflineSessionInfo* 142 offlineSessionInfo, 143 /*out*/std::shared_ptr<aidl::android::hardware::camera::device::ICameraOfflineSession>* 144 offlineSession, 145 /*out*/camera3::BufferRecords* bufferRecords); 146 147 private: 148 149 // Always valid 150 std::shared_ptr<aidl::android::hardware::camera::device::ICameraDeviceSession> 151 mAidlSession = nullptr; 152 //Valid for injection sessions 153 std::shared_ptr<aidl::android::hardware::camera::device::ICameraInjectionSession> 154 mAidlInjectionSession = nullptr; 155 156 status_t wrapAsAidlRequest(camera_capture_request_t* request, 157 /*out*/aidl::android::hardware::camera::device::CaptureRequest* captureRequest, 158 /*out*/std::vector<native_handle_t*>* handlesCreated, 159 /*out*/std::vector<std::pair<int32_t, int32_t>>* inflightBuffers); 160 161 std::shared_ptr<AidlRequestMetadataQueue> mRequestMetadataQueue; 162 bool mSupportSessionHalBufManager = false; 163 }; // class AidlHalInterface 164 165 /** 166 * Implementation of aidl::android::hardware::camera::device::ICameraDeviceCallback 167 */ 168 ::ndk::ScopedAStatus processCaptureResult( 169 const std::vector<aidl::android::hardware::camera::device::CaptureResult>& results); 170 ::ndk::ScopedAStatus notify( 171 const std::vector<aidl::android::hardware::camera::device::NotifyMsg>& msgs); 172 173 ::ndk::ScopedAStatus requestStreamBuffers( 174 const std::vector<aidl::android::hardware::camera::device::BufferRequest>& bufReqs, 175 std::vector<aidl::android::hardware::camera::device::StreamBufferRet>* outBuffers, 176 aidl::android::hardware::camera::device::BufferRequestStatus* status); 177 178 ::ndk::ScopedAStatus returnStreamBuffers( 179 const std::vector<aidl::android::hardware::camera::device::StreamBuffer>& buffers); 180 181 class AidlRequestThread : public Camera3Device::RequestThread { 182 public: 183 AidlRequestThread(wp<Camera3Device> parent, 184 sp<camera3::StatusTracker> statusTracker, 185 sp<HalInterface> interface, 186 const Vector<int32_t>& sessionParamKeys, 187 bool useHalBufManager, 188 bool supportCameraMute, 189 int rotationOverride, 190 bool supportSettingsOverride); 191 192 status_t switchToOffline( 193 const std::vector<int32_t>& streamsToKeep, 194 /*out*/aidl::android::hardware::camera::device::CameraOfflineSessionInfo* 195 offlineSessionInfo, 196 /*out*/std::shared_ptr< 197 aidl::android::hardware::camera::device::ICameraOfflineSession>* 198 offlineSession, 199 /*out*/camera3::BufferRecords* bufferRecords); 200 }; // class AidlRequestThread 201 202 class AidlCamera3DeviceInjectionMethods : public Camera3DeviceInjectionMethods { 203 public: 204 // Initialize the injection camera and generate an hal interface. 205 status_t injectionInitialize( 206 const std::string& injectedCamId, sp<CameraProviderManager> manager, 207 const std::shared_ptr< 208 aidl::android::hardware::camera::device::ICameraDeviceCallback>& 209 callback); AidlCamera3DeviceInjectionMethods(wp<Camera3Device> parent)210 AidlCamera3DeviceInjectionMethods(wp<Camera3Device> parent) : 211 Camera3DeviceInjectionMethods(parent) { }; ~AidlCamera3DeviceInjectionMethods()212 ~AidlCamera3DeviceInjectionMethods() {} 213 private: 214 // Backup of the original camera hal result FMQ. 215 std::unique_ptr<AidlResultMetadataQueue> mBackupResultMetadataQueue; 216 217 // FMQ writes the result for the injection camera. Must be guarded by 218 // mProcessCaptureResultLock. 219 std::unique_ptr<AidlResultMetadataQueue> mInjectionResultMetadataQueue; 220 221 // Use injection camera hal interface to replace and backup original 222 // camera hal interface. 223 virtual status_t replaceHalInterface(sp<HalInterface> newHalInterface, 224 bool keepBackup) override; 225 }; 226 227 // We need a separate class which inherits from AIDL ICameraDeviceCallbacks 228 // since we use the ndk backend for AIDL HAL interfaces. The ndk backend of 229 // ICameraDeviceCallbacks doesn't support sp<> (since it doesn't inherit 230 // from RefBase). 231 // As a result we can't write sp<Camera3Device> = new AidlCamera3Device(...). 232 // It supports std::shared_ptr instead. Other references to 233 // Camera3Device in cameraserver use sp<> widely, so to keep supporting 234 // that, we create a new class which will be managed through std::shared_ptr 235 // internally by AidlCamera3Device. 236 class AidlCameraDeviceCallbacks : 237 public aidl::android::hardware::camera::device::BnCameraDeviceCallback { 238 public: 239 AidlCameraDeviceCallbacks(wp<AidlCamera3Device> parent)240 AidlCameraDeviceCallbacks(wp<AidlCamera3Device> parent) : mParent(parent) { } ~AidlCameraDeviceCallbacks()241 ~AidlCameraDeviceCallbacks() { } 242 ::ndk::ScopedAStatus processCaptureResult( 243 const std::vector< 244 aidl::android::hardware::camera::device::CaptureResult>& results) override; 245 ::ndk::ScopedAStatus notify( 246 const std::vector< 247 aidl::android::hardware::camera::device::NotifyMsg>& msgs) override; 248 249 ::ndk::ScopedAStatus requestStreamBuffers( 250 const std::vector< 251 aidl::android::hardware::camera::device::BufferRequest>& bufReqs, 252 std::vector<aidl::android::hardware::camera::device::StreamBufferRet>* outBuffers, 253 aidl::android::hardware::camera::device::BufferRequestStatus* status) override; 254 255 ::ndk::ScopedAStatus returnStreamBuffers( 256 const std::vector< 257 aidl::android::hardware::camera::device::StreamBuffer>& buffers) override; 258 259 protected: 260 ::ndk::SpAIBinder createBinder() override; 261 262 private: 263 wp<AidlCamera3Device> mParent = nullptr; 264 }; 265 266 private: 267 virtual void applyMaxBatchSizeLocked( 268 RequestList* requestList, 269 const sp<camera3::Camera3OutputStreamInterface>& stream) override; 270 271 virtual status_t injectionCameraInitialize(const std::string &injectCamId, 272 sp<CameraProviderManager> manager) override; 273 274 virtual sp<RequestThread> createNewRequestThread(wp<Camera3Device> parent, 275 sp<camera3::StatusTracker> statusTracker, 276 sp<HalInterface> interface, 277 const Vector<int32_t>& sessionParamKeys, 278 bool useHalBufManager, 279 bool supportCameraMute, 280 int rotationOverride, 281 bool supportSettingsOverride) override; 282 283 virtual sp<Camera3DeviceInjectionMethods> 284 createCamera3DeviceInjectionMethods(wp<Camera3Device>) override; 285 286 // FMQ to write result on. Must be guarded by mProcessCaptureResultLock. 287 std::unique_ptr<AidlResultMetadataQueue> mResultMetadataQueue = nullptr; 288 289 std::shared_ptr<AidlCameraDeviceCallbacks> mCallbacks = nullptr; 290 291 // Whether the batch_size_max field in the high speed configuration actually applied to 292 // capture requests. 293 bool mBatchSizeLimitEnabled = false; 294 295 // Whether the HAL supports reporting sensor readout timestamp 296 bool mSensorReadoutTimestampSupported = true; 297 298 }; // class AidlCamera3Device 299 300 }; // namespace android 301 302 #endif 303