1 /*
2  * Copyright 2020 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_HARDWARE_AUTOMOTIVE_EVS_V1_1_EVSEMULATEDCAMERA_H
18 #define ANDROID_HARDWARE_AUTOMOTIVE_EVS_V1_1_EVSEMULATEDCAMERA_H
19 
20 #include "VideoCapture.h"
21 
22 #include <functional>
23 #include <unordered_map>
24 
25 #include <android/hardware/automotive/evs/1.1/types.h>
26 #include <android/hardware/automotive/evs/1.1/IEvsCamera.h>
27 #include <android/hardware/automotive/evs/1.1/IEvsCameraStream.h>
28 #include <android/hardware/automotive/evs/1.1/IEvsDisplay.h>
29 #include <android/hardware/camera/device/3.2/ICameraDevice.h>
30 #include <ui/GraphicBuffer.h>
31 
32 using ::android::hardware::hidl_string;
33 using ::android::hardware::camera::device::V3_2::Stream;
34 using ::android::hardware::automotive::evs::V1_0::EvsResult;
35 using ::android::hardware::automotive::evs::V1_1::CameraDesc;
36 
37 using IEvsDisplay_1_0      = ::android::hardware::automotive::evs::V1_0::IEvsDisplay;
38 using IEvsDisplay_1_1      = ::android::hardware::automotive::evs::V1_1::IEvsDisplay;
39 using BufferDesc_1_0       = ::android::hardware::automotive::evs::V1_0::BufferDesc;
40 using BufferDesc_1_1       = ::android::hardware::automotive::evs::V1_1::BufferDesc;
41 using IEvsCamera_1_1       = ::android::hardware::automotive::evs::V1_1::IEvsCamera;
42 using IEvsCameraStream_1_0 = ::android::hardware::automotive::evs::V1_0::IEvsCameraStream;
43 using IEvsCameraStream_1_1 = ::android::hardware::automotive::evs::V1_1::IEvsCameraStream;
44 
45 using ::android::hardware::Return;
46 using ::android::hardware::hidl_vec;
47 using namespace ::android::hardware::automotive::evs::V1_1;
48 
49 namespace android {
50 namespace automotive {
51 namespace evs {
52 namespace V1_1 {
53 namespace implementation {
54 
55 struct EmulatedCameraDesc {
56     int width;                          // Camera output width in pixels
57     int height;                         // Camera output height in pixels
58     std::string path;                   // Path to the directory where source files are stored
59     std::chrono::nanoseconds interval;  // Interval between two consecutive frames; this is
60                                         // a reciprocal of the framerate
61 };
62 
63 
64 class EvsEmulatedCamera : public IEvsCamera_1_1 {
65 public:
66     // Methods from ::android::hardware::automotive::evs::V1_0::IEvsCamera follow.
67     Return<void>      getCameraInfo(getCameraInfo_cb _hidl_cb)  override;
68     Return<EvsResult> setMaxFramesInFlight(uint32_t bufferCount) override;
69     Return<EvsResult> startVideoStream(const ::android::sp<IEvsCameraStream_1_0>& stream) override;
70     Return<void>      doneWithFrame(const BufferDesc_1_0& buffer) override;
71     Return<void>      stopVideoStream() override;
72     Return<int32_t>   getExtendedInfo(uint32_t opaqueIdentifier) override;
73     Return<EvsResult> setExtendedInfo(uint32_t opaqueIdentifier, int32_t opaqueValue) override;
74 
75     // Methods from ::android::hardware::automotive::evs::V1_1::IEvsCamera follow.
76     Return<void>      getCameraInfo_1_1(getCameraInfo_1_1_cb _hidl_cb)  override;
77     Return<void>      getPhysicalCameraInfo(const hidl_string& deviceId,
78                                             getPhysicalCameraInfo_cb _hidl_cb)  override;
79     Return<EvsResult> pauseVideoStream() override;
80     Return<EvsResult> resumeVideoStream() override;
81     Return<EvsResult> doneWithFrame_1_1(const hidl_vec<BufferDesc_1_1>& buffer) override;
82     Return<EvsResult> setMaster() override;
83     Return<EvsResult> forceMaster(const sp<IEvsDisplay_1_0>&) override;
84     Return<EvsResult> unsetMaster() override;
85     Return<void>      getParameterList(getParameterList_cb _hidl_cb) override;
86     Return<void>      getIntParameterRange(CameraParam id,
87                                            getIntParameterRange_cb _hidl_cb) override;
88     Return<void>      setIntParameter(CameraParam id, int32_t value,
89                                       setIntParameter_cb _hidl_cb) override;
90     Return<void>      getIntParameter(CameraParam id,
91                                       getIntParameter_cb _hidl_cb) override;
92     Return<EvsResult> setExtendedInfo_1_1(uint32_t opaqueIdentifier,
93                                           const hidl_vec<uint8_t>& opaqueValue) override;
94     Return<void>      getExtendedInfo_1_1(uint32_t opaqueIdentifier,
95                                           getExtendedInfo_1_1_cb _hidl_cb) override;
96     Return<void>      importExternalBuffers(const hidl_vec<BufferDesc_1_1>& buffers,
97                                             importExternalBuffers_cb _hidl_cb) override;
98 
99     static sp<EvsEmulatedCamera> Create(const char *deviceName,
100                                         const EmulatedCameraDesc& desc);
101     EvsEmulatedCamera(const EvsEmulatedCamera&) = delete;
102     EvsEmulatedCamera& operator=(const EvsEmulatedCamera&) = delete;
103 
104     virtual ~EvsEmulatedCamera() override;
105     void shutdown();
106 
getDesc()107     const CameraDesc& getDesc() { return mDescription; };
108 
109     bool openDevice();
110 
111 private:
112     // Constructors
113     EvsEmulatedCamera(const char *deviceName,
114                       const EmulatedCameraDesc& desc);
115 
116     // These three functions are expected to be called while mAccessLock is held
117     bool setAvailableFrames_Locked(unsigned bufferCount);
118     unsigned increaseAvailableFrames_Locked(unsigned numToAdd);
119     unsigned decreaseAvailableFrames_Locked(unsigned numToRemove);
120 
121     void forwardFrame(imageBufferDesc* tgt, void* data);
122 
123     sp<IEvsCameraStream_1_1> mStream = nullptr;  // The callback used to deliver each frame
124 
125     sp<VideoCapture> mVideo;        // Virtual video device
126     CameraDesc       mDescription;  // The properties of this camera
127 
128     uint32_t mFormat = 0;           // Values from android_pixel_format_t
129     uint32_t mUsage  = 0;           // Values from from Gralloc.h
130     uint32_t mStride = 0;           // Number of bytes from one row of pixels in memory
131                                     // to the next
132 
133     struct BufferRecord {
134         buffer_handle_t handle;
135         bool inUse;
136 
BufferRecordBufferRecord137         explicit BufferRecord(buffer_handle_t h) : handle(h), inUse(false) {};
138     };
139 
140     std::vector <BufferRecord> mBuffers;  // Graphics buffers to transfer images
141     unsigned mFramesAllowed;              // How many buffers are we currently using
142     unsigned mFramesInUse;                // How many buffers are currently outstanding
143 
144 
145     EvsResult doneWithFrame_impl(const uint32_t id, const buffer_handle_t handle);
146 
147     // Synchronization necessary to deconflict the capture thread from the main service thread
148     // Note that the service interface remains single threaded (ie: not reentrant)
149     std::mutex mAccessLock;
150 
151     // Extended information
152     std::unordered_map<uint32_t, std::vector<uint8_t>> mExtInfo;
153 
154     // Emulated device description
155     EmulatedCameraDesc mCaptureDeviceDesc;
156 };
157 
158 } // namespace implementation
159 } // namespace V1_1
160 } // namespace evs
161 } // namespace automotive
162 } // namespace android
163 
164 #endif  // ANDROID_HARDWARE_AUTOMOTIVE_EVS_V1_1_EVSEMULATEDCAMERA_H
165