/* Copyright (c) 2012-2013, The Linux Foundataion. 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 __QCAMERA2HARDWAREINTERFACE_H__ #define __QCAMERA2HARDWAREINTERFACE_H__ #include #include #include #include #include "QCameraQueue.h" #include "QCameraCmdThread.h" #include "QCameraChannel.h" #include "QCameraStream.h" #include "QCameraStateMachine.h" #include "QCameraAllocator.h" #include "QCameraPostProc.h" #include "QCameraThermalAdapter.h" extern "C" { #include #include } #if DISABLE_DEBUG_LOG inline void __null_log(int, const char *, const char *, ...) {} #ifdef ALOGD #undef ALOGD #define ALOGD(...) do { __null_log(0, LOG_TAG,__VA_ARGS__); } while (0) #endif #ifdef ALOGI #undef ALOGI #define ALOGI(...) do { __null_log(0, LOG_TAG,__VA_ARGS__); } while (0) #endif #endif namespace qcamera { #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif typedef enum { QCAMERA_CH_TYPE_ZSL, QCAMERA_CH_TYPE_CAPTURE, QCAMERA_CH_TYPE_PREVIEW, QCAMERA_CH_TYPE_VIDEO, QCAMERA_CH_TYPE_SNAPSHOT, QCAMERA_CH_TYPE_RAW, QCAMERA_CH_TYPE_METADATA, QCAMERA_CH_TYPE_MAX } qcamera_ch_type_enum_t; typedef struct { int32_t msg_type; int32_t ext1; int32_t ext2; } qcamera_evt_argm_t; #define QCAMERA_DUMP_FRM_PREVIEW 1 #define QCAMERA_DUMP_FRM_VIDEO (1<<1) #define QCAMERA_DUMP_FRM_SNAPSHOT (1<<2) #define QCAMERA_DUMP_FRM_THUMBNAIL (1<<3) #define QCAMERA_DUMP_FRM_RAW (1<<4) #define QCAMERA_DUMP_FRM_JPEG (1<<5) #define QCAMERA_DUMP_FRM_MASK_ALL 0x000000ff #define QCAMERA_ION_USE_CACHE true #define QCAMERA_ION_USE_NOCACHE false typedef enum { QCAMERA_NOTIFY_CALLBACK, QCAMERA_DATA_CALLBACK, QCAMERA_DATA_TIMESTAMP_CALLBACK, QCAMERA_DATA_SNAPSHOT_CALLBACK } qcamera_callback_type_m; typedef void (*camera_release_callback)(void *user_data, void *cookie); typedef struct { qcamera_callback_type_m cb_type; // event type int32_t msg_type; // msg type int32_t ext1; // extended parameter int32_t ext2; // extended parameter camera_memory_t * data; // ptr to data memory struct unsigned int index; // index of the buf in the whole buffer int64_t timestamp; // buffer timestamp camera_frame_metadata_t *metadata; // meta data void *user_data; // any data needs to be released after callback void *cookie; // release callback cookie camera_release_callback release_cb; // release callback } qcamera_callback_argm_t; class QCameraCbNotifier { public: QCameraCbNotifier(QCamera2HardwareInterface *parent) : mNotifyCb (NULL), mDataCb (NULL), mDataCbTimestamp (NULL), mCallbackCookie (NULL), mParent (parent), mDataQ(releaseNotifications, this) {} virtual ~QCameraCbNotifier(); virtual int32_t notifyCallback(qcamera_callback_argm_t &cbArgs); virtual void setCallbacks(camera_notify_callback notifyCb, camera_data_callback dataCb, camera_data_timestamp_callback dataCbTimestamp, void *callbackCookie); virtual int32_t startSnapshots(); virtual void stopSnapshots(); static void * cbNotifyRoutine(void * data); static void releaseNotifications(void *data, void *user_data); static bool matchSnapshotNotifications(void *data, void *user_data); private: camera_notify_callback mNotifyCb; camera_data_callback mDataCb; camera_data_timestamp_callback mDataCbTimestamp; void *mCallbackCookie; QCamera2HardwareInterface *mParent; QCameraQueue mDataQ; QCameraCmdThread mProcTh; }; class QCamera2HardwareInterface : public QCameraAllocator, public QCameraThermalCallback { public: /* static variable and functions accessed by camera service */ static camera_device_ops_t mCameraOps; 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); static int close_camera_device(hw_device_t *); static int register_face_image(struct camera_device *, void *img_ptr, cam_pp_offline_src_config_t *config); public: QCamera2HardwareInterface(int cameraId); virtual ~QCamera2HardwareInterface(); int openCamera(struct hw_device_t **hw_device); static int getCapabilities(int cameraId, struct camera_info *info); static int initCapabilities(int cameraId); // Implementation of QCameraAllocator virtual QCameraMemory *allocateStreamBuf(cam_stream_type_t stream_type, int size, uint8_t &bufferCnt); virtual QCameraHeapMemory *allocateStreamInfoBuf(cam_stream_type_t stream_type); // Implementation of QCameraThermalCallback virtual int thermalEvtHandle(qcamera_thermal_level_enum_t level, void *userdata, void *data); friend class QCameraStateMachine; friend class QCameraPostProcessor; friend class QCameraCbNotifier; private: int setPreviewWindow(struct preview_stream_ops *window); int setCallBacks( camera_notify_callback notify_cb, camera_data_callback data_cb, camera_data_timestamp_callback data_cb_timestamp, camera_request_memory get_memory, void *user); int enableMsgType(int32_t msg_type); int disableMsgType(int32_t msg_type); int msgTypeEnabled(int32_t msg_type); int msgTypeEnabledWithLock(int32_t msg_type); int startPreview(); int stopPreview(); int storeMetaDataInBuffers(int enable); int startRecording(); int stopRecording(); int releaseRecordingFrame(const void *opaque); int autoFocus(); int cancelAutoFocus(); int takePicture(); int cancelPicture(); int takeLiveSnapshot(); int cancelLiveSnapshot(); char* getParameters(); int putParameters(char *); int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); int release(); int dump(int fd); int registerFaceImage(void *img_ptr, cam_pp_offline_src_config_t *config, int32_t &faceID); int openCamera(); int closeCamera(); int processAPI(qcamera_sm_evt_enum_t api, void *api_payload); int processEvt(qcamera_sm_evt_enum_t evt, void *evt_payload); int processSyncEvt(qcamera_sm_evt_enum_t evt, void *evt_payload); void lockAPI(); void waitAPIResult(qcamera_sm_evt_enum_t api_evt); void unlockAPI(); void signalAPIResult(qcamera_api_result_t *result); void signalEvtResult(qcamera_api_result_t *result); int updateThermalLevel(qcamera_thermal_level_enum_t level); // update entris to set parameters and check if restart is needed int updateParameters(const char *parms, bool &needRestart); // send request to server to set parameters int commitParameterChanges(); bool needDebugFps(); bool isCACEnabled(); bool needReprocess(); bool needRotationReprocess(); void debugShowVideoFPS(); void debugShowPreviewFPS(); void dumpFrameToFile(const void *data, uint32_t size, int index, int dump_type); void releaseSuperBuf(mm_camera_super_buf_t *super_buf); void playShutter(); void getThumbnailSize(cam_dimension_t &dim); int getJpegQuality(); int getJpegRotation(); QCameraExif *getExifData(); int32_t processAutoFocusEvent(cam_auto_focus_data_t &focus_data); int32_t processZoomEvent(cam_crop_data_t &crop_info); int32_t processPrepSnapshotDoneEvent(cam_prep_snapshot_state_t prep_snapshot_state); int32_t processJpegNotify(qcamera_jpeg_evt_payload_t *jpeg_job); int32_t sendEvtNotify(int32_t msg_type, int32_t ext1, int32_t ext2); int32_t sendDataNotify(int32_t msg_type, camera_memory_t *data, uint8_t index, camera_frame_metadata_t *metadata); int32_t addChannel(qcamera_ch_type_enum_t ch_type); int32_t startChannel(qcamera_ch_type_enum_t ch_type); int32_t stopChannel(qcamera_ch_type_enum_t ch_type); int32_t delChannel(qcamera_ch_type_enum_t ch_type); int32_t addPreviewChannel(); int32_t addSnapshotChannel(); int32_t addVideoChannel(); int32_t addZSLChannel(); int32_t addCaptureChannel(); int32_t addRawChannel(); int32_t addMetaDataChannel(); QCameraReprocessChannel *addOnlineReprocChannel(QCameraChannel *pInputChannel); QCameraReprocessChannel *addOfflineReprocChannel( cam_pp_offline_src_config_t &img_config, cam_pp_feature_config_t &pp_feature, stream_cb_routine stream_cb, void *userdata); int32_t addStreamToChannel(QCameraChannel *pChannel, cam_stream_type_t streamType, stream_cb_routine streamCB, void *userData); int32_t preparePreview(); void unpreparePreview(); QCameraChannel *getChannelByHandle(uint32_t channelHandle); mm_camera_buf_def_t *getSnapshotFrame(mm_camera_super_buf_t *recvd_frame); int32_t processFaceDetectionResult(cam_face_detection_data_t *fd_data); int32_t processHistogramStats(cam_hist_stats_t &stats_data); int32_t setHistogram(bool histogram_en); int32_t setFaceDetection(bool enabled); int32_t prepareHardwareForSnapshot(int32_t afNeeded); bool needProcessPreviewFrame() {return m_stateMachine.isPreviewRunning();}; bool isNoDisplayMode() {return mParameters.isNoDisplayMode();}; bool isZSLMode() {return mParameters.isZSLMode();}; uint8_t numOfSnapshotsExpected() {return mParameters.getNumOfSnapshots();}; uint8_t getBufNumRequired(cam_stream_type_t stream_type); static void camEvtHandle(uint32_t camera_handle, mm_camera_event_t *evt, void *user_data); static void jpegEvtHandle(jpeg_job_status_t status, uint32_t client_hdl, uint32_t jobId, mm_jpeg_output_t *p_buf, void *userdata); static void *evtNotifyRoutine(void *data); // functions for different data notify cb static void zsl_channel_cb(mm_camera_super_buf_t *recvd_frame, void *userdata); static void capture_channel_cb_routine(mm_camera_super_buf_t *recvd_frame, void *userdata); static void postproc_channel_cb_routine(mm_camera_super_buf_t *recvd_frame, void *userdata); static void nodisplay_preview_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void preview_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void postview_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void video_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void snapshot_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void raw_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void metadata_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void reprocess_stream_cb_routine(mm_camera_super_buf_t *frame, QCameraStream *stream, void *userdata); static void releaseCameraMemory(void *data, void *cookie); static void returnStreamBuffer(void *data, void *cookie); private: camera_device_t mCameraDevice; uint8_t mCameraId; mm_camera_vtbl_t *mCameraHandle; bool mCameraOpened; preview_stream_ops_t *mPreviewWindow; QCameraParameters mParameters; int32_t mMsgEnabled; int mStoreMetaDataInFrame; camera_notify_callback mNotifyCb; camera_data_callback mDataCb; camera_data_timestamp_callback mDataCbTimestamp; camera_request_memory mGetMemory; void *mCallbackCookie; QCameraStateMachine m_stateMachine; // state machine QCameraPostProcessor m_postprocessor; // post processor QCameraThermalAdapter &m_thermalAdapter; QCameraCbNotifier m_cbNotifier; pthread_mutex_t m_lock; pthread_cond_t m_cond; qcamera_api_result_t m_apiResult; pthread_mutex_t m_evtLock; pthread_cond_t m_evtCond; qcamera_api_result_t m_evtResult; QCameraChannel *m_channels[QCAMERA_CH_TYPE_MAX]; // array holding channel ptr bool m_bShutterSoundPlayed; // if shutter sound had been played // if auto focus is running, in other words, when auto_focus is called from service, // and beforeany focus callback/cancel_focus happens. This flag is not an indication // of whether lens is moving or not. bool m_bAutoFocusRunning; cam_autofocus_state_t m_currentFocusState; // If start_zsl_snapshot is called to notify camera daemon about zsl snapshot bool m_bStartZSLSnapshotCalled; power_module_t *m_pPowerModule; // power module int mDumpFrmCnt; // frame dump count int mDumpSkipCnt; // frame skip count }; }; // namespace qcamera #endif /* __QCAMERA2HARDWAREINTERFACE_H__ */