src/type3_AndroidCloud/anbox-master/android/camera/EmulatedCamera2.cpp

   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 */