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