From 0819e42a0b8c0da6db7a8267d067f235d060e37f Mon Sep 17 00:00:00 2001 From: Eino-Ville Talvala Date: Wed, 28 Mar 2012 19:44:38 -0700 Subject: [PATCH] Add skeleton implementation of a fake v2 camera device. Change-Id: Idd2485064548a6036ea318680065b7429463d9cd --- tools/emulator/system/camera/Android.mk | 12 +- .../system/camera/EmulatedCamera2.cpp | 528 ++++++++++++++++++ .../emulator/system/camera/EmulatedCamera2.h | 305 ++++++++++ .../system/camera/EmulatedCameraFactory.cpp | 75 ++- .../system/camera/EmulatedCameraFactory.h | 6 + .../system/camera/EmulatedFakeCamera2.cpp | 54 ++ .../system/camera/EmulatedFakeCamera2.h | 67 +++ .../system/camera/EmulatedQemuCamera2.cpp | 55 ++ .../system/camera/EmulatedQemuCamera2.h | 66 +++ 9 files changed, 1158 insertions(+), 10 deletions(-) create mode 100644 tools/emulator/system/camera/EmulatedCamera2.cpp create mode 100644 tools/emulator/system/camera/EmulatedCamera2.h create mode 100644 tools/emulator/system/camera/EmulatedFakeCamera2.cpp create mode 100644 tools/emulator/system/camera/EmulatedFakeCamera2.h create mode 100644 tools/emulator/system/camera/EmulatedQemuCamera2.cpp create mode 100644 tools/emulator/system/camera/EmulatedQemuCamera2.h diff --git a/tools/emulator/system/camera/Android.mk b/tools/emulator/system/camera/Android.mk index 61e1e830d..c51f6212e 100755 --- a/tools/emulator/system/camera/Android.mk +++ b/tools/emulator/system/camera/Android.mk @@ -35,9 +35,10 @@ LOCAL_SHARED_LIBRARIES += \ libandroid_runtime \ LOCAL_C_INCLUDES += external/jpeg \ - external/skia/include/core/ \ - frameworks/native/include/media/hardware \ - frameworks/base/core/jni/android/graphics + external/skia/include/core/ \ + frameworks/native/include/media/hardware \ + frameworks/base/core/jni/android/graphics \ + $(call include-path-for, camera) LOCAL_SRC_FILES := \ EmulatedCameraHal.cpp \ @@ -53,7 +54,10 @@ LOCAL_SRC_FILES := \ PreviewWindow.cpp \ CallbackNotifier.cpp \ QemuClient.cpp \ - JpegCompressor.cpp + JpegCompressor.cpp \ + EmulatedCamera2.cpp \ + EmulatedFakeCamera2.cpp \ + EmulatedQemuCamera2.cpp ifeq ($(TARGET_PRODUCT),vbox_x86) LOCAL_MODULE := camera.vbox_x86 diff --git a/tools/emulator/system/camera/EmulatedCamera2.cpp b/tools/emulator/system/camera/EmulatedCamera2.cpp new file mode 100644 index 000000000..f7672f430 --- /dev/null +++ b/tools/emulator/system/camera/EmulatedCamera2.cpp @@ -0,0 +1,528 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Contains implementation of a class EmulatedCamera that encapsulates + * functionality common to all version 2.0 emulated camera devices. Instances + * of this class (for each emulated camera) are created during the construction + * of the EmulatedCameraFactory instance. This class serves as an entry point + * for all camera API calls that defined by camera2_device_ops_t API. + */ + +#define LOG_NDEBUG 0 +#define LOG_TAG "EmulatedCamera2_Camera" +#include + +#include "EmulatedCamera2.h" +#include "system/camera_metadata.h" + +namespace android { + +/* Constructs EmulatedCamera2 instance. + * Param: + * cameraId - Zero based camera identifier, which is an index of the camera + * instance in camera factory's array. + * module - Emulated camera HAL module descriptor. + */ +EmulatedCamera2::EmulatedCamera2(int cameraId, + struct hw_module_t* module): + EmulatedBaseCamera(cameraId, + CAMERA_DEVICE_API_VERSION_2_0, + &common, + module) +{ + common.close = EmulatedCamera2::close; + ops = &sDeviceOps; + priv = this; + + mRequestQueueDstOps.notify_queue_not_empty = + EmulatedCamera2::request_queue_notify_queue_not_empty; + mRequestQueueDstOps.parent = this; + + mRequestQueueDstOps.notify_queue_not_empty = + EmulatedCamera2::reprocess_queue_notify_queue_not_empty; + mReprocessQueueDstOps.parent = this; + + mFrameQueueSrcOps.buffer_count = EmulatedCamera2::frame_queue_buffer_count; + mFrameQueueSrcOps.dequeue = EmulatedCamera2::frame_queue_dequeue; + mFrameQueueSrcOps.free = EmulatedCamera2::frame_queue_free; + mFrameQueueSrcOps.parent = this; + + mReprocessStreamOps.dequeue_buffer = + EmulatedCamera2::reprocess_stream_dequeue_buffer; + mReprocessStreamOps.enqueue_buffer = + EmulatedCamera2::reprocess_stream_enqueue_buffer; + mReprocessStreamOps.cancel_buffer = + EmulatedCamera2::reprocess_stream_cancel_buffer; + mReprocessStreamOps.set_buffer_count = + EmulatedCamera2::reprocess_stream_set_buffer_count; + mReprocessStreamOps.set_crop = EmulatedCamera2::reprocess_stream_set_crop; + mReprocessStreamOps.set_timestamp = + EmulatedCamera2::reprocess_stream_set_timestamp; + mReprocessStreamOps.set_usage = EmulatedCamera2::reprocess_stream_set_usage; + mReprocessStreamOps.get_min_undequeued_buffer_count = + EmulatedCamera2::reprocess_stream_get_min_undequeued_buffer_count; + mReprocessStreamOps.lock_buffer = + EmulatedCamera2::reprocess_stream_lock_buffer; + mReprocessStreamOps.parent = this; + + mVendorTagOps.get_camera_vendor_section_name = + EmulatedCamera2::get_camera_vendor_section_name; + mVendorTagOps.get_camera_vendor_tag_name = + EmulatedCamera2::get_camera_vendor_tag_name; + mVendorTagOps.get_camera_vendor_tag_type = + EmulatedCamera2::get_camera_vendor_tag_type; + mVendorTagOps.parent = this; +} + +/* Destructs EmulatedCamera2 instance. */ +EmulatedCamera2::~EmulatedCamera2() { +} + +/**************************************************************************** + * Abstract API + ***************************************************************************/ + +/**************************************************************************** + * Public API + ***************************************************************************/ + +status_t EmulatedCamera2::Initialize() { + return NO_ERROR; +} + +/**************************************************************************** + * Camera API implementation + ***************************************************************************/ + +status_t EmulatedCamera2::connectCamera(hw_device_t** device) { + return NO_ERROR; +} + +status_t EmulatedCamera2::closeCamera() { + return NO_ERROR; +} + +status_t EmulatedCamera2::getCameraInfo(struct camera_info* info) { + + return EmulatedBaseCamera::getCameraInfo(info); +} + +/**************************************************************************** + * Camera API implementation. + * These methods are called from the camera API callback routines. + ***************************************************************************/ + +/** Request input queue */ + +int EmulatedCamera2::setRequestQueueSrcOps( + camera2_metadata_queue_src_ops *request_queue_src_ops) { + return NO_ERROR; +} + +int EmulatedCamera2::requestQueueNotifyNotEmpty() { + return NO_ERROR; +} + +/** Reprocessing input queue */ + +int EmulatedCamera2::setReprocessQueueSrcOps( + camera2_metadata_queue_src_ops *reprocess_queue_src_ops) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessQueueNotifyNotEmpty() { + return NO_ERROR; +} + +/** Frame output queue */ + +int EmulatedCamera2::setFrameQueueDstOps(camera2_metadata_queue_dst_ops *frame_queue_dst_ops) { + return NO_ERROR; +} + +int EmulatedCamera2::frameQueueBufferCount() { + return NO_ERROR; +} +int EmulatedCamera2::frameQueueDequeue(camera_metadata_t **buffer) { + return NO_ERROR; +} +int EmulatedCamera2::frameQueueFree(camera_metadata_t *old_buffer) { + return NO_ERROR; +} + +/** Notifications to application */ +int EmulatedCamera2::setNotifyCallback(camera2_notify_callback notify_cb) { + return NO_ERROR; +} + +/** Count of requests in flight */ +int EmulatedCamera2::getInProgressCount() { + return NO_ERROR; +} + +/** Cancel all captures in flight */ +int EmulatedCamera2::flushCapturesInProgress() { + return NO_ERROR; +} + +/** Reprocessing input stream management */ +int EmulatedCamera2::reprocessStreamDequeueBuffer(buffer_handle_t** buffer, + int *stride) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamEnqueueBuffer(buffer_handle_t* buffer) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamCancelBuffer(buffer_handle_t* buffer) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamSetBufferCount(int count) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamSetCrop(int left, int top, int right, int bottom) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamSetTimestamp(int64_t timestamp) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamSetUsage(int usage) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamSetSwapInterval(int interval) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamGetMinUndequeuedBufferCount(int *count) { + return NO_ERROR; +} + +int EmulatedCamera2::reprocessStreamLockBuffer(buffer_handle_t *buffer) { + return NO_ERROR; +} + +/** Output stream creation and management */ + +int EmulatedCamera2::getStreamSlotCount() { + return NO_ERROR; +} + +int EmulatedCamera2::allocateStream(uint32_t stream_slot, + uint32_t width, + uint32_t height, + int format, + camera2_stream_ops_t *stream_ops) { + return NO_ERROR; +} + +int EmulatedCamera2::releaseStream(uint32_t stream_slot) { + return NO_ERROR; +} + +/** Custom tag query methods */ + +const char* EmulatedCamera2::getVendorSectionName(uint32_t tag) { + return NULL; +} + +const char* EmulatedCamera2::getVendorTagName(uint32_t tag) { + return NULL; +} + +int EmulatedCamera2::getVendorTagType(uint32_t tag) { + return -1; +} + +/** Shutdown and debug methods */ + +int EmulatedCamera2::release() { + return NO_ERROR; +} + +int EmulatedCamera2::dump(int fd) { + return NO_ERROR; +} + +/**************************************************************************** + * Private API. + ***************************************************************************/ + +/**************************************************************************** + * Camera API callbacks as defined by camera2_device_ops structure. See + * hardware/libhardware/include/hardware/camera2.h for information on each + * of these callbacks. Implemented in this class, these callbacks simply + * dispatch the call into an instance of EmulatedCamera2 class defined by the + * 'camera_device2' parameter. + ***************************************************************************/ + +int EmulatedCamera2::set_request_queue_src_ops(struct camera2_device *d, + camera2_metadata_queue_src_ops *queue_src_ops) { + EmulatedCamera2* ec = static_cast(d); + return ec->setRequestQueueSrcOps(queue_src_ops); +} + +int EmulatedCamera2::get_request_queue_dst_ops(struct camera2_device *d, + camera2_metadata_queue_dst_ops **queue_dst_ops) { + EmulatedCamera2* ec = static_cast(d); + *queue_dst_ops = static_cast( + &ec->mRequestQueueDstOps); + return NO_ERROR; +} + +int EmulatedCamera2::request_queue_notify_queue_not_empty( + camera2_metadata_queue_dst_ops *q) { + EmulatedCamera2* ec = static_cast(q)->parent; + return ec->requestQueueNotifyNotEmpty(); +} + +int EmulatedCamera2::set_reprocess_queue_src_ops(struct camera2_device *d, + camera2_metadata_queue_src_ops *queue_src_ops) { + EmulatedCamera2* ec = static_cast(d); + return ec->setReprocessQueueSrcOps(queue_src_ops); +} + +int EmulatedCamera2::get_reprocess_queue_dst_ops(struct camera2_device *d, + camera2_metadata_queue_dst_ops **queue_dst_ops) { + EmulatedCamera2* ec = static_cast(d); + *queue_dst_ops = static_cast( + &ec->mReprocessQueueDstOps); + return NO_ERROR; +} + +int EmulatedCamera2::reprocess_queue_notify_queue_not_empty( + camera2_metadata_queue_dst_ops *q) { + EmulatedCamera2* ec = static_cast(q)->parent; + return ec->reprocessQueueNotifyNotEmpty(); +} + +int EmulatedCamera2::set_frame_queue_dst_ops(struct camera2_device *d, + camera2_metadata_queue_dst_ops *queue_dst_ops) { + EmulatedCamera2* ec = static_cast(d); + return ec->setFrameQueueDstOps(queue_dst_ops); +} + +int EmulatedCamera2::get_frame_queue_src_ops(struct camera2_device *d, + camera2_metadata_queue_src_ops **queue_src_ops) { + EmulatedCamera2* ec = static_cast(d); + *queue_src_ops = static_cast( + &ec->mFrameQueueSrcOps); + return NO_ERROR; +} + +int EmulatedCamera2::frame_queue_buffer_count(camera2_metadata_queue_src_ops *q) { + EmulatedCamera2 *ec = static_cast(q)->parent; + return ec->frameQueueBufferCount(); +} + +int EmulatedCamera2::frame_queue_dequeue(camera2_metadata_queue_src_ops *q, + camera_metadata_t **buffer) { + EmulatedCamera2 *ec = static_cast(q)->parent; + return ec->frameQueueDequeue(buffer); +} + +int EmulatedCamera2::frame_queue_free(camera2_metadata_queue_src_ops *q, + camera_metadata_t *old_buffer) { + EmulatedCamera2 *ec = static_cast(q)->parent; + return ec->frameQueueFree(old_buffer); +} + +int EmulatedCamera2::set_notify_callback(struct camera2_device *d, + camera2_notify_callback notify_cb) { + EmulatedCamera2* ec = static_cast(d); + return ec->setNotifyCallback(notify_cb); +} + +int EmulatedCamera2::get_in_progress_count(struct camera2_device *d) { + EmulatedCamera2* ec = static_cast(d); + return ec->getInProgressCount(); +} + +int EmulatedCamera2::flush_captures_in_progress(struct camera2_device *d) { + EmulatedCamera2* ec = static_cast(d); + return ec->flushCapturesInProgress(); +} + +int EmulatedCamera2::get_reprocess_stream_ops(camera2_device_t *d, + camera2_stream_ops **stream) { + EmulatedCamera2* ec = static_cast(d); + *stream = static_cast(&ec->mReprocessStreamOps); + return NO_ERROR; +} + +int EmulatedCamera2::reprocess_stream_dequeue_buffer(camera2_stream_ops *s, + buffer_handle_t** buffer, int *stride) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamDequeueBuffer(buffer, stride); +} + +int EmulatedCamera2::reprocess_stream_enqueue_buffer(camera2_stream_ops *s, + buffer_handle_t* buffer) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamEnqueueBuffer(buffer); +} + +int EmulatedCamera2::reprocess_stream_cancel_buffer(camera2_stream_ops *s, + buffer_handle_t* buffer) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamCancelBuffer(buffer); +} + +int EmulatedCamera2::reprocess_stream_set_buffer_count(camera2_stream_ops *s, + int count) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamSetBufferCount(count); +} + +int EmulatedCamera2::reprocess_stream_set_crop(camera2_stream_ops *s, + int left, int top, int right, int bottom) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamSetCrop(left, top, right, bottom); +} + +int EmulatedCamera2::reprocess_stream_set_timestamp(camera2_stream_ops *s, + int64_t timestamp) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamSetTimestamp(timestamp); +} + +int EmulatedCamera2::reprocess_stream_set_usage(camera2_stream_ops *s, + int usage) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamSetUsage(usage); +} + +int EmulatedCamera2::reprocess_stream_set_swap_interval(camera2_stream_ops *s, + int interval) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamSetSwapInterval(interval); +} + +int EmulatedCamera2::reprocess_stream_get_min_undequeued_buffer_count( + const camera2_stream_ops *s, + int *count) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamGetMinUndequeuedBufferCount(count); +} + +int EmulatedCamera2::reprocess_stream_lock_buffer(camera2_stream_ops *s, + buffer_handle_t* buffer) { + EmulatedCamera2* ec = static_cast(s)->parent; + return ec->reprocessStreamLockBuffer(buffer); +} + +int EmulatedCamera2::get_stream_slot_count(struct camera2_device *d) { + EmulatedCamera2* ec = + static_cast(d); + return ec->getStreamSlotCount(); +} + +int EmulatedCamera2::allocate_stream(struct camera2_device *d, + uint32_t stream_slot, + uint32_t width, + uint32_t height, + uint32_t format, + camera2_stream_ops_t *stream_ops) { + EmulatedCamera2* ec = + static_cast(d); + return ec->allocateStream(stream_slot, width, height, format, stream_ops); +} + +int EmulatedCamera2::release_stream(struct camera2_device *d, + uint32_t stream_slot) { + EmulatedCamera2* ec = + static_cast(d); + return ec->releaseStream(stream_slot); +} + +void EmulatedCamera2::release(struct camera2_device *d) { + EmulatedCamera2* ec = + static_cast(d); + ec->release(); +} + +int EmulatedCamera2::dump(struct camera2_device *d, int fd) { + EmulatedCamera2* ec = + static_cast(d); + return ec->dump(fd); +} + +int EmulatedCamera2::close(struct hw_device_t* device) { + EmulatedCamera2* ec = + static_cast( + reinterpret_cast(device) ); + if (ec == NULL) { + ALOGE("%s: Unexpected NULL camera2 device", __FUNCTION__); + return -EINVAL; + } + return ec->closeCamera(); +} + +int EmulatedCamera2::get_metadata_vendor_tag_ops(struct camera2_device *d, + vendor_tag_query_ops_t **ops) { + EmulatedCamera2* ec = static_cast(d); + *ops = static_cast( + &ec->mVendorTagOps); + return NO_ERROR; +} + +const char* EmulatedCamera2::get_camera_vendor_section_name( + const vendor_tag_query_ops_t *v, + uint32_t tag) { + EmulatedCamera2* ec = static_cast(v)->parent; + return ec->getVendorSectionName(tag); +} + +const char* EmulatedCamera2::get_camera_vendor_tag_name( + const vendor_tag_query_ops_t *v, + uint32_t tag) { + EmulatedCamera2* ec = static_cast(v)->parent; + return ec->getVendorTagName(tag); +} + +int EmulatedCamera2::get_camera_vendor_tag_type( + const vendor_tag_query_ops_t *v, + uint32_t tag) { + EmulatedCamera2* ec = static_cast(v)->parent; + return ec->getVendorTagType(tag); +} + +camera2_device_ops_t EmulatedCamera2::sDeviceOps = { + EmulatedCamera2::set_request_queue_src_ops, + EmulatedCamera2::get_request_queue_dst_ops, + EmulatedCamera2::set_reprocess_queue_src_ops, + EmulatedCamera2::get_reprocess_queue_dst_ops, + EmulatedCamera2::set_frame_queue_dst_ops, + EmulatedCamera2::get_frame_queue_src_ops, + EmulatedCamera2::set_notify_callback, + EmulatedCamera2::get_in_progress_count, + EmulatedCamera2::flush_captures_in_progress, + EmulatedCamera2::get_reprocess_stream_ops, + EmulatedCamera2::get_stream_slot_count, + EmulatedCamera2::allocate_stream, + EmulatedCamera2::release_stream, + EmulatedCamera2::get_metadata_vendor_tag_ops, + EmulatedCamera2::release, + EmulatedCamera2::dump +}; + +}; /* namespace android */ diff --git a/tools/emulator/system/camera/EmulatedCamera2.h b/tools/emulator/system/camera/EmulatedCamera2.h new file mode 100644 index 000000000..feeadf943 --- /dev/null +++ b/tools/emulator/system/camera/EmulatedCamera2.h @@ -0,0 +1,305 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H +#define HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H + +/* + * Contains declaration of a class EmulatedCamera that encapsulates + * functionality common to all version 2.0 emulated camera devices. Instances + * of this class (for each emulated camera) are created during the construction + * of the EmulatedCameraFactory instance. This class serves as an entry point + * for all camera API calls that defined by camera2_device_ops_t API. + */ + +#include "hardware/camera2.h" +#include "system/camera_metadata.h" +#include "EmulatedBaseCamera.h" + +namespace android { + +/* Encapsulates functionality common to all version 2.0 emulated camera devices + * + * Note that EmulatedCameraFactory instantiates object of this class just once, + * when EmulatedCameraFactory instance gets constructed. Connection to / + * disconnection from the actual camera device is handled by calls to + * connectDevice(), and closeCamera() methods of this class that are invoked in + * response to hw_module_methods_t::open, and camera_device::close callbacks. + */ +class EmulatedCamera2 : public camera2_device, public EmulatedBaseCamera { +public: + /* Constructs EmulatedCamera2 instance. + * Param: + * cameraId - Zero based camera identifier, which is an index of the camera + * instance in camera factory's array. + * module - Emulated camera HAL module descriptor. + */ + EmulatedCamera2(int cameraId, + struct hw_module_t* module); + + /* Destructs EmulatedCamera2 instance. */ + virtual ~EmulatedCamera2(); + + /**************************************************************************** + * Abstract API + ***************************************************************************/ + +public: + + /**************************************************************************** + * Public API + ***************************************************************************/ + +public: + virtual status_t Initialize(); + + /**************************************************************************** + * Camera API implementation + ***************************************************************************/ + +public: + virtual status_t connectCamera(hw_device_t** device); + + virtual status_t closeCamera(); + + virtual status_t getCameraInfo(struct camera_info* info); + + /**************************************************************************** + * Camera API implementation. + * These methods are called from the camera API callback routines. + ***************************************************************************/ + +protected: + /** Request input queue */ + + int setRequestQueueSrcOps( + camera2_metadata_queue_src_ops *request_queue_src_ops); + + int requestQueueNotifyNotEmpty(); + + /** Reprocessing input queue */ + + int setReprocessQueueSrcOps( + camera2_metadata_queue_src_ops *reprocess_queue_src_ops); + + int reprocessQueueNotifyNotEmpty(); + + /** Frame output queue */ + + int setFrameQueueDstOps(camera2_metadata_queue_dst_ops *frame_queue_dst_ops); + + int frameQueueBufferCount(); + int frameQueueDequeue(camera_metadata_t **buffer); + int frameQueueFree(camera_metadata_t *old_buffer); + + /** Notifications to application */ + int setNotifyCallback(camera2_notify_callback notify_cb); + + /** Count of requests in flight */ + int getInProgressCount(); + + /** Cancel all captures in flight */ + int flushCapturesInProgress(); + + /** Reprocessing input stream management */ + int reprocessStreamDequeueBuffer(buffer_handle_t** buffer, + int *stride); + + int reprocessStreamEnqueueBuffer(buffer_handle_t* buffer); + + int reprocessStreamCancelBuffer(buffer_handle_t* buffer); + + int reprocessStreamSetBufferCount(int count); + + int reprocessStreamSetCrop(int left, int top, int right, int bottom); + + int reprocessStreamSetTimestamp(int64_t timestamp); + + int reprocessStreamSetUsage(int usage); + + int reprocessStreamSetSwapInterval(int interval); + + int reprocessStreamGetMinUndequeuedBufferCount(int *count); + + int reprocessStreamLockBuffer(buffer_handle_t *buffer); + + /** Output stream creation and management */ + + int getStreamSlotCount(); + + int allocateStream(uint32_t stream_slot, + uint32_t width, + uint32_t height, + int format, + camera2_stream_ops_t *stream_ops); + + int releaseStream(uint32_t stream_slot); + + /** Custom tag definitions */ + const char* getVendorSectionName(uint32_t tag); + const char* getVendorTagName(uint32_t tag); + int getVendorTagType(uint32_t tag); + + /** Shutdown and debug methods */ + + int release(); + + int dump(int fd); + + int close(); + + /**************************************************************************** + * Camera API callbacks as defined by camera2_device_ops structure. See + * hardware/libhardware/include/hardware/camera2.h for information on each + * of these callbacks. Implemented in this class, these callbacks simply + * dispatch the call into an instance of EmulatedCamera2 class defined in the + * 'camera_device2' parameter. + ***************************************************************************/ + +private: + /** Input request queue */ + static int set_request_queue_src_ops(camera2_device_t *, + camera2_metadata_queue_src_ops *queue_src_ops); + static int get_request_queue_dst_ops(camera2_device_t *, + camera2_metadata_queue_dst_ops **queue_dst_ops); + // for get_request_queue_dst_ops + static int request_queue_notify_queue_not_empty( + camera2_metadata_queue_dst_ops *); + + /** Input reprocess queue */ + static int set_reprocess_queue_src_ops(camera2_device_t *, + camera2_metadata_queue_src_ops *reprocess_queue_src_ops); + static int get_reprocess_queue_dst_ops(camera2_device_t *, + camera2_metadata_queue_dst_ops **queue_dst_ops); + // for reprocess_queue_dst_ops + static int reprocess_queue_notify_queue_not_empty( + camera2_metadata_queue_dst_ops *); + + /** Output frame queue */ + static int set_frame_queue_dst_ops(camera2_device_t *, + camera2_metadata_queue_dst_ops *queue_dst_ops); + static int get_frame_queue_src_ops(camera2_device_t *, + camera2_metadata_queue_src_ops **queue_src_ops); + // for get_frame_queue_src_ops + static int frame_queue_buffer_count(camera2_metadata_queue_src_ops *); + static int frame_queue_dequeue(camera2_metadata_queue_src_ops *, + camera_metadata_t **buffer); + static int frame_queue_free(camera2_metadata_queue_src_ops *, + camera_metadata_t *old_buffer); + + /** Notifications to application */ + static int set_notify_callback(camera2_device_t *, + camera2_notify_callback notify_cb); + + /** In-progress request management */ + static int get_in_progress_count(camera2_device_t *); + + static int flush_captures_in_progress(camera2_device_t *); + + /** Input reprocessing stream */ + static int get_reprocess_stream_ops(camera2_device_t *, + camera2_stream_ops_t **stream); + // for get_reprocess_stream_ops + static int reprocess_stream_dequeue_buffer(camera2_stream_ops *, + buffer_handle_t** buffer, int *stride); + static int reprocess_stream_enqueue_buffer(camera2_stream_ops *, + buffer_handle_t* buffer); + static int reprocess_stream_cancel_buffer(camera2_stream_ops *, + buffer_handle_t* buffer); + static int reprocess_stream_set_buffer_count(camera2_stream_ops *, + int count); + static int reprocess_stream_set_crop(camera2_stream_ops *, + int left, int top, int right, int bottom); + static int reprocess_stream_set_timestamp(camera2_stream_ops *, + int64_t timestamp); + static int reprocess_stream_set_usage(camera2_stream_ops *, + int usage); + static int reprocess_stream_set_swap_interval(camera2_stream_ops *, + int interval); + static int reprocess_stream_get_min_undequeued_buffer_count( + const camera2_stream_ops *, + int *count); + static int reprocess_stream_lock_buffer(camera2_stream_ops *, + buffer_handle_t* buffer); + + /** Output stream allocation and management */ + + static int get_stream_slot_count(camera2_device_t *); + + static int allocate_stream(camera2_device_t *, + uint32_t stream_slot, + uint32_t width, + uint32_t height, + uint32_t format, + camera2_stream_ops_t *stream_ops); + + static int release_stream(camera2_device_t *, + uint32_t stream_slot); + + static void release(camera2_device_t *); + + /** Vendor metadata registration */ + + static int get_metadata_vendor_tag_ops(camera2_device_t *, + vendor_tag_query_ops_t **ops); + // for get_metadata_vendor_tag_ops + static const char* get_camera_vendor_section_name( + const vendor_tag_query_ops_t *, + uint32_t tag); + static const char* get_camera_vendor_tag_name( + const vendor_tag_query_ops_t *, + uint32_t tag); + static int get_camera_vendor_tag_type( + const vendor_tag_query_ops_t *, + uint32_t tag); + + static int dump(camera2_device_t *, int fd); + + static int close(struct hw_device_t* device); + + /**************************************************************************** + * Data members + ***************************************************************************/ + + private: + static camera2_device_ops_t sDeviceOps; + + struct QueueDstOps : public camera2_metadata_queue_dst_ops { + EmulatedCamera2 *parent; + }; + + struct QueueSrcOps : public camera2_metadata_queue_src_ops { + EmulatedCamera2 *parent; + }; + + struct StreamOps : public camera2_stream_ops { + EmulatedCamera2 *parent; + }; + + struct TagOps : public vendor_tag_query_ops { + EmulatedCamera2 *parent; + }; + + QueueDstOps mRequestQueueDstOps; + QueueDstOps mReprocessQueueDstOps; + QueueSrcOps mFrameQueueSrcOps; + StreamOps mReprocessStreamOps; + TagOps mVendorTagOps; +}; + +}; /* namespace android */ + +#endif /* HW_EMULATOR_CAMERA_EMULATED_CAMERA2_H */ diff --git a/tools/emulator/system/camera/EmulatedCameraFactory.cpp b/tools/emulator/system/camera/EmulatedCameraFactory.cpp index fbb05b5bd..2960751da 100755 --- a/tools/emulator/system/camera/EmulatedCameraFactory.cpp +++ b/tools/emulator/system/camera/EmulatedCameraFactory.cpp @@ -25,6 +25,7 @@ #include #include "EmulatedQemuCamera.h" #include "EmulatedFakeCamera.h" +#include "EmulatedFakeCamera2.h" #include "EmulatedCameraFactory.h" extern camera_module_t HAL_MODULE_INFO_SYM; @@ -66,13 +67,27 @@ EmulatedCameraFactory::EmulatedCameraFactory() __FUNCTION__, mEmulatedCameraNum); return; } - memset(mEmulatedCameras, 0, (mEmulatedCameraNum + 1) * sizeof(EmulatedCamera*)); + memset(mEmulatedCameras, 0, + (mEmulatedCameraNum + 1) * sizeof(EmulatedBaseCamera*)); } /* Create, and initialize the fake camera */ - mEmulatedCameras[camera_id] = - new EmulatedFakeCamera(camera_id, true, &HAL_MODULE_INFO_SYM.common); + switch (getBackCameraHalVersion()) { + case 1: + mEmulatedCameras[camera_id] = + new EmulatedFakeCamera(camera_id, false, &HAL_MODULE_INFO_SYM.common); + break; + case 2: + mEmulatedCameras[camera_id] = + new EmulatedFakeCamera2(camera_id, false, &HAL_MODULE_INFO_SYM.common); + break; + default: + ALOGE("%s: Unknown back camera hal version requested: %d", __FUNCTION__, + getBackCameraHalVersion()); + } if (mEmulatedCameras[camera_id] != NULL) { + ALOGV("%s: Back camera device version is %d", __FUNCTION__, + getBackCameraHalVersion()); if (mEmulatedCameras[camera_id]->Initialize() != NO_ERROR) { delete mEmulatedCameras[camera_id]; mEmulatedCameras--; @@ -98,13 +113,27 @@ EmulatedCameraFactory::EmulatedCameraFactory() __FUNCTION__, mEmulatedCameraNum); return; } - memset(mEmulatedCameras, 0, mEmulatedCameraNum * sizeof(EmulatedCamera*)); + memset(mEmulatedCameras, 0, + mEmulatedCameraNum * sizeof(EmulatedBaseCamera*)); } /* Create, and initialize the fake camera */ - mEmulatedCameras[camera_id] = - new EmulatedFakeCamera(camera_id, false, &HAL_MODULE_INFO_SYM.common); + switch (getFrontCameraHalVersion()) { + case 1: + mEmulatedCameras[camera_id] = + new EmulatedFakeCamera(camera_id, false, &HAL_MODULE_INFO_SYM.common); + break; + case 2: + mEmulatedCameras[camera_id] = + new EmulatedFakeCamera2(camera_id, false, &HAL_MODULE_INFO_SYM.common); + break; + default: + ALOGE("%s: Unknown front camera hal version requested: %d", __FUNCTION__, + getFrontCameraHalVersion()); + } if (mEmulatedCameras[camera_id] != NULL) { + ALOGV("%s: Front camera device version is %d", __FUNCTION__, + getFrontCameraHalVersion()); if (mEmulatedCameras[camera_id]->Initialize() != NO_ERROR) { delete mEmulatedCameras[camera_id]; mEmulatedCameras--; @@ -348,6 +377,23 @@ bool EmulatedCameraFactory::isBackFakeCameraEmulationOn() } } +int EmulatedCameraFactory::getBackCameraHalVersion() +{ + /* Defined by 'qemu.sf.back_camera_hal_version' boot property: if the + * property doesn't exist, it is assumed to be 1. */ + char prop[PROPERTY_VALUE_MAX]; + if (property_get("qemu.sf.back_camera_hal", prop, NULL) > 0) { + char *prop_end = prop; + int val = strtol(prop, &prop_end, 10); + if (*prop_end == '\0') { + return val; + } + // Badly formatted property, should just be a number + ALOGE("qemu.sf.back_camera_hal is not a number: %s", prop); + } + return 1; +} + bool EmulatedCameraFactory::isFrontFakeCameraEmulationOn() { /* Defined by 'qemu.sf.fake_camera' boot property: if property exist, and @@ -362,6 +408,23 @@ bool EmulatedCameraFactory::isFrontFakeCameraEmulationOn() } } +int EmulatedCameraFactory::getFrontCameraHalVersion() +{ + /* Defined by 'qemu.sf.front_camera_hal_version' boot property: if the + * property doesn't exist, it is assumed to be 1. */ + char prop[PROPERTY_VALUE_MAX]; + if (property_get("qemu.sf.front_camera_hal", prop, NULL) > 0) { + char *prop_end = prop; + int val = strtol(prop, &prop_end, 10); + if (*prop_end == '\0') { + return val; + } + // Badly formatted property, should just be a number + ALOGE("qemu.sf.front_camera_hal is not a number: %s", prop); + } + return 1; +} + /******************************************************************************** * Initializer for the static member structure. *******************************************************************************/ diff --git a/tools/emulator/system/camera/EmulatedCameraFactory.h b/tools/emulator/system/camera/EmulatedCameraFactory.h index 7e3d4b262..123e73550 100755 --- a/tools/emulator/system/camera/EmulatedCameraFactory.h +++ b/tools/emulator/system/camera/EmulatedCameraFactory.h @@ -134,9 +134,15 @@ private: /* Checks if fake camera emulation is on for the camera facing back. */ bool isBackFakeCameraEmulationOn(); + /* Gets camera device version number to use for back camera emulation */ + int getBackCameraHalVersion(); + /* Checks if fake camera emulation is on for the camera facing front. */ bool isFrontFakeCameraEmulationOn(); + /* Gets camera device version number to use for front camera emulation */ + int getFrontCameraHalVersion(); + /**************************************************************************** * Data members. ***************************************************************************/ diff --git a/tools/emulator/system/camera/EmulatedFakeCamera2.cpp b/tools/emulator/system/camera/EmulatedFakeCamera2.cpp new file mode 100644 index 000000000..aa622446f --- /dev/null +++ b/tools/emulator/system/camera/EmulatedFakeCamera2.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Contains implementation of a class EmulatedFakeCamera2 that encapsulates + * functionality of an advanced fake camera. + */ + +#define LOG_NDEBUG 0 +#define LOG_TAG "EmulatedCamera_FakeCamera2" +#include +#include +#include "EmulatedFakeCamera2.h" +#include "EmulatedCameraFactory.h" + +namespace android { + +EmulatedFakeCamera2::EmulatedFakeCamera2(int cameraId, + bool facingBack, + struct hw_module_t* module) + : EmulatedCamera2(cameraId,module), + mFacingBack(facingBack) +{ + ALOGD("Constructing emulated fake camera 2 facing %s", + facingBack ? "back" : "front"); +} + +EmulatedFakeCamera2::~EmulatedFakeCamera2() +{ +} + +/**************************************************************************** + * Public API overrides + ***************************************************************************/ + +status_t EmulatedFakeCamera2::Initialize() +{ + return NO_ERROR; +} + +}; /* namespace android */ diff --git a/tools/emulator/system/camera/EmulatedFakeCamera2.h b/tools/emulator/system/camera/EmulatedFakeCamera2.h new file mode 100644 index 000000000..89b12d3da --- /dev/null +++ b/tools/emulator/system/camera/EmulatedFakeCamera2.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H +#define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H + +/* + * Contains declaration of a class EmulatedFakeCamera2 that encapsulates + * functionality of a fake camera that implements version 2 of the camera device + * interface. + */ + +#include "EmulatedCamera2.h" + +namespace android { + +/* Encapsulates functionality of an advanced fake camera. This camera contains + * a simple simulation of a scene, sensor, and image processing pipeline. + */ +class EmulatedFakeCamera2 : public EmulatedCamera2 { +public: + /* Constructs EmulatedFakeCamera instance. */ + EmulatedFakeCamera2(int cameraId, bool facingBack, struct hw_module_t* module); + + /* Destructs EmulatedFakeCamera instance. */ + ~EmulatedFakeCamera2(); + + /**************************************************************************** + * EmulatedCamera2 virtual overrides. + ***************************************************************************/ + +public: + /* Initializes EmulatedFakeCamera2 instance. */ + status_t Initialize(); + + /**************************************************************************** + * EmulatedCamera abstract API implementation. + ***************************************************************************/ + +protected: + + /**************************************************************************** + * Data memebers. + ***************************************************************************/ + +protected: + /* Facing back (true) or front (false) switch. */ + bool mFacingBack; + +}; + +}; /* namespace android */ + +#endif /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H */ diff --git a/tools/emulator/system/camera/EmulatedQemuCamera2.cpp b/tools/emulator/system/camera/EmulatedQemuCamera2.cpp new file mode 100644 index 000000000..2c94f0e31 --- /dev/null +++ b/tools/emulator/system/camera/EmulatedQemuCamera2.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Contains implementation of a class EmulatedQemuCamera2 that encapsulates + * functionality of a host webcam with further processing to simulate the + * capabilities of a v2 camera device. + */ + +#define LOG_NDEBUG 0 +#define LOG_TAG "EmulatedCamera_QemuCamera2" +#include +#include +#include "EmulatedQemuCamera2.h" +#include "EmulatedCameraFactory.h" + +namespace android { + +EmulatedQemuCamera2::EmulatedQemuCamera2(int cameraId, + bool facingBack, + struct hw_module_t* module) + : EmulatedCamera2(cameraId,module), + mFacingBack(facingBack) +{ + ALOGD("Constructing emulated qemu camera 2 facing %s", + facingBack ? "back" : "front"); +} + +EmulatedQemuCamera2::~EmulatedQemuCamera2() +{ +} + +/**************************************************************************** + * Public API overrides + ***************************************************************************/ + +status_t EmulatedQemuCamera2::Initialize() +{ + return NO_ERROR; +} + +}; /* namespace android */ diff --git a/tools/emulator/system/camera/EmulatedQemuCamera2.h b/tools/emulator/system/camera/EmulatedQemuCamera2.h new file mode 100644 index 000000000..520ccce89 --- /dev/null +++ b/tools/emulator/system/camera/EmulatedQemuCamera2.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA2_H +#define HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA2_H + +/* + * Contains declaration of a class EmulatedQemuCamera2 that encapsulates + * functionality of a host webcam with added processing to implement version 2 + * of the camera device interface. + */ + +#include "EmulatedCamera2.h" + +namespace android { + +/* Encapsulates functionality of an advanced fake camera based on real host camera data. + */ +class EmulatedQemuCamera2 : public EmulatedCamera2 { +public: + /* Constructs EmulatedFakeCamera instance. */ + EmulatedQemuCamera2(int cameraId, bool facingBack, struct hw_module_t* module); + + /* Destructs EmulatedFakeCamera instance. */ + ~EmulatedQemuCamera2(); + + /**************************************************************************** + * EmulatedCamera2 virtual overrides. + ***************************************************************************/ + +public: + /* Initializes EmulatedQemuCamera2 instance. */ + status_t Initialize(); + + /**************************************************************************** + * EmulatedCamera abstract API implementation. + ***************************************************************************/ + +protected: + + /**************************************************************************** + * Data memebers. + ***************************************************************************/ + +protected: + /* Facing back (true) or front (false) switch. */ + bool mFacingBack; + +}; + +}; /* namespace android */ + +#endif /* HW_EMULATOR_CAMERA_EMULATED_QEMU_CAMERA2_H */