669d233045
CAF revision: AU_LINUX_ANDROID_LA.UM.5.1_RB1.06.00.01.192.038 Change-Id: I87589fea5e9c00c3bdc9c79cc6b2d6453c3d09b3
285 lines
12 KiB
C++
285 lines
12 KiB
C++
/* 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];
|
|
} 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_bDualCameraEnabled;
|
|
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__ */
|
|
|