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