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