msmcobalt/QCamera2/HAL/QCameraPostProc.h

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