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