/*
 *  Copyright (c) 2019 Rockchip Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include "CamHwIsp21.h"
//#include "isp20/Isp20PollThread.h"
#ifdef ANDROID_OS
#include <cutils/properties.h>
#endif

namespace RkCam {

CamHwIsp21::CamHwIsp21()
    : CamHwIsp20()
{
    mNoReadBack = true;
#ifndef ANDROID_OS
    char* valueStr = getenv("normal_no_read_back");
    if (valueStr) {
        mNoReadBack = atoi(valueStr) > 0 ? true : false;
    }
#else
    char property_value[PROPERTY_VALUE_MAX] = {'\0'};

    property_get("persist.vendor.rkisp_no_read_back", property_value, "-1");
    int val = atoi(property_value);
    if (val != -1)
        mNoReadBack = atoi(property_value) > 0 ? true : false;
#endif
}

CamHwIsp21::~CamHwIsp21()
{}

XCamReturn
CamHwIsp21::init(const char* sns_ent_name)
{
    xcam_mem_clear (_full_active_isp21_params);

    XCamReturn ret = CamHwIsp20::init(sns_ent_name);

    //SmartPtr<Isp20PollThread> isp20Pollthread =
    //    mPollthread.dynamic_cast_ptr<Isp20PollThread>();
    //isp20Pollthread->set_need_luma_rd_info(false);
    return ret;
}

XCamReturn
CamHwIsp21::stop()
{

    XCamReturn ret = CamHwIsp20::stop();
    xcam_mem_clear (_full_active_isp21_params);

    return ret;
}

bool CamHwIsp21::isOnlineByWorkingMode()
{
    return false;
}

XCamReturn
CamHwIsp21::dispatchResult(cam3aResultList& list)
{
    cam3aResultList isp_result_list;
    for (auto& result : list) {
        switch (result->getType()) {
        case RESULT_TYPE_FLASH_PARAM:
        case RESULT_TYPE_CPSL_PARAM:
        case RESULT_TYPE_IRIS_PARAM:
        case RESULT_TYPE_FOCUS_PARAM:
        case RESULT_TYPE_EXPOSURE:
            CamHwIsp20::dispatchResult(result);
            break;
        default:
            isp_result_list.push_back(result);
            break;
        }
    }

    if (isp_result_list.size() > 0) {
        handleIsp3aReslut(isp_result_list);
    }

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
CamHwIsp21::dispatchResult(SmartPtr<cam3aResult> result)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (!result.ptr())
        return XCAM_RETURN_ERROR_PARAM;

    LOGD("%s enter, msg type(0x%x)", __FUNCTION__, result->getType());
    switch (result->getType())
    {
    case RESULT_TYPE_FLASH_PARAM:
    case RESULT_TYPE_CPSL_PARAM:
    case RESULT_TYPE_IRIS_PARAM:
    case RESULT_TYPE_FOCUS_PARAM:
    case RESULT_TYPE_EXPOSURE:
        return CamHwIsp20::dispatchResult(result);
    default:
        handleIsp3aReslut(result);
        break;
    }
    return ret;
    LOGD("%s exit", __FUNCTION__);
}

void
CamHwIsp21::gen_full_isp_params(const struct isp21_isp_params_cfg* update_params,
                                struct isp21_isp_params_cfg* full_params,
                                uint64_t* module_en_update_partial,
                                uint64_t* module_cfg_update_partial)
{
    XCAM_ASSERT (update_params);
    XCAM_ASSERT (full_params);
    int i = 0;

    ENTER_CAMHW_FUNCTION();
    for (; i <= RK_ISP2X_MAX_ID; i++)
        if (update_params->module_en_update & (1LL << i)) {
            if ((full_params->module_ens & (1LL << i)) !=
                    (update_params->module_ens & (1LL << i)))
                *module_en_update_partial |= 1LL << i;
            full_params->module_en_update |= 1LL << i;
            // clear old bit value
            full_params->module_ens &= ~(1LL << i);
            // set new bit value
            full_params->module_ens |= update_params->module_ens & (1LL << i);
        }

    for (i = 0; i <= RK_ISP2X_MAX_ID; i++) {
        if (update_params->module_cfg_update & (1LL << i)) {

#define CHECK_UPDATE_PARAMS(dst, src) \
            if (memcmp(&dst, &src, sizeof(dst)) == 0 && \
                full_params->frame_id > ISP_PARAMS_EFFECT_DELAY_CNT) { \
                continue; \
            } \
            *module_cfg_update_partial |= 1LL << i; \
            dst = src; \

            full_params->module_cfg_update |= 1LL << i;
            switch (i) {
            case RK_ISP2X_RAWAE_BIG1_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawae0, update_params->meas.rawae0);
                break;
            case RK_ISP2X_RAWAE_BIG2_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawae1, update_params->meas.rawae1);
                break;
            case RK_ISP2X_RAWAE_BIG3_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawae2, update_params->meas.rawae2);
                break;
            case RK_ISP2X_RAWAE_LITE_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawae3, update_params->meas.rawae3);
                break;
            case RK_ISP2X_RAWHIST_BIG1_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawhist0, update_params->meas.rawhist0);
                break;
            case RK_ISP2X_RAWHIST_BIG2_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawhist1, update_params->meas.rawhist1);
                break;
            case RK_ISP2X_RAWHIST_BIG3_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawhist2, update_params->meas.rawhist2);
                break;
            case RK_ISP2X_RAWHIST_LITE_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawhist3, update_params->meas.rawhist3);
                break;
            case RK_ISP2X_YUVAE_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.yuvae, update_params->meas.yuvae);
                break;
            case RK_ISP2X_SIHST_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.sihst, update_params->meas.sihst);
                break;
            case RK_ISP2X_SIAWB_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.siawb, update_params->meas.siawb);
                break;
            case RK_ISP2X_RAWAWB_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawawb, update_params->meas.rawawb);
                break;
            case RK_ISP2X_AWB_GAIN_ID:
                CHECK_UPDATE_PARAMS(full_params->others.awb_gain_cfg, update_params->others.awb_gain_cfg);
                break;
            case RK_ISP2X_RAWAF_ID:
                CHECK_UPDATE_PARAMS(full_params->meas.rawaf, update_params->meas.rawaf);
                break;
            case RK_ISP2X_HDRMGE_ID:
                CHECK_UPDATE_PARAMS(full_params->others.hdrmge_cfg, update_params->others.hdrmge_cfg);
                break;
            /* case RK_ISP2X_HDRTMO_ID: */
            /*     full_params->others.hdrtmo_cfg = update_params->others.hdrtmo_cfg; */
            /*     break; */
            case RK_ISP2X_CTK_ID:
                CHECK_UPDATE_PARAMS(full_params->others.ccm_cfg, update_params->others.ccm_cfg);
                break;
            case RK_ISP2X_LSC_ID:
                CHECK_UPDATE_PARAMS(full_params->others.lsc_cfg, update_params->others.lsc_cfg);
                break;
            case RK_ISP2X_GOC_ID:
                CHECK_UPDATE_PARAMS(full_params->others.gammaout_cfg, update_params->others.gammaout_cfg);
                break;
            case RK_ISP2X_3DLUT_ID:
                CHECK_UPDATE_PARAMS(full_params->others.isp3dlut_cfg, update_params->others.isp3dlut_cfg);
                break;
            case RK_ISP2X_DPCC_ID:
                CHECK_UPDATE_PARAMS(full_params->others.dpcc_cfg, update_params->others.dpcc_cfg);
                break;
            case RK_ISP2X_BLS_ID:
                CHECK_UPDATE_PARAMS(full_params->others.bls_cfg, update_params->others.bls_cfg);
                break;
            case RK_ISP2X_DEBAYER_ID:
                CHECK_UPDATE_PARAMS(full_params->others.debayer_cfg, update_params->others.debayer_cfg);
                break;
            case RK_ISP2X_DHAZ_ID:
                CHECK_UPDATE_PARAMS(full_params->others.dhaz_cfg, update_params->others.dhaz_cfg);
                break;
            /* case RK_ISP2X_RAWNR_ID: */
            /*     full_params->others.rawnr_cfg = update_params->others.rawnr_cfg; */
            /*     break; */
            /* case RK_ISP2X_GAIN_ID: */
            /*     full_params->others.gain_cfg = update_params->others.gain_cfg; */
            /*     break; */
            case RK_ISP2X_LDCH_ID:
                CHECK_UPDATE_PARAMS(full_params->others.ldch_cfg, update_params->others.ldch_cfg);
                break;
            case RK_ISP2X_GIC_ID:
                CHECK_UPDATE_PARAMS(full_params->others.gic_cfg, update_params->others.gic_cfg);
                break;
            case RK_ISP2X_CPROC_ID:
                CHECK_UPDATE_PARAMS(full_params->others.cproc_cfg, update_params->others.cproc_cfg);
                break;
            case Rk_ISP21_BAYNR_ID:
                CHECK_UPDATE_PARAMS(full_params->others.baynr_cfg, update_params->others.baynr_cfg);
                break;
            case Rk_ISP21_BAY3D_ID:
                CHECK_UPDATE_PARAMS(full_params->others.bay3d_cfg, update_params->others.bay3d_cfg);
                break;
            case Rk_ISP21_YNR_ID:
                CHECK_UPDATE_PARAMS(full_params->others.ynr_cfg, update_params->others.ynr_cfg);
                break;
            case Rk_ISP21_CNR_ID:
                CHECK_UPDATE_PARAMS(full_params->others.cnr_cfg, update_params->others.cnr_cfg);
                break;
            case Rk_ISP21_SHARP_ID:
                CHECK_UPDATE_PARAMS(full_params->others.sharp_cfg, update_params->others.sharp_cfg);
                break;
            case Rk_ISP21_DRC_ID:
                CHECK_UPDATE_PARAMS(full_params->others.drc_cfg, update_params->others.drc_cfg);
                break;
            case RK_ISP2X_SDG_ID:
                CHECK_UPDATE_PARAMS(full_params->others.sdg_cfg, update_params->others.sdg_cfg);
                break;
            default:
                break;
            }
        }
    }
    EXIT_CAMHW_FUNCTION();
}

/*
 * some module(HDR/TNR) parameters are related to the next frame exposure
 * and can only be easily obtained at the hwi layer,
 * so these parameters are calculated at hwi and the result is overwritten.
 */
XCamReturn
CamHwIsp21::overrideExpRatioToAiqResults(const sint32_t frameId,
        int module_id,
        cam3aResultList &results,
        int hdr_mode)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    SmartPtr<RkAiqExpParamsProxy> curFrameExpParam;
    SmartPtr<RkAiqExpParamsProxy> nextFrameExpParam;
    SmartPtr<BaseSensorHw> mSensorSubdev = mSensorDev.dynamic_cast_ptr<BaseSensorHw>();

    if (mSensorSubdev.ptr()) {
        if (mSensorSubdev->getEffectiveExpParams(curFrameExpParam, frameId) < 0) {
            LOGE_CAMHW_SUBM(ISP20HW_SUBM, "exp-sync: module_id: 0x%x, rx id: %d\n",
                            module_id,
                            frameId);
            return ret;
        }

        if (mSensorSubdev->getEffectiveExpParams(nextFrameExpParam, frameId + 1) < 0) {
            LOGE_CAMHW_SUBM(ISP20HW_SUBM, "exp-sync: module_id: 0x%x, rx id: %d\n",
                            module_id,
                            frameId + 1);
            return ret;
        }
    }

    LOGD_CAMHW_SUBM(ISP20HW_SUBM, "exp-sync: module_id: 0x%x, rx id: %d\n"
                    "curFrame(%d): lexp: %f-%f, mexp: %f-%f, sexp: %f-%f\n"
                    "nextFrame(%d): lexp: %f-%f, mexp: %f-%f, sexp: %f-%f\n",
                    module_id,
                    frameId,
                    frameId,
                    curFrameExpParam->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain,
                    curFrameExpParam->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time,
                    curFrameExpParam->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain,
                    curFrameExpParam->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time,
                    curFrameExpParam->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain,
                    curFrameExpParam->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time,
                    frameId + 1,
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[2].exp_real_params.analog_gain,
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[2].exp_real_params.integration_time,
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain,
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time,
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain,
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time);

    //calc expo
    float nextLExpo = 0;
    float nextMExpo = 0;
    float nextSExpo = 0;
    float nextRatioLS = 1.0;
    if(hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
        nextLExpo = nextFrameExpParam->data()->aecExpInfo.LinearExp.exp_real_params.analog_gain * \
                    nextFrameExpParam->data()->aecExpInfo.LinearExp.exp_real_params.integration_time;
        nextMExpo = nextLExpo;
        nextSExpo = nextLExpo;
    }
    else if(hdr_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2) {
        nextLExpo = nextFrameExpParam->data()->aecExpInfo.HdrExp[1].exp_real_params.analog_gain * \
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[1].exp_real_params.integration_time;
        nextMExpo = nextLExpo;
        nextSExpo = nextFrameExpParam->data()->aecExpInfo.HdrExp[0].exp_real_params.analog_gain * \
                    nextFrameExpParam->data()->aecExpInfo.HdrExp[0].exp_real_params.integration_time;
    }
    else {
        LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get wrong hdr mode\n");
        return ret;
    }

    nextRatioLS = nextLExpo / nextSExpo;
    nextRatioLS = nextRatioLS >= 1 ? nextRatioLS : 1;

    switch (module_id) {
    case Rk_ISP21_DRC_ID:
    {
        SmartPtr<cam3aResult> drc_res = get_3a_module_result(results, RESULT_TYPE_DRC_PARAM);
        SmartPtr<RkAiqIspDrcParamsProxyV21> drcParamsProxy;
        if (drc_res.ptr()) {
            drcParamsProxy = drc_res.dynamic_cast_ptr<RkAiqIspDrcParamsProxyV21>();
        } else {
            LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get drc params from 3a result failed!\n");
            return ret;
        }
        rk_aiq_isp_drc_v21_t& drc = drcParamsProxy->data()->result;

        if(!drc.bTmoEn)
            break;

        if (drc.LongFrameMode)
            nextRatioLS = 1.0;

        //get sw_drc_compres_scl
        float MFHDR_LOG_Q_BITS = 11;
        float adrc_gain = drc.DrcProcRes.sw_drc_adrc_gain;
        float log_ratio2 = log(nextRatioLS * adrc_gain) / log(2.0f) + 12;
        float offsetbits_int = (float)(drc.DrcProcRes.sw_drc_offset_pow2);
        float offsetbits = offsetbits_int * pow(2, MFHDR_LOG_Q_BITS);
        float hdrbits = log_ratio2 * pow(2, MFHDR_LOG_Q_BITS);
        float hdrvalidbits = hdrbits - offsetbits;
        float compres_scl = (12 * pow(2, MFHDR_LOG_Q_BITS * 2)) / hdrvalidbits;
        drc.DrcProcRes.sw_drc_compres_scl = (int)(compres_scl);

        //get sw_drc_min_ogain
        if(drc.DrcProcRes.sw_drc_min_ogain == 1)
            drc.DrcProcRes.sw_drc_min_ogain = 1 << 15;
        else {
            float sw_drc_min_ogain = 1 / (nextRatioLS * adrc_gain);
            drc.DrcProcRes.sw_drc_min_ogain = (int)(sw_drc_min_ogain * pow(2, 15) + 0.5);
        }

        //get sw_drc_compres_y
        if(drc.CompressMode == COMPRESS_AUTO) {
            float curveparam, curveparam2, curveparam3, tmp;
            float luma2[17] = { 0, 1024, 2048, 3072, 4096, 5120, 6144, 7168, 8192, 10240, 12288, 14336, 16384, 18432, 20480, 22528, 24576 };
            float curveTable[17];
            float ISP_RAW_BIT = 12;
            float dstbits = ISP_RAW_BIT * pow(2, MFHDR_LOG_Q_BITS);
            float validbits = dstbits - offsetbits;
            for(int i = 0; i < ISP21_DRC_Y_NUM; ++i)
            {
                curveparam = (float)(validbits - 0) / (hdrvalidbits - validbits + pow(2, -6));
                curveparam2 = validbits * (1 + curveparam);
                curveparam3 = hdrvalidbits * curveparam;
                tmp = luma2[i] * hdrvalidbits / 24576;
                curveTable[i] = (tmp * curveparam2 / (tmp + curveparam3));
                drc.DrcProcRes.sw_drc_compres_y[i] = (int)(curveTable[i]) ;
            }
        }

        LOGD_CAMHW_SUBM(ISP20HW_SUBM, "nextRatioLS:%f sw_drc_compres_scl:%d sw_drc_min_ogain:%d\n",
                        nextRatioLS, drc.DrcProcRes.sw_drc_compres_scl, drc.DrcProcRes.sw_drc_min_ogain);
        LOGD_CAMHW_SUBM(ISP20HW_SUBM, "CompressMode:%d\n", drc.CompressMode);
        for(int i = 0; i < ISP21_DRC_Y_NUM; ++i)
            LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sw_drc_compres_y[%d]:%d\n", i, drc.DrcProcRes.sw_drc_compres_y[i]);

        break;
    }
    case RK_ISP2X_HDRMGE_ID:
    {
        SmartPtr<cam3aResult> merge_res = get_3a_module_result(results, RESULT_TYPE_MERGE_PARAM);
        SmartPtr<RkAiqIspMergeParamsProxy> mergeParamsProxy;

        if (merge_res.ptr()) {
            mergeParamsProxy = merge_res.dynamic_cast_ptr<RkAiqIspMergeParamsProxy>();
        } else {
            LOGE_CAMHW_SUBM(ISP20HW_SUBM, "get drc params from 3a result failed!\n");
            return ret;
        }
        RkAiqAmergeProcResult_t& merge = mergeParamsProxy->data()->result;

        if(merge.Res.sw_hdrmge_mode == 0)
            break;

        //get sw_hdrmge_gain0
        merge.Res.sw_hdrmge_gain0 = (int)(64 * nextRatioLS);
        if(nextRatioLS == 1)
            merge.Res.sw_hdrmge_gain0_inv = (int)(4096 * (1 / nextRatioLS) - 1);
        else
            merge.Res.sw_hdrmge_gain0_inv = (int)(4096 * (1 / nextRatioLS));

        //get sw_hdrmge_gain1
        merge.Res.sw_hdrmge_gain1 = 0x40;
        merge.Res.sw_hdrmge_gain1_inv = 0xfff;

        //get sw_hdrmge_gain2
        merge.Res.sw_hdrmge_gain2 = 0x40;

        LOGD_CAMHW_SUBM(ISP20HW_SUBM, "sw_hdrmge_gain0:%d sw_hdrmge_gain0_inv:%d\n",
                        merge.Res.sw_hdrmge_gain0, merge.Res.sw_hdrmge_gain0_inv);

        break;
    }
    default:
        LOGW_CAMHW_SUBM(ISP20HW_SUBM, "unkown module id: 0x%x!\n", module_id);
        break;
    }

    return ret;
}

XCamReturn
CamHwIsp21::setIspConfig()
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    ENTER_CAMHW_FUNCTION();

    SmartPtr<V4l2Buffer> v4l2buf;
    uint32_t frameId = -1;

    {
        SmartLock locker (_isp_params_cfg_mutex);
        while (_effecting_ispparam_map.size() > 4)
            _effecting_ispparam_map.erase(_effecting_ispparam_map.begin());
    }
    if (mIspParamsDev.ptr()) {
        ret = mIspParamsDev->get_buffer(v4l2buf);
        if (ret) {
            LOGE_CAMHW_SUBM(ISP20HW_SUBM, "Can not get isp params buffer\n");
            return XCAM_RETURN_ERROR_PARAM;
        }
    } else
        return XCAM_RETURN_BYPASS;

    cam3aResultList ready_results;
    ret = mParamsAssembler->deQueOne(ready_results, frameId);
    if (ret != XCAM_RETURN_NO_ERROR) {
        LOGI_CAMHW_SUBM(ISP20HW_SUBM, "deque isp ready parameter failed\n");
        mIspParamsDev->return_buffer_to_pool (v4l2buf);
        return XCAM_RETURN_ERROR_PARAM;
    }

    LOGD_ANALYZER("----------%s, start config id(%d)'s isp params", __FUNCTION__, frameId);

    struct isp21_isp_params_cfg update_params;

    update_params.module_en_update = 0;
    update_params.module_ens = 0;
    update_params.module_cfg_update = 0;
    if (_state == CAM_HW_STATE_STOPPED || _state == CAM_HW_STATE_PREPARED || _state == CAM_HW_STATE_PAUSED) {
        // update all ens
        _full_active_isp21_params.module_en_update = ~0;
        // just re-config the enabled moddules
        _full_active_isp21_params.module_cfg_update = _full_active_isp21_params.module_ens;
    } else {
        _full_active_isp21_params.module_en_update = 0;
        // use module_ens to store module status, so we can use it to restore
        // the init params for re-start and re-prepare
        /* _full_active_isp21_params.module_ens = 0; */
        _full_active_isp21_params.module_cfg_update = 0;
    }

    ret = overrideExpRatioToAiqResults(frameId, Rk_ISP21_DRC_ID, ready_results, _hdr_mode);
    if (ret < 0) {
        LOGE_CAMHW_SUBM(ISP20HW_SUBM, "DRC convertExpRatioToAiqResults error!\n");
    }

    ret = overrideExpRatioToAiqResults(frameId, RK_ISP2X_HDRMGE_ID, ready_results, _hdr_mode);
    if (ret < 0) {
        LOGE_CAMHW_SUBM(ISP20HW_SUBM, "Merge convertExpRatioToAiqResults error!\n");
    }

    if (frameId >= 0) {
        SmartPtr<cam3aResult> awb_res = get_3a_module_result(ready_results, RESULT_TYPE_AWB_PARAM);
        SmartPtr<RkAiqIspAwbParamsProxyV21> awbParams;
        if (awb_res.ptr()) {
            awbParams = awb_res.dynamic_cast_ptr<RkAiqIspAwbParamsProxyV21>();
            {
                SmartLock locker (_isp_params_cfg_mutex);
                _effecting_ispparam_map[frameId].awb_cfg_v201 = awbParams->data()->result;

            }
        } else {
            /* use the latest */
            SmartLock locker (_isp_params_cfg_mutex);
            if (!_effecting_ispparam_map.empty()) {
                _effecting_ispparam_map[frameId].awb_cfg_v201 = (_effecting_ispparam_map.rbegin())->second.awb_cfg_v201;
                LOGW_CAMHW_SUBM(ISP20HW_SUBM, "use frame %d awb params for frame %d !\n",
                                frameId, (_effecting_ispparam_map.rbegin())->first);
            } else {
                LOGW_CAMHW_SUBM(ISP20HW_SUBM, "get awb params from 3a result failed for frame %d !\n", frameId);
            }
        }
    }

    // TODO: merge_isp_results would cause the compile warning: reference to ‘merge_isp_results’ is ambiguous
    // now use Isp21Params::merge_isp_results instead
    if (Isp21Params::merge_isp_results(ready_results, &update_params) != XCAM_RETURN_NO_ERROR)
        LOGE_CAMHW_SUBM(ISP20HW_SUBM, "ISP parameter translation error\n");

    uint64_t module_en_update_partial = 0;
    uint64_t module_cfg_update_partial = 0;
    gen_full_isp_params(&update_params, &_full_active_isp21_params,
                        &module_en_update_partial, &module_cfg_update_partial);

    if (_state == CAM_HW_STATE_STOPPED)
        LOGD_CAMHW_SUBM(ISP20HW_SUBM, "ispparam ens 0x%llx, en_up 0x%llx, cfg_up 0x%llx",
                        _full_active_isp21_params.module_ens,
                        _full_active_isp21_params.module_en_update,
                        _full_active_isp21_params.module_cfg_update);
#ifdef RUNTIME_MODULE_DEBUG
    _full_active_isp21_params.module_en_update &= ~g_disable_isp_modules_en;
    _full_active_isp21_params.module_ens |= g_disable_isp_modules_en;
    _full_active_isp21_params.module_cfg_update &= ~g_disable_isp_modules_cfg_update;
    module_en_update_partial = _full_active_isp21_params.module_en_update;
    module_cfg_update_partial = _full_active_isp21_params.module_cfg_update;
#endif

    {
        SmartLock locker (_isp_params_cfg_mutex);
        if (frameId < 0) {
            _effecting_ispparam_map[0].isp_params_v21 = _full_active_isp21_params;
        } else {
            _effecting_ispparam_map[frameId].isp_params_v21 = _full_active_isp21_params;
        }
    }

    if (v4l2buf.ptr()) {
        struct isp21_isp_params_cfg* isp_params;
        int buf_index = v4l2buf->get_buf().index;

        isp_params = (struct isp21_isp_params_cfg*)v4l2buf->get_buf().m.userptr;
        *isp_params = _full_active_isp21_params;
        isp_params->module_en_update = module_en_update_partial;
        isp_params->module_cfg_update = module_cfg_update_partial;
        //TODO: isp driver has bug now, lsc cfg_up should be set along with
        //en_up
        if (isp_params->module_cfg_update & ISP2X_MODULE_LSC)
            isp_params->module_en_update |= ISP2X_MODULE_LSC;
        isp_params->frame_id = frameId;

#if 0 //TODO: isp21 params has no exposure info field
        SmartPtr<SensorHw> mSensorSubdev = mSensorDev.dynamic_cast_ptr<SensorHw>();
        if (mSensorSubdev.ptr()) {
            memset(&isp_params->exposure, 0, sizeof(isp_params->exposure));
            SmartPtr<RkAiqExpParamsProxy> expParam;

            if (mSensorSubdev->getEffectiveExpParams(expParam, frameId) < 0) {
                LOGE_CAMHW_SUBM(ISP20HW_SUBM, "frame_id(%d), get exposure failed!!!\n", frameId);
            } else {
                if (RK_AIQ_HDR_GET_WORKING_MODE(_hdr_mode) == RK_AIQ_WORKING_MODE_NORMAL) {
                    isp_params->exposure.linear_exp.analog_gain_code_global = \
                            expParam->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global;
                    isp_params->exposure.linear_exp.coarse_integration_time = \
                            expParam->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time;
                } else {
                    isp_params->exposure.hdr_exp[0].analog_gain_code_global = \
                            expParam->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global;
                    isp_params->exposure.hdr_exp[0].coarse_integration_time = \
                            expParam->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time;
                    isp_params->exposure.hdr_exp[1].analog_gain_code_global = \
                            expParam->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global;
                    isp_params->exposure.hdr_exp[1].coarse_integration_time = \
                            expParam->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time;
                    isp_params->exposure.hdr_exp[2].analog_gain_code_global = \
                            expParam->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global;
                    isp_params->exposure.hdr_exp[2].coarse_integration_time = \
                            expParam->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time;
                }
            }
        }
#endif
        if (mIspParamsDev->queue_buffer (v4l2buf) != 0) {
            LOGE_CAMHW_SUBM(ISP20HW_SUBM, "RKISP1: failed to ioctl VIDIOC_QBUF for index %d, %d %s.\n",
                            buf_index, errno, strerror(errno));
            mIspParamsDev->return_buffer_to_pool (v4l2buf);
            return XCAM_RETURN_ERROR_IOCTL;
        }

        ispModuleEns = _full_active_isp21_params.module_ens;
        LOGD_CAMHW_SUBM(ISP20HW_SUBM, "ispparam ens 0x%llx, en_up 0x%llx, cfg_up 0x%llx",
                        _full_active_isp21_params.module_ens,
                        isp_params->module_en_update,
                        isp_params->module_cfg_update);

        LOGD_CAMHW_SUBM(ISP20HW_SUBM, "device(%s) queue buffer index %d, queue cnt %d, check exit status again[exit: %d]",
                        XCAM_STR (mIspParamsDev->get_device_name()),
                        buf_index, mIspParamsDev->get_queued_bufcnt(), _is_exit);
        if (_is_exit)
            return XCAM_RETURN_BYPASS;
    } else
        return XCAM_RETURN_BYPASS;

    EXIT_CAMHW_FUNCTION();
    return ret;
}


};