1 /* 2 * Copyright (C) 2019 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 EMULATOR_CAMERA_HAL_HWL_REQUEST_PROCESSOR_H 18 #define EMULATOR_CAMERA_HAL_HWL_REQUEST_PROCESSOR_H 19 20 #include <condition_variable> 21 #include <memory> 22 #include <mutex> 23 #include <queue> 24 #include <thread> 25 26 #include "EmulatedLogicalRequestState.h" 27 #include "EmulatedSensor.h" 28 #include "HandleImporter.h" 29 #include "android/frameworks/sensorservice/1.0/ISensorManager.h" 30 #include "android/frameworks/sensorservice/1.0/types.h" 31 #include "hwl_types.h" 32 33 namespace android { 34 35 using ::android::frameworks::sensorservice::V1_0::IEventQueue; 36 using ::android::frameworks::sensorservice::V1_0::IEventQueueCallback; 37 using ::android::hardware::Return; 38 using ::android::hardware::Void; 39 using android::hardware::camera::common::V1_0::helper::HandleImporter; 40 using ::android::hardware::sensors::V1_0::Event; 41 using google_camera_hal::HalCameraMetadata; 42 using google_camera_hal::HwlPipelineRequest; 43 using google_camera_hal::HwlSessionCallback; 44 using google_camera_hal::RequestTemplate; 45 using google_camera_hal::StreamBuffer; 46 47 struct PendingRequest { 48 std::unique_ptr<HalCameraMetadata> settings; 49 std::unique_ptr<Buffers> input_buffers; 50 std::unique_ptr<Buffers> output_buffers; 51 }; 52 53 class EmulatedRequestProcessor { 54 public: 55 EmulatedRequestProcessor(uint32_t camera_id, sp<EmulatedSensor> sensor, 56 const HwlSessionCallback& session_callback); 57 virtual ~EmulatedRequestProcessor(); 58 59 // Process given pipeline requests and invoke the respective callback in a 60 // separate thread 61 status_t ProcessPipelineRequests( 62 uint32_t frame_number, std::vector<HwlPipelineRequest>& requests, 63 const std::vector<EmulatedPipeline>& pipelines, 64 const DynamicStreamIdMapType& dynamic_stream_id_map, 65 bool use_default_physical_camera); 66 67 status_t GetDefaultRequest( 68 RequestTemplate type, 69 std::unique_ptr<HalCameraMetadata>* default_settings); 70 71 status_t Flush(); 72 73 status_t Initialize(std::unique_ptr<HalCameraMetadata> static_meta, 74 PhysicalDeviceMapPtr physical_devices); 75 void InitializeSensorQueue(std::weak_ptr<EmulatedRequestProcessor> processor); 76 77 void SetSessionCallback(const HwlSessionCallback& hwl_session_callback); 78 79 private: 80 class SensorHandler : public IEventQueueCallback { 81 public: SensorHandler(std::weak_ptr<EmulatedRequestProcessor> processor)82 SensorHandler(std::weak_ptr<EmulatedRequestProcessor> processor) 83 : processor_(processor) { 84 } 85 86 // IEventQueueCallback interface 87 Return<void> onEvent(const Event& e) override; 88 89 private: 90 std::weak_ptr<EmulatedRequestProcessor> processor_; 91 }; 92 93 int32_t sensor_handle_; 94 sp<IEventQueue> sensor_event_queue_; 95 std::atomic_uint32_t screen_rotation_; 96 97 void RequestProcessorLoop(); 98 99 std::thread request_thread_; 100 std::atomic_bool processor_done_ = false; 101 102 // helper methods AlignTo(uint32_t value,uint32_t alignment)103 static uint32_t inline AlignTo(uint32_t value, uint32_t alignment) { 104 uint32_t delta = value % alignment; 105 return (delta == 0) ? value : (value + (alignment - delta)); 106 } 107 108 // Return buffer size and row stride in bytes 109 status_t GetBufferSizeAndStride(const EmulatedStream& stream, 110 buffer_handle_t buffer, uint32_t* size /*out*/, 111 uint32_t* stride /*out*/); 112 status_t LockSensorBuffer(const EmulatedStream& stream, 113 buffer_handle_t buffer, int32_t width, 114 int32_t height, SensorBuffer* sensor_buffer /*out*/); 115 std::unique_ptr<Buffers> CreateSensorBuffers( 116 uint32_t frame_number, const std::vector<StreamBuffer>& buffers, 117 const std::unordered_map<uint32_t, EmulatedStream>& streams, 118 uint32_t pipeline_id, HwlPipelineCallback cb, int32_t override_width, 119 int32_t override_height); 120 std::unique_ptr<SensorBuffer> CreateSensorBuffer( 121 uint32_t frame_number, const EmulatedStream& stream, uint32_t pipeline_id, 122 HwlPipelineCallback callback, StreamBuffer stream_buffer, 123 int32_t override_width, int32_t override_height); 124 std::unique_ptr<Buffers> AcquireBuffers(Buffers* buffers); 125 void NotifyFailedRequest(const PendingRequest& request); 126 127 std::mutex process_mutex_; 128 std::condition_variable request_condition_; 129 std::queue<PendingRequest> pending_requests_; 130 uint32_t camera_id_; 131 sp<EmulatedSensor> sensor_; 132 HwlSessionCallback session_callback_; 133 std::unique_ptr<EmulatedLogicalRequestState> 134 request_state_; // Stores and handles 3A and related camera states. 135 std::unique_ptr<HalCameraMetadata> last_settings_; 136 std::shared_ptr<HandleImporter> importer_; 137 138 EmulatedRequestProcessor(const EmulatedRequestProcessor&) = delete; 139 EmulatedRequestProcessor& operator=(const EmulatedRequestProcessor&) = delete; 140 }; 141 142 } // namespace android 143 144 #endif // EMULATOR_CAMERA_HAL_HWL_REQUEST_PROCESSOR_H 145