summaryrefslogtreecommitdiff
path: root/v3/EmulatedCamera2.h (plain)
blob: 9f5f67ba5ead2dc07a0a227f0f3546073ff6af6c
1/*
2 * Copyright (C) 2012 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 HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H
18#define HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H
19
20/*
21 * Contains declaration of a class EmulatedCamera that encapsulates
22 * functionality common to all version 2.0 emulated camera devices. Instances
23 * of this class (for each emulated camera) are created during the construction
24 * of the EmulatedCameraFactory instance. This class serves as an entry point
25 * for all camera API calls that defined by camera2_device_ops_t API.
26 */
27
28#include "hardware/camera2.h"
29#include "system/camera_metadata.h"
30#include "EmulatedBaseCamera.h"
31#include <utils/Thread.h>
32#include <utils/Mutex.h>
33
34namespace android {
35
36/* Encapsulates functionality common to all version 2.0 emulated camera devices
37 *
38 * Note that EmulatedCameraFactory instantiates object of this class just once,
39 * when EmulatedCameraFactory instance gets constructed. Connection to /
40 * disconnection from the actual camera device is handled by calls to
41 * connectDevice(), and closeCamera() methods of this class that are invoked in
42 * response to hw_module_methods_t::open, and camera_device::close callbacks.
43 */
44class EmulatedCamera2 : public camera2_device, public EmulatedBaseCamera {
45public:
46 /* Constructs EmulatedCamera2 instance.
47 * Param:
48 * cameraId - Zero based camera identifier, which is an index of the camera
49 * instance in camera factory's array.
50 * module - Emulated camera HAL module descriptor.
51 */
52 EmulatedCamera2(int cameraId,
53 struct hw_module_t* module);
54
55 /* Destructs EmulatedCamera2 instance. */
56 virtual ~EmulatedCamera2();
57
58 /****************************************************************************
59 * Abstract API
60 ***************************************************************************/
61
62public:
63
64 /****************************************************************************
65 * Public API
66 ***************************************************************************/
67
68public:
69 virtual status_t Initialize();
70
71 /****************************************************************************
72 * Camera module API and generic hardware device API implementation
73 ***************************************************************************/
74
75public:
76 virtual status_t connectCamera(hw_device_t** device);
77
78 virtual status_t closeCamera();
79
80 virtual status_t getCameraInfo(struct camera_info* info) = 0;
81
82 /****************************************************************************
83 * Camera API implementation.
84 * These methods are called from the camera API callback routines.
85 ***************************************************************************/
86
87protected:
88 /** Request input queue notification */
89 virtual int requestQueueNotify();
90
91 /** Count of requests in flight */
92 virtual int getInProgressCount();
93
94 /** Cancel all captures in flight */
95 virtual int flushCapturesInProgress();
96
97 virtual int constructDefaultRequest(
98 int request_template,
99 camera_metadata_t **request);
100
101 /** Output stream creation and management */
102 virtual int allocateStream(
103 uint32_t width,
104 uint32_t height,
105 int format,
106 const camera2_stream_ops_t *stream_ops,
107 uint32_t *stream_id,
108 uint32_t *format_actual,
109 uint32_t *usage,
110 uint32_t *max_buffers);
111
112 virtual int registerStreamBuffers(
113 uint32_t stream_id,
114 int num_buffers,
115 buffer_handle_t *buffers);
116
117 virtual int releaseStream(uint32_t stream_id);
118
119 /** Input stream creation and management */
120 virtual int allocateReprocessStream(
121 uint32_t width,
122 uint32_t height,
123 uint32_t format,
124 const camera2_stream_in_ops_t *reprocess_stream_ops,
125 uint32_t *stream_id,
126 uint32_t *consumer_usage,
127 uint32_t *max_buffers);
128
129 virtual int allocateReprocessStreamFromStream(
130 uint32_t output_stream_id,
131 const camera2_stream_in_ops_t *reprocess_stream_ops,
132 uint32_t *stream_id);
133
134 virtual int releaseReprocessStream(uint32_t stream_id);
135
136 /** 3A action triggering */
137 virtual int triggerAction(uint32_t trigger_id,
138 int32_t ext1, int32_t ext2);
139
140 /** Custom tag definitions */
141 virtual const char* getVendorSectionName(uint32_t tag);
142 virtual const char* getVendorTagName(uint32_t tag);
143 virtual int getVendorTagType(uint32_t tag);
144
145 /** Debug methods */
146
147 virtual int dump(int fd);
148
149 /****************************************************************************
150 * Camera API callbacks as defined by camera2_device_ops structure. See
151 * hardware/libhardware/include/hardware/camera2.h for information on each
152 * of these callbacks. Implemented in this class, these callbacks simply
153 * dispatch the call into an instance of EmulatedCamera2 class defined in
154 * the 'camera_device2' parameter.
155 ***************************************************************************/
156
157private:
158 /** Input request queue */
159 static int set_request_queue_src_ops(const camera2_device_t *,
160 const camera2_request_queue_src_ops *queue_src_ops);
161 static int notify_request_queue_not_empty(const camera2_device_t *);
162
163 /** Output frame queue */
164 static int set_frame_queue_dst_ops(const camera2_device_t *,
165 const camera2_frame_queue_dst_ops *queue_dst_ops);
166
167 /** In-progress request management */
168 static int get_in_progress_count(const camera2_device_t *);
169
170 static int flush_captures_in_progress(const camera2_device_t *);
171
172 /** Request template creation */
173 static int construct_default_request(const camera2_device_t *,
174 int request_template,
175 camera_metadata_t **request);
176
177 /** Stream management */
178 static int allocate_stream(const camera2_device_t *,
179 uint32_t width,
180 uint32_t height,
181 int format,
182 const camera2_stream_ops_t *stream_ops,
183 uint32_t *stream_id,
184 uint32_t *format_actual,
185 uint32_t *usage,
186 uint32_t *max_buffers);
187
188 static int register_stream_buffers(const camera2_device_t *,
189 uint32_t stream_id,
190 int num_buffers,
191 buffer_handle_t *buffers);
192
193 static int release_stream(const camera2_device_t *,
194 uint32_t stream_id);
195
196 static int allocate_reprocess_stream(const camera2_device_t *,
197 uint32_t width,
198 uint32_t height,
199 uint32_t format,
200 const camera2_stream_in_ops_t *reprocess_stream_ops,
201 uint32_t *stream_id,
202 uint32_t *consumer_usage,
203 uint32_t *max_buffers);
204
205 static int allocate_reprocess_stream_from_stream(const camera2_device_t *,
206 uint32_t output_stream_id,
207 const camera2_stream_in_ops_t *reprocess_stream_ops,
208 uint32_t *stream_id);
209
210 static int release_reprocess_stream(const camera2_device_t *,
211 uint32_t stream_id);
212
213 /** 3A triggers*/
214 static int trigger_action(const camera2_device_t *,
215 uint32_t trigger_id,
216 int ext1,
217 int ext2);
218
219 /** Notifications to application */
220 static int set_notify_callback(const camera2_device_t *,
221 camera2_notify_callback notify_cb,
222 void *user);
223
224 /** Vendor metadata registration */
225 static int get_metadata_vendor_tag_ops(const camera2_device_t *,
226 vendor_tag_query_ops_t **ops);
227 // for get_metadata_vendor_tag_ops
228 static const char* get_camera_vendor_section_name(
229 const vendor_tag_query_ops_t *,
230 uint32_t tag);
231 static const char* get_camera_vendor_tag_name(
232 const vendor_tag_query_ops_t *,
233 uint32_t tag);
234 static int get_camera_vendor_tag_type(
235 const vendor_tag_query_ops_t *,
236 uint32_t tag);
237
238 static int dump(const camera2_device_t *, int fd);
239
240 /** For hw_device_t ops */
241 static int close(struct hw_device_t* device);
242
243 /****************************************************************************
244 * Data members shared with implementations
245 ***************************************************************************/
246 protected:
247 /** Mutex for calls through camera2 device interface */
248 Mutex mMutex;
249
250 bool mStatusPresent;
251
252 const camera2_request_queue_src_ops *mRequestQueueSrc;
253 const camera2_frame_queue_dst_ops *mFrameQueueDst;
254
255 struct TagOps : public vendor_tag_query_ops {
256 EmulatedCamera2 *parent;
257 };
258 TagOps mVendorTagOps;
259
260 void sendNotification(int32_t msgType,
261 int32_t ext1, int32_t ext2, int32_t ext3);
262
263 /****************************************************************************
264 * Data members
265 ***************************************************************************/
266 private:
267 static camera2_device_ops_t sDeviceOps;
268 camera2_notify_callback mNotifyCb;
269 void* mNotifyUserPtr;
270};
271
272}; /* namespace android */
273
274#endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H */
275
generated by cgit at 2024-05-18 20:27:27 (GMT)