/* Copyright (c) 2017-2018, 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 "ClearSight"
// System dependencies
#include <dlfcn.h>
#include <utils/Errors.h>
#include <stdio.h>
#include <stdlib.h>
// Camera dependencies
#include "QCameraClearSight.h"
#include "QCameraTrace.h"
#include "cam_intf.h"
extern "C" {
#include "mm_camera_dbg.h"
}

#define NUM_CLEARSIGHT_BUFS 3

namespace qcamera {

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

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

/*===========================================================================
 * FUNCTION   : init
 *
 * DESCRIPTION: initialization of QCameraClearSight
 *
 * 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
 *              non-zero failure code
 *==========================================================================*/
int32_t QCameraClearSight::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;

    doClearSightInit();

    LOGD("X");
    return rc;
}

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

    m_dlHandle = NULL;

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

/*===========================================================================
 * FUNCTION   : start
 *
 * DESCRIPTION: starting QCameraClearSight
 *
 * PARAMETERS :
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraClearSight::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 QCameraClearSight::feedInput(qcamera_hal_pp_data_t *pInputData)
{
    int32_t rc = NO_ERROR;
    LOGD("E");
    if (NULL != pInputData) {
        mm_camera_buf_def_t *pInputSnapshotBuf = getSnapshotBuf(pInputData);
        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);
                // new the vector first
                pVector = new std::vector<qcamera_hal_pp_data_t*>(MM_CAMERA_MAX_CAM_CNT);
                // Add vector to the hash map
                m_frameMap[frameIndex] = pVector;
            } else {
                uint32_t *pFrameIndex = new uint32_t;
                *pFrameIndex = frameIndex;
                // Enqueue the frame index (i.e. key of vector) to queue
                if (false == m_inputQ.enqueue((void*)pFrameIndex)) {
                    LOGE("Input Q is not active!!!");
                    releaseData(pInputData);
                    m_frameMap.erase(frameIndex);
                    delete pFrameIndex;
                    delete pVector;
                    rc = INVALID_OPERATION;
                    return rc;
                }
                if (m_inputQ.getCurrentSize() == MIN_CLEARSIGHT_BUFS) {
                    m_halPPGetOutputCB(frameIndex, m_pHalPPMgr);
                }
            }
            pInputData->frameIndex = frameIndex;
            // Check if frame is from main 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(BAYER_INPUT) = pInputData;
            } else {
                pVector->at(MONO_INPUT) = pInputData;
            }
        }
    } 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 QCameraClearSight::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 input frame in order to get output buffer len,
        // and copy metadata buffer.
        if (pVector != NULL && pVector->at(BAYER_INPUT) != NULL) {
            qcamera_hal_pp_data_t *pInputData = pVector->at(BAYER_INPUT);
            rc = getOutputBuffer(pInputData, pOutputData);
            // 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 ClearSight blending process
 *
 * PARAMETERS : None
 *
 * RETURN     : int32_t type of status
 *              NO_ERROR  -- success
 *              none-zero failure code
 *==========================================================================*/
int32_t QCameraClearSight::process()
{
    int32_t rc = NO_ERROR;

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

    LOGD("E");

    if (!canProcess()) {
        LOGD("Yet to receive all input/output bufs");
        return NO_ERROR;
    }

    LOGI("start clearsight process");

    // TODO: dequeue from m_inputQ and start process logic
    // Start the blending process when it is ready
    while (!m_inputQ.isEmpty()) {
        uint32_t *pFrameIndex = (uint32_t *)m_inputQ.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(BAYER_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(MONO_INPUT);
        if (pInputAuxData == NULL) {
            LOGE("Cannot find input aux data");
            return UNEXPECTED_NULL;
        }

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

        // Use offset info from reproc stream
        cam_frame_len_offset_t frm_offset = pInputMainData->snap_offset;
        LOGI("Main stride:%d, scanline:%d, frame len:%d",
                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, "bayer");
            dumpYUVtoFile((uint8_t *)aux_snapshot_buf->buffer,  frm_offset,
                    aux_snapshot_buf->frame_idx,  "mono");
        }

        //Get input and output parameter
        clearsight_input_params_t inParams;
        getInputParams(main_meta_buf, aux_meta_buf,
                                pInputMainData->snap_offset,
                                pInputAuxData->snap_offset,
                inParams);

        if (main_snapshot_buf->frame_idx == aux_snapshot_buf->frame_idx)
            inParams.frame_idx = main_snapshot_buf->frame_idx;
        else {
            LOGE("something wrong !!!");
        }
        dumpInputParams(inParams);

        qcamera_hal_pp_data_t *pOutputData = NULL;
        if (m_inputQ.isEmpty()) {
            pOutputData = (qcamera_hal_pp_data_t*)m_outgoingQ.dequeue();
            if (pOutputData == NULL) {
                LOGE("Cannot find output data");
                return UNEXPECTED_NULL;
            }
            mm_camera_super_buf_t *output_frame = pOutputData->frame;
            mm_camera_buf_def_t *output_snapshot_buf = output_frame->bufs[0];

            doClearSightProcess((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.
        if (pOutputData)
            m_halPPBufNotifyCB(pOutputData, m_pHalPPMgr);

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

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

/*===========================================================================
 * FUNCTION   : canProcess
 *
 * DESCRIPTION: function to release internal resources
 * RETURN     : If ClearSight module can start blending process
 *==========================================================================*/
bool QCameraClearSight::canProcess()
{
    LOGD("E");
    bool ready = false;
    if(!m_inputQ.isEmpty() && !m_outgoingQ.isEmpty()) {
        ready = true;
    }
    LOGD("X: ready = %d", ready);
    return ready;
}

/*===========================================================================
 * FUNCTION   : getInputParams
 *
 * DESCRIPTION: Helper function to get input params from input metadata
 *==========================================================================*/
void QCameraClearSight::getInputParams(__unused mm_camera_buf_def_t *pMainMetaBuf,
        __unused mm_camera_buf_def_t *pAuxMetaBuf, cam_frame_len_offset_t main_offset,
                cam_frame_len_offset_t aux_offset, clearsight_input_params_t& inParams)
{
    LOGD("E");
    memset(&inParams, 0, sizeof(clearsight_input_params_t));

    // bayer frame size
    inParams.bayer.width     = main_offset.mp[0].width;
    inParams.bayer.height    = main_offset.mp[0].height;
    inParams.bayer.stride    = main_offset.mp[0].stride;
    inParams.bayer.scanline  = main_offset.mp[0].scanline;
    inParams.bayer.frame_len = main_offset.frame_len;

    // mono frame size
    inParams.mono.width     = aux_offset.mp[0].width;
    inParams.mono.height    = aux_offset.mp[0].height;
    inParams.mono.stride    = aux_offset.mp[0].stride;
    inParams.mono.scanline  = aux_offset.mp[0].scanline;
    inParams.mono.frame_len = aux_offset.frame_len;

    LOGD("X");
}

/*===========================================================================
 * FUNCTION   : doClearSightInit
 *
 * DESCRIPTION: function to do required initialization for clearsight processing.
 * RETURN     :  int32_t type of status
 *                   NO_ERROR  -- success
 *                   non-zero -- failure code
 *==========================================================================*/
int32_t QCameraClearSight::doClearSightInit()
{
    LOGD("E");
    int rc = NO_ERROR;

    LOGD("X");
    return rc;
}

/*===========================================================================
 * FUNCTION   : doClearSightProcess
 *
 * DESCRIPTION: clearsight processing routine
 * RETURN     :  int32_t type of status
 *                   NO_ERROR  -- success
 *                   non-zero -- failure code
 *==========================================================================*/

int32_t QCameraClearSight::doClearSightProcess(const uint8_t* pBayer, const uint8_t* pMono,
        clearsight_input_params_t inParams, uint8_t* pOut)
{
    LOGD("E");

    // trace begin

    // half image from bayer, and half image from mono

    // Y
    memcpy(pOut, pBayer, inParams.bayer.stride * inParams.bayer.scanline / 2);
    memcpy(pOut  + inParams.bayer.stride * inParams.bayer.scanline / 2,
           pMono + inParams.bayer.stride * inParams.bayer.scanline / 2,
           inParams.bayer.stride * inParams.bayer.scanline / 2);

    // UV
    uint32_t uv_offset = inParams.bayer.stride * inParams.bayer.scanline;
    memcpy(pOut  + uv_offset,
           pBayer + uv_offset,
           inParams.bayer.stride * (inParams.bayer.scanline / 2) / 2);
    memcpy(pOut  + uv_offset + inParams.bayer.stride * (inParams.bayer.scanline / 2) / 2,
           pMono + uv_offset + inParams.bayer.stride * (inParams.bayer.scanline / 2) / 2,
           inParams.bayer.stride * (inParams.bayer.scanline / 2) / 2);

    // trace end

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

/*===========================================================================
 * FUNCTION   : dumpYUVtoFile
 *
 * DESCRIPTION: dumps yuv for debug purpose
 * RETURN     :  None
 *==========================================================================*/
void QCameraClearSight::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.");
}

/*===========================================================================
 * FUNCTION   : dumpInputParams
 *
 * DESCRIPTION: dumps input params for debug purpose
 * RETURN     :  None
 *==========================================================================*/
void QCameraClearSight::dumpInputParams(const clearsight_input_params_t& p)
{
    LOGD("E : frame idx %d", p.frame_idx);

    const cam_frame_size_t* s = NULL;

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

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

    LOGD("X");
}

} // namespace qcamera