You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
286 lines
12 KiB
286 lines
12 KiB
/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions are |
|
* met: |
|
* * Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* * Redistributions in binary form must reproduce the above |
|
* copyright notice, this list of conditions and the following |
|
* disclaimer in the documentation and/or other materials provided |
|
* with the distribution. |
|
* * Neither the name of The Linux Foundation nor the names of its |
|
* contributors may be used to endorse or promote products derived |
|
* from this software without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
|
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
*/ |
|
|
|
#ifndef __QCAMERAMUXER_H__ |
|
#define __QCAMERAMUXER_H__ |
|
|
|
#include "camera.h" |
|
#include "QCamera2HWI.h" |
|
#include "QCamera3HWI.h" |
|
|
|
namespace qcamera { |
|
|
|
/* Struct@ qcamera_physical_descriptor_t |
|
* |
|
* Description@ This structure specifies various attributes |
|
* physical cameras enumerated on the device |
|
*/ |
|
typedef struct { |
|
// Userspace Physical Camera ID |
|
uint32_t id; |
|
// Server Camera ID |
|
uint32_t camera_server_id; |
|
// Device version |
|
uint32_t device_version; |
|
// Specifies type of camera |
|
cam_sync_type_t type; |
|
// Specifies mode of Camera |
|
cam_sync_mode_t mode; |
|
// Camera Info |
|
camera_info cam_info; |
|
// Reference to HWI |
|
QCamera2HardwareInterface *hwi; |
|
// Reference to camera device structure |
|
camera_device_t* dev; |
|
} qcamera_physical_descriptor_t; |
|
|
|
/* Struct@ qcamera_logical_descriptor_t |
|
* |
|
* Description@ This structure stores information about logical cameras |
|
* and corresponding data of the physical camera that are part of |
|
* this logical camera |
|
*/ |
|
typedef struct { |
|
// Camera Device to be shared to Frameworks |
|
camera_device_t dev; |
|
// Device version |
|
uint32_t device_version; |
|
// Logical Camera ID |
|
uint32_t id; |
|
// Logical Camera Facing |
|
int32_t facing; |
|
// Number of Physical camera present in this logical camera |
|
uint32_t numCameras; |
|
// To signify if the LINK/UNLINK established between physical cameras |
|
bool bSyncOn; |
|
// index of the primary physical camera session in the bundle |
|
uint8_t nPrimaryPhyCamIndex; |
|
// Signifies Physical Camera ID of each camera |
|
uint32_t pId[MAX_NUM_CAMERA_PER_BUNDLE]; |
|
// Signifies server camera ID of each camera |
|
uint32_t sId[MAX_NUM_CAMERA_PER_BUNDLE]; |
|
// Signifies type of each camera |
|
cam_sync_type_t type[MAX_NUM_CAMERA_PER_BUNDLE]; |
|
// Signifies mode of each camera |
|
cam_sync_mode_t mode[MAX_NUM_CAMERA_PER_BUNDLE]; |
|
// Signifies mode of each 3a used by the camera |
|
cam_3a_sync_mode_t sync_3a[MAX_NUM_CAMERA_PER_BUNDLE]; |
|
} qcamera_logical_descriptor_t; |
|
|
|
/* Struct@ cam_compose_jpeg_info_t |
|
* |
|
* Description@ This structure stores information about individual Jpeg images |
|
* received from multiple related physical camera instances. These images would then be |
|
* composed together into a single MPO image later. |
|
*/ |
|
typedef struct { |
|
// msg_type is same as data callback msg_type |
|
int32_t msg_type; |
|
// ptr to actual data buffer |
|
camera_memory_t *buffer; |
|
// index of the buffer same as received in data callback |
|
unsigned int index; |
|
// metadata associated with the buffer |
|
camera_frame_metadata_t *metadata; |
|
// user contains the caller's identity |
|
// this contains a reference to the physical cam structure |
|
// of the HWI instance which had requested for this data buffer |
|
void *user; |
|
// this indicates validity of the buffer |
|
// this flag is used by multiple threads to check validity of |
|
// Jpegs received by other threads |
|
bool valid; |
|
// frame id of the Jpeg. this is needed for frame sync between aux |
|
// and main camera sessions |
|
uint32_t frame_idx; |
|
// release callback function to release this Jpeg memory later after |
|
// composition is completed |
|
camera_release_callback release_cb; |
|
// cookie for the release callback function |
|
void *release_cookie; |
|
// release data info for what needs to be released |
|
void *release_data; |
|
}cam_compose_jpeg_info_t; |
|
|
|
/* Class@ QCameraMuxer |
|
* |
|
* Description@ Muxer interface |
|
* a) Manages the grouping of the physical cameras into a logical camera |
|
* b) Muxes the operational calls from Frameworks to HWI |
|
* c) Composes MPO from JPEG |
|
*/ |
|
class QCameraMuxer { |
|
|
|
public: |
|
/* Public Methods */ |
|
QCameraMuxer(uint32_t num_of_cameras); |
|
virtual ~QCameraMuxer(); |
|
static void getCameraMuxer(QCameraMuxer** pCamMuxer, |
|
uint32_t num_of_cameras); |
|
static int get_number_of_cameras(); |
|
static int get_camera_info(int camera_id, struct camera_info *info); |
|
static int set_callbacks(const camera_module_callbacks_t *callbacks); |
|
static int open_legacy(const struct hw_module_t* module, |
|
const char* id, uint32_t halVersion, struct hw_device_t** device); |
|
|
|
static int camera_device_open(const struct hw_module_t* module, |
|
const char* id, |
|
struct hw_device_t** device); |
|
static int close_camera_device( hw_device_t *); |
|
|
|
/* Operation methods directly accessed by Camera Service */ |
|
static camera_device_ops_t mCameraMuxerOps; |
|
|
|
/* Start of operational methods */ |
|
static int set_preview_window(struct camera_device *, |
|
struct preview_stream_ops *window); |
|
static void set_callBacks(struct camera_device *, |
|
camera_notify_callback notify_cb, |
|
camera_data_callback data_cb, |
|
camera_data_timestamp_callback data_cb_timestamp, |
|
camera_request_memory get_memory, |
|
void *user); |
|
static void enable_msg_type(struct camera_device *, int32_t msg_type); |
|
static void disable_msg_type(struct camera_device *, int32_t msg_type); |
|
static int msg_type_enabled(struct camera_device *, int32_t msg_type); |
|
static int start_preview(struct camera_device *); |
|
static void stop_preview(struct camera_device *); |
|
static int preview_enabled(struct camera_device *); |
|
static int store_meta_data_in_buffers(struct camera_device *, |
|
int enable); |
|
static int start_recording(struct camera_device *); |
|
static void stop_recording(struct camera_device *); |
|
static int recording_enabled(struct camera_device *); |
|
static void release_recording_frame(struct camera_device *, |
|
const void *opaque); |
|
static int auto_focus(struct camera_device *); |
|
static int cancel_auto_focus(struct camera_device *); |
|
static int take_picture(struct camera_device *); |
|
static int cancel_picture(struct camera_device *); |
|
static int set_parameters(struct camera_device *, const char *parms); |
|
static char* get_parameters(struct camera_device *); |
|
static void put_parameters(struct camera_device *, char *); |
|
static int send_command(struct camera_device *, |
|
int32_t cmd, int32_t arg1, int32_t arg2); |
|
static void release(struct camera_device *); |
|
static int dump(struct camera_device *, int fd); |
|
/* End of operational methods */ |
|
|
|
static void jpeg_data_callback(int32_t msg_type, |
|
const camera_memory_t *data, unsigned int index, |
|
camera_frame_metadata_t *metadata, void *user, |
|
uint32_t frame_idx, camera_release_callback release_cb, |
|
void *release_cookie, void *release_data); |
|
// add notify error msgs to the notifer queue of the primary related cam instance |
|
static int32_t sendEvtNotify(int32_t msg_type, int32_t ext1, int32_t ext2); |
|
// function to compose all JPEG images from all physical related camera instances |
|
void composeMpo(cam_compose_jpeg_info_t* main_Jpeg, |
|
cam_compose_jpeg_info_t* aux_Jpeg); |
|
static void* composeMpoRoutine(void* data); |
|
static bool matchFrameId(void *data, void *user_data, void *match_data); |
|
static bool findPreviousJpegs(void *data, void *user_data, void *match_data); |
|
static void releaseJpegInfo(void *data, void *user_data); |
|
|
|
public: |
|
/* Public Members Variables */ |
|
// Jpeg and Mpo ops need to be shared between 2 HWI instances |
|
// hence these are cached in the muxer alongwith Jpeg handle |
|
mm_jpeg_ops_t mJpegOps; |
|
mm_jpeg_mpo_ops_t mJpegMpoOps; |
|
uint32_t mJpegClientHandle; |
|
// Stores Camera Data Callback function |
|
camera_data_callback mDataCb; |
|
// Stores Camera GetMemory Callback function |
|
camera_request_memory mGetMemoryCb; |
|
|
|
private: |
|
/* Private Member Variables */ |
|
qcamera_physical_descriptor_t *m_pPhyCamera; |
|
qcamera_logical_descriptor_t *m_pLogicalCamera; |
|
const camera_module_callbacks_t *m_pCallbacks; |
|
bool m_bAuxCameraExposed; |
|
uint8_t m_nPhyCameras; |
|
uint8_t m_nLogicalCameras; |
|
|
|
// Main Camera session Jpeg Queue |
|
QCameraQueue m_MainJpegQ; |
|
// Aux Camera session Jpeg Queue |
|
QCameraQueue m_AuxJpegQ; |
|
// thread for mpo composition |
|
QCameraCmdThread m_ComposeMpoTh; |
|
// Final Mpo Jpeg Buffer |
|
camera_memory_t *m_pRelCamMpoJpeg; |
|
// Lock needed to synchronize between multiple composition requests |
|
pthread_mutex_t m_JpegLock; |
|
// this callback cookie would be used for sending Final mpo Jpeg to the framework |
|
void *m_pMpoCallbackCookie; |
|
// this callback cookie would be used for caching main related cam phy instance |
|
// this is needed for error scenarios |
|
// incase of error, we use this cookie to get HWI instance and send errors in notify cb |
|
void *m_pJpegCallbackCookie; |
|
// flag to indicate whether we need to dump dual camera snapshots |
|
bool m_bDumpImages; |
|
// flag to indicate whether MPO is enabled or not |
|
bool m_bMpoEnabled; |
|
// Signifies if frame sync is enabled |
|
bool m_bFrameSyncEnabled; |
|
// flag to indicate whether recording hint is internally set. |
|
bool m_bRecordingHintInternallySet; |
|
|
|
/* Private Member Methods */ |
|
int setupLogicalCameras(); |
|
int cameraDeviceOpen(int camera_id, struct hw_device_t **hw_device); |
|
int getNumberOfCameras(); |
|
int getCameraInfo(int camera_id, struct camera_info *info, |
|
cam_sync_type_t *p_cam_type); |
|
int32_t setCallbacks(const camera_module_callbacks_t *callbacks); |
|
int32_t setDataCallback(camera_data_callback data_cb); |
|
int32_t setMemoryCallback(camera_request_memory get_memory); |
|
qcamera_logical_descriptor_t* getLogicalCamera( |
|
struct camera_device * device); |
|
qcamera_physical_descriptor_t* getPhysicalCamera( |
|
qcamera_logical_descriptor_t* log_cam, uint32_t index); |
|
int32_t getActiveNumOfPhyCam( |
|
qcamera_logical_descriptor_t* log_cam, int& numOfAcitvePhyCam); |
|
int32_t setMpoCallbackCookie(void* mpoCbCookie); |
|
void* getMpoCallbackCookie(); |
|
int32_t setMainJpegCallbackCookie(void* jpegCbCookie); |
|
void* getMainJpegCallbackCookie(); |
|
void setJpegHandle(uint32_t handle) { mJpegClientHandle = handle;}; |
|
// function to store single JPEG from 1 related physical camera instance |
|
int32_t storeJpeg(cam_sync_type_t cam_type, int32_t msg_type, |
|
const camera_memory_t *data, unsigned int index, |
|
camera_frame_metadata_t *metadata, void *user, |
|
uint32_t frame_idx, camera_release_callback release_cb, |
|
void *release_cookie, void *release_data); |
|
|
|
};// End namespace qcamera |
|
|
|
} |
|
#endif /* __QCAMERAMUXER_H__ */ |
|
|
|
|