• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2013 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 /**
18  * Contains implementation of a class EmulatedCamera that encapsulates
19  * functionality common to all version 3.0 emulated camera devices.  Instances
20  * of this class (for each emulated camera) are created during the construction
21  * of the EmulatedCameraFactory instance.  This class serves as an entry point
22  * for all camera API calls that defined by camera3_device_ops_t API.
23  */
24 
25 #define LOG_NDEBUG 0
26 #define LOG_TAG "EmulatedCamera3_Camera"
27 #include <log/log.h>
28 
29 #include "EmulatedCamera3.h"
30 #include "system/camera_metadata.h"
31 
32 namespace android {
33 
34 /**
35  * Constructs EmulatedCamera3 instance.
36  * Param:
37  *  cameraId - Zero based camera identifier, which is an index of the camera
38  *      instance in camera factory's array.
39  *  module - Emulated camera HAL module descriptor.
40  */
EmulatedCamera3(int cameraId,struct hw_module_t * module)41 EmulatedCamera3::EmulatedCamera3(int cameraId, struct hw_module_t* module)
42     : EmulatedBaseCamera(cameraId, CAMERA_DEVICE_API_VERSION_3_3, &common,
43                          module),
44       mStatus(STATUS_ERROR) {
45   common.close = EmulatedCamera3::close;
46   ops = &sDeviceOps;
47 
48   mCallbackOps = NULL;
49 }
50 
51 /* Destructs EmulatedCamera3 instance. */
~EmulatedCamera3()52 EmulatedCamera3::~EmulatedCamera3() {}
53 
54 /****************************************************************************
55  * Abstract API
56  ***************************************************************************/
57 
58 /****************************************************************************
59  * Public API
60  ***************************************************************************/
61 
Initialize(const cvd::CameraDefinition &)62 status_t EmulatedCamera3::Initialize(const cvd::CameraDefinition& /*params*/) {
63   ALOGV("%s", __FUNCTION__);
64 
65   mStatus = STATUS_CLOSED;
66   return NO_ERROR;
67 }
68 
69 /****************************************************************************
70  * Camera API implementation
71  ***************************************************************************/
72 
connectCamera(hw_device_t ** device)73 status_t EmulatedCamera3::connectCamera(hw_device_t** device) {
74   ALOGV("%s", __FUNCTION__);
75   if (device == NULL) return BAD_VALUE;
76 
77   if (mStatus != STATUS_CLOSED) {
78     ALOGE("%s: Trying to open a camera in state %d!", __FUNCTION__, mStatus);
79     return INVALID_OPERATION;
80   }
81 
82   *device = &common;
83   mStatus = STATUS_OPEN;
84   return NO_ERROR;
85 }
86 
closeCamera()87 status_t EmulatedCamera3::closeCamera() {
88   mStatus = STATUS_CLOSED;
89   return NO_ERROR;
90 }
91 
getCameraInfo(struct camera_info * info)92 status_t EmulatedCamera3::getCameraInfo(struct camera_info* info) {
93   return EmulatedBaseCamera::getCameraInfo(info);
94 }
95 
96 /****************************************************************************
97  * Camera Device API implementation.
98  * These methods are called from the camera API callback routines.
99  ***************************************************************************/
100 
initializeDevice(const camera3_callback_ops * callbackOps)101 status_t EmulatedCamera3::initializeDevice(
102     const camera3_callback_ops* callbackOps) {
103   if (callbackOps == NULL) {
104     ALOGE("%s: NULL callback ops provided to HAL!", __FUNCTION__);
105     return BAD_VALUE;
106   }
107 
108   if (mStatus != STATUS_OPEN) {
109     ALOGE("%s: Trying to initialize a camera in state %d!", __FUNCTION__,
110           mStatus);
111     return INVALID_OPERATION;
112   }
113 
114   mCallbackOps = callbackOps;
115   mStatus = STATUS_READY;
116 
117   return NO_ERROR;
118 }
119 
configureStreams(camera3_stream_configuration *)120 status_t EmulatedCamera3::configureStreams(
121     camera3_stream_configuration* /*streamList*/) {
122   ALOGE("%s: Not implemented", __FUNCTION__);
123   return INVALID_OPERATION;
124 }
125 
registerStreamBuffers(const camera3_stream_buffer_set *)126 status_t EmulatedCamera3::registerStreamBuffers(
127     const camera3_stream_buffer_set* /*bufferSet*/) {
128   ALOGE("%s: Not implemented", __FUNCTION__);
129   return INVALID_OPERATION;
130 }
131 
constructDefaultRequestSettings(int)132 const camera_metadata_t* EmulatedCamera3::constructDefaultRequestSettings(
133     int /*type*/) {
134   ALOGE("%s: Not implemented", __FUNCTION__);
135   return NULL;
136 }
137 
processCaptureRequest(camera3_capture_request *)138 status_t EmulatedCamera3::processCaptureRequest(
139     camera3_capture_request* /*request*/) {
140   ALOGE("%s: Not implemented", __FUNCTION__);
141   return INVALID_OPERATION;
142 }
143 
flush()144 status_t EmulatedCamera3::flush() {
145   ALOGE("%s: Not implemented", __FUNCTION__);
146   return INVALID_OPERATION;
147 }
148 
149 /** Debug methods */
150 
dump(int)151 void EmulatedCamera3::dump(int /*fd*/) {
152   ALOGE("%s: Not implemented", __FUNCTION__);
153   return;
154 }
155 
156 /****************************************************************************
157  * Protected API. Callbacks to the framework.
158  ***************************************************************************/
159 
sendCaptureResult(camera3_capture_result_t * result)160 void EmulatedCamera3::sendCaptureResult(camera3_capture_result_t* result) {
161   mCallbackOps->process_capture_result(mCallbackOps, result);
162 }
163 
sendNotify(camera3_notify_msg_t * msg)164 void EmulatedCamera3::sendNotify(camera3_notify_msg_t* msg) {
165   mCallbackOps->notify(mCallbackOps, msg);
166 }
167 
168 /****************************************************************************
169  * Private API.
170  ***************************************************************************/
171 
172 /****************************************************************************
173  * Camera API callbacks as defined by camera3_device_ops structure.  See
174  * hardware/libhardware/include/hardware/camera3.h for information on each
175  * of these callbacks. Implemented in this class, these callbacks simply
176  * dispatch the call into an instance of EmulatedCamera3 class defined by the
177  * 'camera_device3' parameter, or set a member value in the same.
178  ***************************************************************************/
179 
getInstance(const camera3_device_t * d)180 EmulatedCamera3* getInstance(const camera3_device_t* d) {
181   const EmulatedCamera3* cec = static_cast<const EmulatedCamera3*>(d);
182   return const_cast<EmulatedCamera3*>(cec);
183 }
184 
initialize(const struct camera3_device * d,const camera3_callback_ops_t * callback_ops)185 int EmulatedCamera3::initialize(const struct camera3_device* d,
186                                 const camera3_callback_ops_t* callback_ops) {
187   EmulatedCamera3* ec = getInstance(d);
188   return ec->initializeDevice(callback_ops);
189 }
190 
configure_streams(const struct camera3_device * d,camera3_stream_configuration_t * stream_list)191 int EmulatedCamera3::configure_streams(
192     const struct camera3_device* d,
193     camera3_stream_configuration_t* stream_list) {
194   EmulatedCamera3* ec = getInstance(d);
195   return ec->configureStreams(stream_list);
196 }
197 
register_stream_buffers(const struct camera3_device * d,const camera3_stream_buffer_set_t * buffer_set)198 int EmulatedCamera3::register_stream_buffers(
199     const struct camera3_device* d,
200     const camera3_stream_buffer_set_t* buffer_set) {
201   EmulatedCamera3* ec = getInstance(d);
202   return ec->registerStreamBuffers(buffer_set);
203 }
204 
process_capture_request(const struct camera3_device * d,camera3_capture_request_t * request)205 int EmulatedCamera3::process_capture_request(
206     const struct camera3_device* d, camera3_capture_request_t* request) {
207   EmulatedCamera3* ec = getInstance(d);
208   return ec->processCaptureRequest(request);
209 }
210 
construct_default_request_settings(const camera3_device_t * d,int type)211 const camera_metadata_t* EmulatedCamera3::construct_default_request_settings(
212     const camera3_device_t* d, int type) {
213   EmulatedCamera3* ec = getInstance(d);
214   return ec->constructDefaultRequestSettings(type);
215 }
216 
dump(const camera3_device_t * d,int fd)217 void EmulatedCamera3::dump(const camera3_device_t* d, int fd) {
218   EmulatedCamera3* ec = getInstance(d);
219   ec->dump(fd);
220 }
221 
flush(const camera3_device_t * d)222 int EmulatedCamera3::flush(const camera3_device_t* d) {
223   EmulatedCamera3* ec = getInstance(d);
224   return ec->flush();
225 }
226 
close(struct hw_device_t * device)227 int EmulatedCamera3::close(struct hw_device_t* device) {
228   EmulatedCamera3* ec = static_cast<EmulatedCamera3*>(
229       reinterpret_cast<camera3_device_t*>(device));
230   if (ec == NULL) {
231     ALOGE("%s: Unexpected NULL camera3 device", __FUNCTION__);
232     return BAD_VALUE;
233   }
234   return ec->closeCamera();
235 }
236 
237 camera3_device_ops_t EmulatedCamera3::sDeviceOps = {
238     EmulatedCamera3::initialize,
239     EmulatedCamera3::configure_streams,
240     /* DEPRECATED: register_stream_buffers */ nullptr,
241     EmulatedCamera3::construct_default_request_settings,
242     EmulatedCamera3::process_capture_request,
243     /* DEPRECATED: get_metadata_vendor_tag_ops */ nullptr,
244     EmulatedCamera3::dump,
245     EmulatedCamera3::flush,
246 #ifdef CAMERA_DEVICE_API_VERSION_3_6
247     /*UNUSED: signal_stream_flush*/nullptr,
248     /*UNUSED: is_reconfiguration_required*/nullptr,
249 #endif
250     {0}};
251 
252 const char* EmulatedCamera3::sAvailableCapabilitiesStrings[NUM_CAPABILITIES] = {
253     "BACKWARD_COMPATIBLE",
254     "MANUAL_SENSOR",
255     "MANUAL_POST_PROCESSING",
256     "RAW",
257     "PRIVATE_REPROCESSING",
258     "READ_SENSOR_SETTINGS",
259     "BURST_CAPTURE",
260     "YUV_REPROCESSING",
261     "DEPTH_OUTPUT",
262     "CONSTRAINED_HIGH_SPEED_VIDEO",
263     "FULL_LEVEL"};
264 
265 }; /* namespace android */
266