diff options
Diffstat (limited to 'camera/QCamera2/HAL/QCameraPostProc.h')
| -rw-r--r-- | camera/QCamera2/HAL/QCameraPostProc.h | 250 |
1 files changed, 250 insertions, 0 deletions
diff --git a/camera/QCamera2/HAL/QCameraPostProc.h b/camera/QCamera2/HAL/QCameraPostProc.h new file mode 100644 index 0000000..5c56214 --- /dev/null +++ b/camera/QCamera2/HAL/QCameraPostProc.h @@ -0,0 +1,250 @@ +/* Copyright (c) 2012-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 __QCAMERA_POSTPROC_H__ +#define __QCAMERA_POSTPROC_H__ + +// Camera dependencies +#include "QCamera2HWI.h" + +extern "C" { +#include "mm_camera_interface.h" +#include "mm_jpeg_interface.h" +} + +#define MAX_JPEG_BURST 2 +#define CAM_PP_CHANNEL_MAX 8 + +namespace qcamera { + +class QCameraExif; +class QCamera2HardwareInterface; + +typedef struct { + uint32_t jobId; // job ID + uint32_t client_hdl; // handle of jpeg client (obtained when open jpeg) + mm_camera_super_buf_t *src_frame;// source frame (need to be returned back to kernel + //after done) + mm_camera_super_buf_t *src_reproc_frame; // original source + //frame for reproc if not NULL + metadata_buffer_t *metadata; // source frame metadata + bool reproc_frame_release; // false release original buffer, true don't release it + mm_camera_buf_def_t *src_reproc_bufs; + QCameraExif *pJpegExifObj; + uint8_t offline_buffer; + mm_camera_buf_def_t *offline_reproc_buf; //HAL processed buffer +} qcamera_jpeg_data_t; + + +typedef struct { + int8_t reprocCount; + mm_camera_super_buf_t *src_frame; // source frame that needs post process + mm_camera_super_buf_t *src_reproc_frame;// source frame (need to be + //returned back to kernel after done) +}qcamera_pp_request_t; + +typedef struct { + uint32_t jobId; // job ID + int8_t reprocCount; //Current pass count + int8_t ppChannelIndex; //Reprocess channel object index + mm_camera_super_buf_t *src_frame;// source frame + bool reproc_frame_release; // false release original buffer + // true don't release it + mm_camera_buf_def_t *src_reproc_bufs; + mm_camera_super_buf_t *src_reproc_frame;// source frame (need to be + //returned back to kernel after done) + uint8_t offline_buffer; + mm_camera_buf_def_t *offline_reproc_buf; //HAL processed buffer +} qcamera_pp_data_t; + +typedef struct { + uint32_t jobId; // job ID (obtained when start_jpeg_job) + jpeg_job_status_t status; // jpeg encoding status + mm_jpeg_output_t out_data; // ptr to jpeg output buf +} qcamera_jpeg_evt_payload_t; + +typedef struct { + camera_memory_t * data; // ptr to data memory struct + mm_camera_super_buf_t * frame; // ptr to frame + QCameraMemory * streamBufs; //ptr to stream buffers + bool unlinkFile; // unlink any stored buffers on error +} qcamera_release_data_t; + +typedef struct { + int32_t msg_type; // msg type of data notify + camera_memory_t * data; // ptr to data memory struct + unsigned int index; // index of the buf in the whole buffer + camera_frame_metadata_t *metadata; // ptr to meta data + qcamera_release_data_t release_data; // any data needs to be release after notify +} qcamera_data_argm_t; + +#define MAX_EXIF_TABLE_ENTRIES 17 +class QCameraExif +{ +public: + QCameraExif(); + virtual ~QCameraExif(); + + int32_t addEntry(exif_tag_id_t tagid, + exif_tag_type_t type, + uint32_t count, + void *data); + uint32_t getNumOfEntries() {return m_nNumEntries;}; + QEXIF_INFO_DATA *getEntries() {return m_Entries;}; + +private: + QEXIF_INFO_DATA m_Entries[MAX_EXIF_TABLE_ENTRIES]; // exif tags for JPEG encoder + uint32_t m_nNumEntries; // number of valid entries +}; + +class QCameraPostProcessor +{ +public: + QCameraPostProcessor(QCamera2HardwareInterface *cam_ctrl); + virtual ~QCameraPostProcessor(); + + int32_t init(jpeg_encode_callback_t jpeg_cb, void *user_data); + int32_t deinit(); + int32_t start(QCameraChannel *pSrcChannel); + int32_t stop(); + bool validatePostProcess(mm_camera_super_buf_t *frame); + int32_t processData(mm_camera_super_buf_t *frame); + int32_t processRawData(mm_camera_super_buf_t *frame); + int32_t processPPData(mm_camera_super_buf_t *frame); + int32_t processJpegEvt(qcamera_jpeg_evt_payload_t *evt); + int32_t getJpegPaddingReq(cam_padding_info_t &padding_info); + QCameraReprocessChannel * getReprocChannel(uint8_t index); + inline bool getJpegMemOpt() {return mJpegMemOpt;} + inline void setJpegMemOpt(bool val) {mJpegMemOpt = val;} + int32_t setJpegHandle(mm_jpeg_ops_t *pJpegHandle, + mm_jpeg_mpo_ops_t* pJpegMpoHandle, uint32_t clientHandle); + int32_t createJpegSession(QCameraChannel *pSrcChannel); + + int8_t getPPChannelCount() {return mPPChannelCount;}; + mm_camera_buf_def_t *getOfflinePPInputBuffer( + mm_camera_super_buf_t *src_frame); + QCameraMemory *mOfflineDataBufs; + +private: + int32_t sendDataNotify(int32_t msg_type, + camera_memory_t *data, + uint8_t index, + camera_frame_metadata_t *metadata, + qcamera_release_data_t *release_data, + uint32_t super_buf_frame_idx = 0); + int32_t sendEvtNotify(int32_t msg_type, int32_t ext1, int32_t ext2); + qcamera_jpeg_data_t *findJpegJobByJobId(uint32_t jobId); + mm_jpeg_color_format getColorfmtFromImgFmt(cam_format_t img_fmt); + mm_jpeg_format_t getJpegImgTypeFromImgFmt(cam_format_t img_fmt); + int32_t getJpegEncodingConfig(mm_jpeg_encode_params_t& encode_parm, + QCameraStream *main_stream, + QCameraStream *thumb_stream); + int32_t encodeData(qcamera_jpeg_data_t *jpeg_job_data, + uint8_t &needNewSess); + int32_t queryStreams(QCameraStream **main, + QCameraStream **thumb, + QCameraStream **reproc, + mm_camera_buf_def_t **main_image, + mm_camera_buf_def_t **thumb_image, + mm_camera_super_buf_t *main_frame, + mm_camera_super_buf_t *reproc_frame); + int32_t syncStreamParams(mm_camera_super_buf_t *frame, + mm_camera_super_buf_t *reproc_frame); + void releaseSuperBuf(mm_camera_super_buf_t *super_buf); + void releaseSuperBuf(mm_camera_super_buf_t *super_buf, + cam_stream_type_t stream_type); + static void releaseNotifyData(void *user_data, + void *cookie, + int32_t cb_status); + void releaseJpegJobData(qcamera_jpeg_data_t *job); + static void releaseSaveJobData(void *data, void *user_data); + static void releaseRawData(void *data, void *user_data); + int32_t processRawImageImpl(mm_camera_super_buf_t *recvd_frame); + + static void releaseJpegData(void *data, void *user_data); + static void releasePPInputData(void *data, void *user_data); + static void releaseOngoingPPData(void *data, void *user_data); + + static void *dataProcessRoutine(void *data); + static void *dataSaveRoutine(void *data); + + int32_t setYUVFrameInfo(mm_camera_super_buf_t *recvd_frame); + static bool matchJobId(void *data, void *user_data, void *match_data); + static int getJpegMemory(omx_jpeg_ouput_buf_t *out_buf); + static int releaseJpegMemory(omx_jpeg_ouput_buf_t *out_buf); + + int32_t doReprocess(); + int32_t stopCapture(); +private: + QCamera2HardwareInterface *m_parent; + jpeg_encode_callback_t mJpegCB; + void * mJpegUserData; + mm_jpeg_ops_t mJpegHandle; + mm_jpeg_mpo_ops_t mJpegMpoHandle; // handle for mpo composition for dualcam + uint32_t mJpegClientHandle; + uint32_t mJpegSessionId; + + void * m_pJpegOutputMem[MM_JPEG_MAX_BUF]; + QCameraExif * m_pJpegExifObj; + uint32_t m_bThumbnailNeeded; + + int8_t mPPChannelCount; + QCameraReprocessChannel *mPPChannels[CAM_PP_CHANNEL_MAX]; + + camera_memory_t * m_DataMem; // save frame mem pointer + + int8_t m_bInited; // if postproc is inited + + QCameraQueue m_inputPPQ; // input queue for postproc + QCameraQueue m_ongoingPPQ; // ongoing postproc queue + QCameraQueue m_inputJpegQ; // input jpeg job queue + QCameraQueue m_ongoingJpegQ; // ongoing jpeg job queue + QCameraQueue m_inputRawQ; // input raw job queue + QCameraQueue m_inputSaveQ; // input save job queue + QCameraCmdThread m_dataProcTh; // thread for data processing + QCameraCmdThread m_saveProcTh; // thread for storing buffers + uint32_t mSaveFrmCnt; // save frame counter + static const char *STORE_LOCATION; // path for storing buffers + bool mUseSaveProc; // use store thread + bool mUseJpegBurst; // use jpeg burst encoding mode + bool mJpegMemOpt; + uint32_t m_JpegOutputMemCount; + uint8_t mNewJpegSessionNeeded; + int32_t m_bufCountPPQ; + Vector<mm_camera_buf_def_t *> m_InputMetadata; // store input metadata buffers for AOST cases + size_t m_PPindex; // counter for each incoming AOST buffer + pthread_mutex_t m_reprocess_lock; // lock to ensure reprocess job is not freed early. + +public: + cam_dimension_t m_dst_dim; +}; + +}; // namespace qcamera + +#endif /* __QCAMERA_POSTPROC_H__ */ |