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 /* 18 * Contains implementation of a class EmulatedCamera that encapsulates 19 * functionality common to all version 2.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 camera2_device_ops_t API. 23 */ 24 25 //#define LOG_NDEBUG 0 26 #define LOG_TAG "EmulatedCamera2_Camera" 27 #include <cutils/log.h> 28 29 #include "EmulatedCamera2.h" 30 #include "system/camera_metadata.h" 31 32 namespace android { 33 34 /* Constructs EmulatedCamera2 instance. 35 * Param: 36 * cameraId - Zero based camera identifier, which is an index of the camera 37 * instance in camera factory's array. 38 * module - Emulated camera HAL module descriptor. 39 */ 40 EmulatedCamera2::EmulatedCamera2(int cameraId, 41 struct hw_module_t* module): 42 EmulatedBaseCamera(cameraId, 43 CAMERA_DEVICE_API_VERSION_2_0, 44 &common, 45 module) 46 { 47 common.close = EmulatedCamera2::close; 48 ops = &sDeviceOps; 49 priv = this; 50 51 mNotifyCb = NULL; 52 53 mRequestQueueSrc = NULL; 54 mFrameQueueDst = NULL; 55 56 mVendorTagOps.get_camera_vendor_section_name = 57 EmulatedCamera2::get_camera_vendor_section_name; 58 mVendorTagOps.get_camera_vendor_tag_name = 59 EmulatedCamera2::get_camera_vendor_tag_name; 60 mVendorTagOps.get_camera_vendor_tag_type = 61 EmulatedCamera2::get_camera_vendor_tag_type; 62 mVendorTagOps.parent = this; 63 64 mStatusPresent = true; 65 } 66 67 /* Destructs EmulatedCamera2 instance. */ 68 EmulatedCamera2::~EmulatedCamera2() { 69 } 70 71 /**************************************************************************** 72 * Abstract API 73 ***************************************************************************/ 74 75 /**************************************************************************** 76 * Public API 77 ***************************************************************************/ 78 79 status_t EmulatedCamera2::Initialize() { 80 return NO_ERROR; 81 } 82 83 /**************************************************************************** 84 * Camera API implementation 85 ***************************************************************************/ 86 87 status_t EmulatedCamera2::connectCamera(hw_device_t** device) { 88 *device = &common; 89 return NO_ERROR; 90 } 91 92 status_t EmulatedCamera2::closeCamera() { 93 return NO_ERROR; 94 } 95 96 status_t EmulatedCamera2::getCameraInfo(struct camera_info* info) { 97 return EmulatedBaseCamera::getCameraInfo(info); 98 } 99 100 /**************************************************************************** 101 * Camera Device API implementation. 102 * These methods are called from the camera API callback routines. 103 ***************************************************************************/ 104 105 /** Request input queue */ 106 107 int EmulatedCamera2::requestQueueNotify() { 108 return INVALID_OPERATION; 109 } 110 111 /** Count of requests in flight */ 112 int EmulatedCamera2::getInProgressCount() { 113 return INVALID_OPERATION; 114 } 115 116 /** Cancel all captures in flight */ 117 int EmulatedCamera2::flushCapturesInProgress() { 118 return INVALID_OPERATION; 119 } 120 121 /** Construct a default request for a given use case */ 122 int EmulatedCamera2::constructDefaultRequest( 123 int request_template, 124 camera_metadata_t **request) { 125 return INVALID_OPERATION; 126 } 127 128 /** Output stream creation and management */ 129 130 int EmulatedCamera2::allocateStream( 131 uint32_t width, 132 uint32_t height, 133 int format, 134 const camera2_stream_ops_t *stream_ops, 135 uint32_t *stream_id, 136 uint32_t *format_actual, 137 uint32_t *usage, 138 uint32_t *max_buffers) { 139 return INVALID_OPERATION; 140 } 141 142 int EmulatedCamera2::registerStreamBuffers( 143 uint32_t stream_id, 144 int num_buffers, 145 buffer_handle_t *buffers) { 146 return INVALID_OPERATION; 147 } 148 149 150 int EmulatedCamera2::releaseStream(uint32_t stream_id) { 151 return INVALID_OPERATION; 152 } 153 154 /** Reprocessing input stream management */ 155 156 int EmulatedCamera2::allocateReprocessStream( 157 uint32_t width, 158 uint32_t height, 159 uint32_t format, 160 const camera2_stream_in_ops_t *reprocess_stream_ops, 161 uint32_t *stream_id, 162 uint32_t *consumer_usage, 163 uint32_t *max_buffers) { 164 return INVALID_OPERATION; 165 } 166 167 int EmulatedCamera2::allocateReprocessStreamFromStream( 168 uint32_t output_stream_id, 169 const camera2_stream_in_ops_t *reprocess_stream_ops, 170 uint32_t *stream_id) { 171 return INVALID_OPERATION; 172 } 173 174 int EmulatedCamera2::releaseReprocessStream(uint32_t stream_id) { 175 return INVALID_OPERATION; 176 } 177 178 /** 3A triggering */ 179 180 int EmulatedCamera2::triggerAction(uint32_t trigger_id, 181 int ext1, int ext2) { 182 return INVALID_OPERATION; 183 } 184 185 /** Custom tag query methods */ 186 187 const char* EmulatedCamera2::getVendorSectionName(uint32_t tag) { 188 return NULL; 189 } 190 191 const char* EmulatedCamera2::getVendorTagName(uint32_t tag) { 192 return NULL; 193 } 194 195 int EmulatedCamera2::getVendorTagType(uint32_t tag) { 196 return -1; 197 } 198 199 /** Debug methods */ 200 201 int EmulatedCamera2::dump(int fd) { 202 return INVALID_OPERATION; 203 } 204 205 /**************************************************************************** 206 * Private API. 207 ***************************************************************************/ 208 209 /**************************************************************************** 210 * Camera API callbacks as defined by camera2_device_ops structure. See 211 * hardware/libhardware/include/hardware/camera2.h for information on each 212 * of these callbacks. Implemented in this class, these callbacks simply 213 * dispatch the call into an instance of EmulatedCamera2 class defined by the 214 * 'camera_device2' parameter, or set a member value in the same. 215 ***************************************************************************/ 216 217 EmulatedCamera2* getInstance(const camera2_device_t *d) { 218 const EmulatedCamera2* cec = static_cast<const EmulatedCamera2*>(d); 219 return const_cast<EmulatedCamera2*>(cec); 220 } 221 222 int EmulatedCamera2::set_request_queue_src_ops(const camera2_device_t *d, 223 const camera2_request_queue_src_ops *queue_src_ops) { 224 EmulatedCamera2* ec = getInstance(d); 225 ec->mRequestQueueSrc = queue_src_ops; 226 return NO_ERROR; 227 } 228 229 int EmulatedCamera2::notify_request_queue_not_empty(const camera2_device_t *d) { 230 EmulatedCamera2* ec = getInstance(d); 231 return ec->requestQueueNotify(); 232 } 233 234 int EmulatedCamera2::set_frame_queue_dst_ops(const camera2_device_t *d, 235 const camera2_frame_queue_dst_ops *queue_dst_ops) { 236 EmulatedCamera2* ec = getInstance(d); 237 ec->mFrameQueueDst = queue_dst_ops; 238 return NO_ERROR; 239 } 240 241 int EmulatedCamera2::get_in_progress_count(const camera2_device_t *d) { 242 EmulatedCamera2* ec = getInstance(d); 243 return ec->getInProgressCount(); 244 } 245 246 int EmulatedCamera2::flush_captures_in_progress(const camera2_device_t *d) { 247 EmulatedCamera2* ec = getInstance(d); 248 return ec->flushCapturesInProgress(); 249 } 250 251 int EmulatedCamera2::construct_default_request(const camera2_device_t *d, 252 int request_template, 253 camera_metadata_t **request) { 254 EmulatedCamera2* ec = getInstance(d); 255 return ec->constructDefaultRequest(request_template, request); 256 } 257 258 int EmulatedCamera2::allocate_stream(const camera2_device_t *d, 259 uint32_t width, 260 uint32_t height, 261 int format, 262 const camera2_stream_ops_t *stream_ops, 263 uint32_t *stream_id, 264 uint32_t *format_actual, 265 uint32_t *usage, 266 uint32_t *max_buffers) { 267 EmulatedCamera2* ec = getInstance(d); 268 return ec->allocateStream(width, height, format, stream_ops, 269 stream_id, format_actual, usage, max_buffers); 270 } 271 272 int EmulatedCamera2::register_stream_buffers(const camera2_device_t *d, 273 uint32_t stream_id, 274 int num_buffers, 275 buffer_handle_t *buffers) { 276 EmulatedCamera2* ec = getInstance(d); 277 return ec->registerStreamBuffers(stream_id, 278 num_buffers, 279 buffers); 280 } 281 int EmulatedCamera2::release_stream(const camera2_device_t *d, 282 uint32_t stream_id) { 283 EmulatedCamera2* ec = getInstance(d); 284 return ec->releaseStream(stream_id); 285 } 286 287 int EmulatedCamera2::allocate_reprocess_stream(const camera2_device_t *d, 288 uint32_t width, 289 uint32_t height, 290 uint32_t format, 291 const camera2_stream_in_ops_t *reprocess_stream_ops, 292 uint32_t *stream_id, 293 uint32_t *consumer_usage, 294 uint32_t *max_buffers) { 295 EmulatedCamera2* ec = getInstance(d); 296 return ec->allocateReprocessStream(width, height, format, 297 reprocess_stream_ops, stream_id, consumer_usage, max_buffers); 298 } 299 300 int EmulatedCamera2::allocate_reprocess_stream_from_stream( 301 const camera2_device_t *d, 302 uint32_t output_stream_id, 303 const camera2_stream_in_ops_t *reprocess_stream_ops, 304 uint32_t *stream_id) { 305 EmulatedCamera2* ec = getInstance(d); 306 return ec->allocateReprocessStreamFromStream(output_stream_id, 307 reprocess_stream_ops, stream_id); 308 } 309 310 311 int EmulatedCamera2::release_reprocess_stream(const camera2_device_t *d, 312 uint32_t stream_id) { 313 EmulatedCamera2* ec = getInstance(d); 314 return ec->releaseReprocessStream(stream_id); 315 } 316 317 int EmulatedCamera2::trigger_action(const camera2_device_t *d, 318 uint32_t trigger_id, 319 int ext1, 320 int ext2) { 321 EmulatedCamera2* ec = getInstance(d); 322 return ec->triggerAction(trigger_id, ext1, ext2); 323 } 324 325 int EmulatedCamera2::set_notify_callback(const camera2_device_t *d, 326 camera2_notify_callback notify_cb, void* user) { 327 EmulatedCamera2* ec = getInstance(d); 328 Mutex::Autolock l(ec->mMutex); 329 ec->mNotifyCb = notify_cb; 330 ec->mNotifyUserPtr = user; 331 return NO_ERROR; 332 } 333 334 int EmulatedCamera2::get_metadata_vendor_tag_ops(const camera2_device_t *d, 335 vendor_tag_query_ops_t **ops) { 336 EmulatedCamera2* ec = getInstance(d); 337 *ops = static_cast<vendor_tag_query_ops_t*>( 338 &ec->mVendorTagOps); 339 return NO_ERROR; 340 } 341 342 const char* EmulatedCamera2::get_camera_vendor_section_name( 343 const vendor_tag_query_ops_t *v, 344 uint32_t tag) { 345 EmulatedCamera2* ec = static_cast<const TagOps*>(v)->parent; 346 return ec->getVendorSectionName(tag); 347 } 348 349 const char* EmulatedCamera2::get_camera_vendor_tag_name( 350 const vendor_tag_query_ops_t *v, 351 uint32_t tag) { 352 EmulatedCamera2* ec = static_cast<const TagOps*>(v)->parent; 353 return ec->getVendorTagName(tag); 354 } 355 356 int EmulatedCamera2::get_camera_vendor_tag_type( 357 const vendor_tag_query_ops_t *v, 358 uint32_t tag) { 359 EmulatedCamera2* ec = static_cast<const TagOps*>(v)->parent; 360 return ec->getVendorTagType(tag); 361 } 362 363 int EmulatedCamera2::dump(const camera2_device_t *d, int fd) { 364 EmulatedCamera2* ec = getInstance(d); 365 return ec->dump(fd); 366 } 367 368 int EmulatedCamera2::close(struct hw_device_t* device) { 369 EmulatedCamera2* ec = 370 static_cast<EmulatedCamera2*>( 371 reinterpret_cast<camera2_device_t*>(device) ); 372 if (ec == NULL) { 373 ALOGE("%s: Unexpected NULL camera2 device", __FUNCTION__); 374 return -EINVAL; 375 } 376 return ec->closeCamera(); 377 } 378 379 void EmulatedCamera2::sendNotification(int32_t msgType, 380 int32_t ext1, int32_t ext2, int32_t ext3) { 381 camera2_notify_callback notifyCb; 382 { 383 Mutex::Autolock l(mMutex); 384 notifyCb = mNotifyCb; 385 } 386 if (notifyCb != NULL) { 387 notifyCb(msgType, ext1, ext2, ext3, mNotifyUserPtr); 388 } 389 } 390 391 camera2_device_ops_t EmulatedCamera2::sDeviceOps = { 392 EmulatedCamera2::set_request_queue_src_ops, 393 EmulatedCamera2::notify_request_queue_not_empty, 394 EmulatedCamera2::set_frame_queue_dst_ops, 395 EmulatedCamera2::get_in_progress_count, 396 EmulatedCamera2::flush_captures_in_progress, 397 EmulatedCamera2::construct_default_request, 398 EmulatedCamera2::allocate_stream, 399 EmulatedCamera2::register_stream_buffers, 400 EmulatedCamera2::release_stream, 401 EmulatedCamera2::allocate_reprocess_stream, 402 EmulatedCamera2::allocate_reprocess_stream_from_stream, 403 EmulatedCamera2::release_reprocess_stream, 404 EmulatedCamera2::trigger_action, 405 EmulatedCamera2::set_notify_callback, 406 EmulatedCamera2::get_metadata_vendor_tag_ops, 407 EmulatedCamera2::dump 408 }; 409 410 }; /* namespace android */ 411
