/* Copyright (c) 2016-2017, 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.
 *
 */

#define LOG_TAG "DualFOVPP"
// System dependencies
#include <dlfcn.h>
#include <utils/Errors.h>
#include <stdio.h>
#include <stdlib.h>
// Camera dependencies
#include "QCameraDualFOVPP.h"
#include "QCameraTrace.h"
#include "cam_intf.h"
extern "C" {
#include "mm_camera_dbg.h"
}

#define LIB_PATH_LENGTH 100

namespace qcamera {

/*===========================================================================
 * FUNCTION   : QCameraDualFOVPP
 *
 * DESCRIPTION: constructor of QCameraDualFOVPP.
 *
 * PARAMETERS : None
 *
 * RETURN     : None
 *==========================================================================*/
QCameraDualFOVPP::QCameraDualFOVPP()
    : QCameraHALPP()
{
    m_dlHandle = NULL;
    m_pCaps = NULL;
}

/*===========================================================================
 * FUNCTION   : ~QCameraDualFOVPP
 *
 * DESCRIPTION: destructor of QCameraDualFOVPP.
 *
 * PARAMETERS : None
 *
 * RETURN     : None
 *==========================================================================*/
QCameraDualFOVPP::~QCameraDualFOVPP()
{
}

/*===========================================================================
 * FUNCTION   : init
 *
 * DESCRIPTION: initialization of QCameraDualFOVPP
 *
 * PARAMETERS :
 *   @bufNotifyCb      : call back function after HALPP process
 *   @getOutputCb      : call back function to request output buffe
 *   @pUserData        : Parent of HALPP, i.e. QCameraPostProc
 *   @pStaticParam     : holds dual camera calibration data in an array and its size
 *                       (expected size is 264 bytes)
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraDualFOVPP::init(halPPBufNotify bufNotifyCb, halPPGetOutput getOutputCb,
        void *pUserData, void *pStaticParam)
{
    LOGD("E");
    int32_t rc = NO_ERROR;
    QCameraHALPP::init(bufNotifyCb, getOutputCb, pUserData);

    m_pCaps = (cam_capability_t *)pStaticParam;

    /* we should load 3rd libs here, with dlopen/dlsym */
    doDualFovPPInit();

    LOGD("X");
    return rc;
}

/*===========================================================================
 * FUNCTION   : deinit
 *
 * DESCRIPTION: de initialization of QCameraDualFOVPP
 *
 * PARAMETERS : None
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraDualFOVPP::deinit()
{
    int32_t rc = NO_ERROR;
    LOGD("E");

    m_dlHandle = NULL;

    QCameraHALPP::deinit();
    LOGD("X");
    return rc;
}

/*===========================================================================
 * FUNCTION   : start
 *
 * DESCRIPTION: starting QCameraDualFOVPP
 *
 * PARAMETERS :
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraDualFOVPP::start()
{
    int32_t rc = NO_ERROR;
    LOGD("E");

    rc = QCameraHALPP::start();

    LOGD("X");
    return rc;
}


/*===========================================================================
 * FUNCTION   : feedInput
 *
 * DESCRIPTION: function to feed input data.
 *              Enqueue the frame index to inputQ if it is new frame
 *              Also, add the input image data to frame hash map
 *
 * PARAMETERS :
 *   @pInput  : ptr to input data
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraDualFOVPP::feedInput(qcamera_hal_pp_data_t *pInputData)
{
    int32_t rc = NO_ERROR;
    LOGD("E");
    if (NULL != pInputData) {
        QCameraStream* pSnapshotStream = NULL;
        mm_camera_buf_def_t *pInputSnapshotBuf = getSnapshotBuf(pInputData, pSnapshotStream);
        if (pInputSnapshotBuf != NULL) {
            uint32_t frameIndex = pInputSnapshotBuf->frame_idx;
            std::vector<qcamera_hal_pp_data_t*> *pVector = getFrameVector(frameIndex);
            if(pVector == NULL) {
                LOGD("insert new frame index = %d", frameIndex);
                uint32_t *pFrameIndex = new uint32_t;
                *pFrameIndex = frameIndex;
                // new the vector first
                pVector = new std::vector<qcamera_hal_pp_data_t*>(WIDE_TELE_CAMERA_NUMBER);
                pVector->at(WIDE_INPUT) = NULL;
                pVector->at(TELE_INPUT) = NULL;
                // Add vector to the hash map
                m_frameMap[frameIndex] = pVector;
                // Enqueue the frame index (i.e. key of vector) to queue
                if (false == m_iuputQ.enqueue((void*)pFrameIndex)) {
                    LOGE("Input Q is not active!!!");
                    releaseData(pInputData);
                    m_frameMap.erase(frameIndex);
                    delete pFrameIndex;
                    delete pVector;
                    rc = INVALID_OPERATION;
                    return rc;
                }
            }
            pInputData->frameIndex = frameIndex;
            // Check if frame is from main wide camera
            bool bIsMain = true;
            uint32_t mainHandle = get_main_camera_handle(
                    pInputData->src_reproc_frame->camera_handle);
            if (mainHandle == 0) {
                bIsMain = false;
            }
            LOGD("mainHandle = %d, is main frame = %d", mainHandle, bIsMain);
            // Add input data to vector
            if (bIsMain) {
                pVector->at(WIDE_INPUT) = pInputData;
            } else {
                pVector->at(TELE_INPUT) = pInputData;
            }

            // request output buffer only if both wide and tele input data are recieved
            if (pVector->at(0) != NULL && pVector->at(1) != NULL) {
                m_halPPGetOutputCB(frameIndex, m_pQCameraPostProc);
            }
        }
    } else {
        LOGE("pInput is NULL");
        rc = UNEXPECTED_NULL;
    }
    LOGD("X");
    return rc;
}

/*===========================================================================
 * FUNCTION   : feedOutput
 *
 * DESCRIPTION: function to feed output buffer and metadata
 *
 * PARAMETERS :
 *   @pOutput     : ptr to output data
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraDualFOVPP::feedOutput(qcamera_hal_pp_data_t *pOutputData)
{
    int32_t rc = NO_ERROR;
    LOGD("E");
    if (NULL != pOutputData) {
        uint32_t frameIndex = pOutputData->frameIndex;
        std::vector<qcamera_hal_pp_data_t*> *pVector = getFrameVector(frameIndex);
        // Get the main (Wide) input frame in order to get output buffer len,
        // and copy metadata buffer.
        if (pVector != NULL && pVector->at(WIDE_INPUT) != NULL) {
            qcamera_hal_pp_data_t *pInputData = pVector->at(WIDE_INPUT);
            mm_camera_super_buf_t *pInputFrame = pInputData->frame;
            QCameraStream* pSnapshotStream = NULL;
            QCameraStream* pMetadataStream = NULL;
            mm_camera_buf_def_t *pInputSnapshotBuf = getSnapshotBuf(pInputData, pSnapshotStream);
            mm_camera_buf_def_t *pInputMetadataBuf = getMetadataBuf(pInputData, pMetadataStream);
            mm_camera_super_buf_t *pOutputFrame = pOutputData->frame;
            mm_camera_buf_def_t *pOutputBufDefs = pOutputData->bufs;

            if (pInputSnapshotBuf == NULL || pInputMetadataBuf == NULL) {
                LOGE("cannot get sanpshot or metadata buf def");
                releaseData(pOutputData);
                return UNEXPECTED_NULL;
            }
            if (pSnapshotStream == NULL || pMetadataStream == NULL) {
                LOGE("cannot get sanpshot or metadata stream");
                releaseData(pOutputData);
                return UNEXPECTED_NULL;
            }

            // Copy main input frame info to output frame
            pOutputFrame->camera_handle = pInputFrame->camera_handle;
            pOutputFrame->ch_id = pInputFrame->ch_id;
            pOutputFrame->num_bufs = HAL_PP_NUM_BUFS;//snapshot and metadata
            pOutputFrame->bUnlockAEC = pInputFrame->bUnlockAEC;
            pOutputFrame->bReadyForPrepareSnapshot = pInputFrame->bReadyForPrepareSnapshot;

            // Reconstruction of output_frame super buffer
            pOutputFrame->bufs[0] = &pOutputBufDefs[0];
            pOutputFrame->bufs[1] = &pOutputBufDefs[1];

            // Allocate heap buffer for output image frame
            cam_frame_len_offset_t offset;
            memset(&offset, 0, sizeof(cam_frame_len_offset_t));
            LOGD("pInputSnapshotBuf->frame_len = %d", pInputSnapshotBuf->frame_len);
            rc = pOutputData->snapshot_heap->allocate(1, pInputSnapshotBuf->frame_len);
            if (rc < 0) {
                LOGE("Unable to allocate heap memory for image buf");
                releaseData(pOutputData);
                return NO_MEMORY;
            }
            pSnapshotStream->getFrameOffset(offset);
            memcpy(&pOutputBufDefs[0], pInputSnapshotBuf, sizeof(mm_camera_buf_def_t));
            LOGD("pOutputFrame->bufs[0]->fd = %d, pOutputFrame->bufs[0]->buffer = %x",
                    pOutputFrame->bufs[0]->fd, pOutputFrame->bufs[0]->buffer);
            pOutputData->snapshot_heap->getBufDef(offset, pOutputBufDefs[0], 0);
            LOGD("pOutputFrame->bufs[0]->fd = %d, pOutputFrame->bufs[0]->buffer = %x",
                    pOutputFrame->bufs[0]->fd, pOutputFrame->bufs[0]->buffer);

            // Allocate heap buffer for output metadata
            LOGD("pInputMetadataBuf->frame_len = %d", pInputMetadataBuf->frame_len);
            rc = pOutputData->metadata_heap->allocate(1, pInputMetadataBuf->frame_len);
            if (rc < 0) {
                LOGE("Unable to allocate heap memory for metadata buf");
                releaseData(pOutputData);
                return NO_MEMORY;
            }
            memset(&offset, 0, sizeof(cam_frame_len_offset_t));
            pMetadataStream->getFrameOffset(offset);
            memcpy(&pOutputBufDefs[1], pInputMetadataBuf, sizeof(mm_camera_buf_def_t));
            pOutputData->metadata_heap->getBufDef(offset, pOutputBufDefs[1], 0);
            // copy the whole metadata
            memcpy(pOutputBufDefs[1].buffer, pInputMetadataBuf->buffer,
                    pInputMetadataBuf->frame_len);

            // Enqueue output_data to m_outgoingQ
            if (false == m_outgoingQ.enqueue((void *)pOutputData)) {
                LOGE("outgoing Q is not active!!!");
                releaseData(pOutputData);
                rc = INVALID_OPERATION;
            }
        }
    } else {
        LOGE("pOutput is NULL");
        rc = UNEXPECTED_NULL;
    }
    LOGD("X");
    return rc;
}

/*===========================================================================
 * FUNCTION   : process
 *
 * DESCRIPTION: function to start CP FOV blending process
 *
 * PARAMETERS : None
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraDualFOVPP::process()
{
    int32_t rc = NO_ERROR;

    /* dump in/out frames */
    char prop[PROPERTY_VALUE_MAX];
    memset(prop, 0, sizeof(prop));
    property_get("persist.camera.dualfov.dumpimg", prop, "0");
    int dumpimg = atoi(prop);

    LOGD("E");

    // TODO: dequeue from m_inputQ and start process logic
    // Start the blending process when it is ready
    if (canProcess()) {
        LOGI("start Dual FOV process");
        uint32_t *pFrameIndex = (uint32_t *)m_iuputQ.dequeue();
        if (pFrameIndex == NULL) {
            LOGE("frame index is null");
            return UNEXPECTED_NULL;
        }
        uint32_t frameIndex = *pFrameIndex;
        std::vector<qcamera_hal_pp_data_t*> *pVector = getFrameVector(frameIndex);
        // Search vector of input frames in frame map
        if (pVector == NULL) {
            LOGE("Cannot find vecotr of input frames");
            return UNEXPECTED_NULL;
        }
        // Get input and output frame buffer
        qcamera_hal_pp_data_t *pInputMainData =
                (qcamera_hal_pp_data_t *)pVector->at(WIDE_INPUT);
        if (pInputMainData == NULL) {
            LOGE("Cannot find input main data");
            return UNEXPECTED_NULL;
        }
        if (pInputMainData->src_reproc_frame == NULL) {
            LOGI("process pInputMainData->src_reproc_frame = NULL");
        }
        //mm_camera_super_buf_t *input_main_frame = input_main_data->frame;
        qcamera_hal_pp_data_t *pInputAuxData =
                (qcamera_hal_pp_data_t *)pVector->at(TELE_INPUT);
        if (pInputAuxData == NULL) {
            LOGE("Cannot find input aux data");
            return UNEXPECTED_NULL;
        }

        //mm_camera_super_buf_t *input_aux_frame = input_aux_data->frame;
        qcamera_hal_pp_data_t *pOutputData =
                (qcamera_hal_pp_data_t*)m_outgoingQ.dequeue();
        if (pOutputData == NULL) {
            LOGE("Cannot find output data");
            return UNEXPECTED_NULL;
        }

        QCameraStream* pMainSnapshotStream = NULL;
        QCameraStream* pMainMetadataStream = NULL;
        QCameraStream* pAuxSnapshotStream  = NULL;
        QCameraStream* pAuxMetadataStream  = NULL;

        mm_camera_buf_def_t *main_snapshot_buf =
                getSnapshotBuf(pInputMainData, pMainSnapshotStream);
        if (main_snapshot_buf == NULL) {
            LOGE("main_snapshot_buf is NULL");
            return UNEXPECTED_NULL;
        }
        mm_camera_buf_def_t *main_meta_buf = getMetadataBuf(pInputMainData, pMainMetadataStream);
        if (main_meta_buf == NULL) {
            LOGE("main_meta_buf is NULL");
            return UNEXPECTED_NULL;
        }
        mm_camera_buf_def_t *aux_snapshot_buf = getSnapshotBuf(pInputAuxData, pAuxSnapshotStream);
        if (aux_snapshot_buf == NULL) {
            LOGE("aux_snapshot_buf is NULL");
            return UNEXPECTED_NULL;
        }
        mm_camera_buf_def_t *aux_meta_buf = getMetadataBuf(pInputAuxData, pAuxMetadataStream);
        if (aux_meta_buf == NULL) {
            LOGE("aux_meta_buf is NULL");
            return UNEXPECTED_NULL;
        }

        mm_camera_super_buf_t *output_frame = pOutputData->frame;
        mm_camera_buf_def_t *output_snapshot_buf = output_frame->bufs[0];

        // Use offset info from reproc stream
        if (pMainSnapshotStream == NULL) {
            LOGE("pMainSnapshotStream is NULL");
            return UNEXPECTED_NULL;
        }
        cam_frame_len_offset_t frm_offset;
        pMainSnapshotStream->getFrameOffset(frm_offset);
        LOGI("Stream type:%d, stride:%d, scanline:%d, frame len:%d",
                pMainSnapshotStream->getMyType(),
                frm_offset.mp[0].stride, frm_offset.mp[0].scanline,
                frm_offset.frame_len);

        if (dumpimg) {
            dumpYUVtoFile((uint8_t *)main_snapshot_buf->buffer, frm_offset,
                    main_snapshot_buf->frame_idx, "wide");
            dumpYUVtoFile((uint8_t *)aux_snapshot_buf->buffer,  frm_offset,
                    aux_snapshot_buf->frame_idx,  "tele");
        }

        //Get input and output parameter
        dualfov_input_params_t inParams;
        if (pAuxSnapshotStream == NULL) {
            LOGE("pAuxSnapshotStream is NULL");
            return UNEXPECTED_NULL;
        }
        getInputParams(main_meta_buf, aux_meta_buf, pMainSnapshotStream, pAuxSnapshotStream,
                inParams);
        dumpInputParams(inParams);

        doDualFovPPProcess((const uint8_t *)main_snapshot_buf->buffer,
                        (const uint8_t *)aux_snapshot_buf->buffer,
                        inParams,
                        (uint8_t *)output_snapshot_buf->buffer);

        if (dumpimg) {
            dumpYUVtoFile((uint8_t *)output_snapshot_buf->buffer, frm_offset,
                    main_snapshot_buf->frame_idx, "out");
        }

        /* clean and invalidate caches, for input and output buffers*/
        pOutputData->snapshot_heap->cleanInvalidateCache(0);

        QCameraMemory *pMem = (QCameraMemory *)main_snapshot_buf->mem_info;
        pMem->invalidateCache(main_snapshot_buf->buf_idx);

        pMem = (QCameraMemory *)aux_snapshot_buf->mem_info;
        pMem->invalidateCache(aux_snapshot_buf->buf_idx);


        // Calling cb function to return output_data after processed.
        m_halPPBufNotifyCB(pOutputData, m_pQCameraPostProc);

        // also send input buffer to postproc.
        m_halPPBufNotifyCB(pInputMainData, m_pQCameraPostProc);
        m_halPPBufNotifyCB(pInputAuxData, m_pQCameraPostProc);
        //releaseData(pInputMainData);
        //releaseData(pInputAuxData);

        // Release internal resource
        m_frameMap.erase(frameIndex);
        delete pFrameIndex;
        delete pVector;
    }
    LOGD("X");
    return rc;
}

/*===========================================================================
 * FUNCTION   : getSnapshotBuf
 *
 * DESCRIPTION: function to get snapshot buf def and the stream from frame
 * PARAMETERS :
 *   @pData           : input frame super buffer
 *   @pSnapshotStream : stream of snapshot that found
 * RETURN             : snapshot buf def
 *==========================================================================*/
mm_camera_buf_def_t* QCameraDualFOVPP::getSnapshotBuf(qcamera_hal_pp_data_t* pData,
        QCameraStream* &pSnapshotStream)
{
    mm_camera_buf_def_t *pBufDef = NULL;
    if (pData == NULL) {
        LOGE("Cannot find input frame super buffer");
        return pBufDef;
    }
    mm_camera_super_buf_t *pFrame = pData->frame;
    QCameraChannel *pChannel = m_pQCameraPostProc->getChannelByHandle(pFrame->ch_id);
    if (pChannel == NULL) {
        LOGE("Cannot find channel");
        return pBufDef;
    }
    // Search for input snapshot frame buf
    for (uint32_t i = 0; i < pFrame->num_bufs; i++) {
        pSnapshotStream = pChannel->getStreamByHandle(pFrame->bufs[i]->stream_id);
        if (pSnapshotStream != NULL) {
            if (pSnapshotStream->isTypeOf(CAM_STREAM_TYPE_SNAPSHOT) ||
                pSnapshotStream->isOrignalTypeOf(CAM_STREAM_TYPE_SNAPSHOT)) {
                    pBufDef = pFrame->bufs[i];
                    break;
            }
        }
    }
    return pBufDef;
}

/*===========================================================================
 * FUNCTION   : getMetadataBuf
 *
 * DESCRIPTION: function to get metadata buf def and the stream from frame
 * PARAMETERS :
 *   @pData     : input frame super buffer
 *   @pMetadataStream : stream of metadata that found
 * RETURN     : metadata buf def
 *==========================================================================*/
mm_camera_buf_def_t* QCameraDualFOVPP::getMetadataBuf(qcamera_hal_pp_data_t *pData,
        QCameraStream* &pMetadataStream)
{
    mm_camera_buf_def_t *pBufDef = NULL;
    if (pData == NULL) {
        LOGE("Cannot find input frame super buffer");
        return pBufDef;
    }
    mm_camera_super_buf_t* pFrame = pData->frame;
    QCameraChannel *pChannel =
            m_pQCameraPostProc->getChannelByHandle(pData->src_reproc_frame->ch_id);
    LOGD("src_reproc_frame num_bufs = %d", pFrame->num_bufs);
    if (pChannel == NULL) {
            LOGE("Cannot find src_reproc_frame channel");
            return pBufDef;
    }
    for (uint32_t i = 0;
            (i < pData->src_reproc_frame->num_bufs); i++) {
        pMetadataStream = pChannel->getStreamByHandle(pData->src_reproc_frame->bufs[i]->stream_id);
        if (pData->src_reproc_frame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
            pBufDef = pData->src_reproc_frame->bufs[i];
            LOGD("find metadata stream and buf from src_reproc_frame");
            break;
        }
    }
    if (pBufDef == NULL) {
        LOGD("frame num_bufs = %d", pFrame->num_bufs);
        pChannel = m_pQCameraPostProc->getChannelByHandle(pFrame->ch_id);
        if (pChannel == NULL) {
            LOGE("Cannot find frame channel");
            return pBufDef;
        }
        for (uint32_t i = 0; i < pFrame->num_bufs; i++) {
            pMetadataStream = pChannel->getStreamByHandle(pFrame->bufs[i]->stream_id);
            if (pMetadataStream != NULL) {
                LOGD("bufs[%d] stream_type = %d", i, pFrame->bufs[i]->stream_type);
                if (pFrame->bufs[i]->stream_type == CAM_STREAM_TYPE_METADATA) {
                    pBufDef = pFrame->bufs[i];
                    break;
                }
            }
        }
    }
    return pBufDef;
}

/*===========================================================================
 * FUNCTION   : canProcess
 *
 * DESCRIPTION: function to release internal resources
 * RETURN     : If CP FOV can start blending process
 *==========================================================================*/
bool QCameraDualFOVPP::canProcess()
{
    LOGD("E");
    bool ready = false;
    if(!m_iuputQ.isEmpty() && !m_outgoingQ.isEmpty()) {
        ready = true;
    }
    LOGD("X");
    return ready;
}

/*===========================================================================
 * FUNCTION   : getInputParams
 *
 * DESCRIPTION: Helper function to get input params from input metadata
 *==========================================================================*/
void QCameraDualFOVPP::getInputParams(mm_camera_buf_def_t *pMainMetaBuf,
        mm_camera_buf_def_t *pAuxMetaBuf, QCameraStream* pMainSnapshotStream,
        QCameraStream* pAuxSnapshotStream, dualfov_input_params_t& inParams)
{
    LOGD("E");
    memset(&inParams, 0, sizeof(dualfov_input_params_t));
    metadata_buffer_t *pMainMeta = (metadata_buffer_t *)pMainMetaBuf->buffer;
    metadata_buffer_t *pAuxMeta = (metadata_buffer_t *)pAuxMetaBuf->buffer;

    // Wide frame size
    cam_frame_len_offset_t offset;
    pMainSnapshotStream->getFrameOffset(offset);
    inParams.wide.width     = offset.mp[0].width;
    inParams.wide.height    = offset.mp[0].height;
    inParams.wide.stride    = offset.mp[0].stride;
    inParams.wide.scanline  = offset.mp[0].scanline;
    inParams.wide.frame_len = offset.frame_len;

    // Tele frame size
    pAuxSnapshotStream->getFrameOffset(offset);
    inParams.tele.width     = offset.mp[0].width;
    inParams.tele.height    = offset.mp[0].height;
    inParams.tele.stride    = offset.mp[0].stride;
    inParams.tele.scanline  = offset.mp[0].scanline;
    inParams.tele.frame_len = offset.frame_len;

    // user_zoom
    int32_t zoom_level = -1; // 0 means zoom 1x.
    IF_META_AVAILABLE(int32_t, userZoom, CAM_INTF_PARM_ZOOM, pMainMeta) {
        zoom_level = *userZoom;
        LOGD("zoom level in main meta:%d", zoom_level);
    }
    inParams.user_zoom= getUserZoomRatio(zoom_level);
    LOGI("dual fov total zoom ratio: %d", inParams.user_zoom);

    IF_META_AVAILABLE(int32_t, auxUserZoom, CAM_INTF_PARM_ZOOM, pAuxMeta) {
        LOGD("zoom level in aux meta:%d", *auxUserZoom);
    }

    IF_META_AVAILABLE(uint32_t, afState, CAM_INTF_META_AF_STATE, pMainMeta) {
        if (((*afState) == CAM_AF_STATE_FOCUSED_LOCKED) ||
            ((*afState) == CAM_AF_STATE_PASSIVE_FOCUSED)) {
            inParams.af_status = AF_STATUS_VALID;
        } else {
            inParams.af_status = AF_STATUS_INVALID;
        }
        LOGD("af state:%d, output af status:%d", *afState, inParams.af_status);
    }

    IF_META_AVAILABLE(uint32_t, auxAfState, CAM_INTF_META_AF_STATE, pAuxMeta) {
        int aux_af_status = 0;
        if (((*auxAfState) == CAM_AF_STATE_FOCUSED_LOCKED) ||
            ((*auxAfState) == CAM_AF_STATE_PASSIVE_FOCUSED)) {
            aux_af_status = AF_STATUS_VALID;
        } else {
            aux_af_status = AF_STATUS_INVALID;
        }
        LOGD("aux af state:%d, output af status:%d", *auxAfState, aux_af_status);
    }


    LOGD("X");
}


int32_t QCameraDualFOVPP::doDualFovPPInit()
{
    LOGD("E");
    int rc = NO_ERROR;

    LOGD("X");
    return rc;
}

int32_t QCameraDualFOVPP::doDualFovPPProcess(const uint8_t* pWide, const uint8_t* pTele,
                                                    dualfov_input_params_t inParams,
                                                    uint8_t* pOut)
{
    LOGW("E.");

    // trace begin

    // half image from main, and half image from tele

    // Y
    memcpy(pOut, pWide, inParams.wide.stride * inParams.wide.scanline / 2);
    memcpy(pOut  + inParams.wide.stride * inParams.wide.scanline / 2,
           pTele + inParams.wide.stride * inParams.wide.scanline / 2,
           inParams.wide.stride * inParams.wide.scanline / 2);

    // UV
    uint32_t uv_offset = inParams.wide.stride * inParams.wide.scanline;
    memcpy(pOut  + uv_offset,
           pWide + uv_offset,
           inParams.wide.stride * (inParams.wide.scanline / 2) / 2);
    memcpy(pOut  + uv_offset + inParams.wide.stride * (inParams.wide.scanline / 2) / 2,
           pTele + uv_offset + inParams.wide.stride * (inParams.wide.scanline / 2) / 2,
           inParams.wide.stride * (inParams.wide.scanline / 2) / 2);

    // trace end

    LOGW("X.");
    return NO_ERROR;
}

uint32_t QCameraDualFOVPP::getUserZoomRatio(int32_t zoom_level)
{
    uint32_t zoom_ratio = 4096;

    LOGD("E. input zoom level:%d", zoom_level);

    if (zoom_level < 0) {
        LOGW("invalid zoom evel!");
        /* got the zoom value from QCamera2HWI Parameters */
        zoom_level = 0;
    }

    // user_zoom_ratio = qcom_zoom_ratio * 4096 / 100
    if (m_pCaps != NULL) {
        zoom_ratio *= m_pCaps->zoom_ratio_tbl[zoom_level];
        zoom_ratio /= 100;
        LOGD("converted zoom ratio:%d", zoom_ratio);
    }

    LOGD("X. zoom_ratio:%d", zoom_ratio);
    return zoom_ratio;
}

void QCameraDualFOVPP::dumpYUVtoFile(const uint8_t* pBuf, cam_frame_len_offset_t offset, uint32_t idx, const char* name_prefix)
{
    LOGD("E.");
    char filename[256];

    snprintf(filename, sizeof(filename), QCAMERA_DUMP_FRM_LOCATION"%s_%dx%d_%d.yuv",
                name_prefix, offset.mp[0].stride, offset.mp[0].scanline, idx);

    QCameraHALPP::dumpYUVtoFile(pBuf,(const char*)filename, offset.frame_len);

    LOGD("X.");
}

void QCameraDualFOVPP::dumpInputParams(const dualfov_input_params_t& p)
{
    LOGD("E");

    const cam_frame_size_t* s = NULL;

    s = &p.wide;
    LOGD("wide frame size: %d, %d, stride:%d, scanline:%d",
            s->width, s->height, s->stride, s->scanline);

    s = &p.tele;
    LOGD("wide frame size: %d, %d, stride:%d, scanline:%d",
            s->width, s->height, s->stride, s->scanline);

    LOGD("zoom ratio: %f", p.user_zoom / 4096.0);
    LOGD("X");
}


/*===========================================================================
 * FUNCTION   : dumpOISData
 *
 * DESCRIPTION: Read Sensor OIS data from metadata and dump it
 *
 * PARAMETERS :
 * @pMetadata : Frame metadata
 *
 * RETURN     : None
 *
 *==========================================================================*/
void QCameraDualFOVPP::dumpOISData(metadata_buffer_t*  pMetadata)
{
    if (!pMetadata) {
        LOGD("OIS data not available");
        return;
    }

    IF_META_AVAILABLE(cam_ois_data_t, pOisData, CAM_INTF_META_OIS_READ_DATA, pMetadata) {
        LOGD("Ois Data: data size: %d", pOisData->size);
        uint8_t *data = pOisData->data;
        if (pOisData->size == 8) {
            LOGD("Ois Data Buffer : %d %d %d %d %d %d %d %d ",
                    data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
        }
    }
    return;
}


} // namespace qcamera