#include "rk_aiq_types_algo_agic_prvt.h"


XCamReturn
AgicInit
(
    AgicContext_t *pAgicCtx,
    CamCalibDbV2Context_t* calib
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
    if(pAgicCtx == NULL) {
        LOGE_AGIC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return XCAM_RETURN_ERROR_PARAM;
    }
    memset(pAgicCtx, 0, sizeof(AgicContext_t));
    pAgicCtx->state = AGIC_STATE_INITIALIZED;

    if(CHECK_ISP_HW_V20()) {
        CalibDbV2_Gic_V20_t* calibv2_agic_calib_V20 =
            (CalibDbV2_Gic_V20_t*)(CALIBDBV2_GET_MODULE_PTR(calib, agic_calib_v20));
        pAgicCtx->full_param.gic_v20 = calibv2_agic_calib_V20;
    } else if(CHECK_ISP_HW_V21()) {
        CalibDbV2_Gic_V21_t* calibv2_agic_calib_V21 =
            (CalibDbV2_Gic_V21_t*)(CALIBDBV2_GET_MODULE_PTR(calib, agic_calib_v21));
        pAgicCtx->full_param.gic_v21 = calibv2_agic_calib_V21;
    }
    pAgicCtx->calib_changed = true;
    pAgicCtx->state = AGIC_STATE_RUNNING;

    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
AgicRelease
(
    AgicContext_t *pAgicCtx
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
    if(pAgicCtx == NULL) {
        LOGE_AGIC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return XCAM_RETURN_ERROR_PARAM;
    }
    AgicStop(pAgicCtx);

    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
AgicStop
(
    AgicContext_t *pAgicCtx
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    if(pAgicCtx == NULL) {
        LOGE_AGIC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return XCAM_RETURN_ERROR_PARAM;
    }
    pAgicCtx->state = AGIC_STATE_STOPPED;
    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn AgicPreProcess(AgicContext_t *pAgicCtx)
{
    return XCAM_RETURN_NO_ERROR;
}

void AgicGetProcResultV21
(
    AgicContext_t*    pAgicCtx
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    pAgicCtx->ProcRes.gic_en = pAgicCtx->ConfigData.ConfigV21.gic_en == 0 ? false : true;
    pAgicCtx->ProcRes.ProcResV21.regmingradthrdark2 = pAgicCtx->ConfigData.ConfigV21.regmingradthrdark2;
    pAgicCtx->ProcRes.ProcResV21.regmingradthrdark1 = pAgicCtx->ConfigData.ConfigV21.regmingradthrdark1;
    pAgicCtx->ProcRes.ProcResV21.regminbusythre = pAgicCtx->ConfigData.ConfigV21.regminbusythre;
    pAgicCtx->ProcRes.ProcResV21.regdarkthre = pAgicCtx->ConfigData.ConfigV21.regdarkthre;
    pAgicCtx->ProcRes.ProcResV21.regmaxcorvboth = pAgicCtx->ConfigData.ConfigV21.regmaxcorvboth;
    pAgicCtx->ProcRes.ProcResV21.regdarktthrehi = pAgicCtx->ConfigData.ConfigV21.regdarktthrehi;
    pAgicCtx->ProcRes.ProcResV21.regkgrad2dark = (int)(log(double(pAgicCtx->ConfigData.ConfigV21.regkgrad2dark)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV21.regkgrad1dark = (int)(log(double(pAgicCtx->ConfigData.ConfigV21.regkgrad1dark)) / log((double)2) + 0.5f);

    pAgicCtx->ProcRes.ProcResV21.regstrengthglobal_fix =  (int)(pAgicCtx->ConfigData.ConfigV21.globalStrength * (1 << 7));
    if (pAgicCtx->ProcRes.ProcResV21.regstrengthglobal_fix > (1 << 7) - 1)
        pAgicCtx->ProcRes.ProcResV21.regstrengthglobal_fix = 7 + 1;
    else
        pAgicCtx->ProcRes.ProcResV21.regstrengthglobal_fix = int(log(double((1 << 7) - pAgicCtx->ProcRes.ProcResV21.regstrengthglobal_fix)) / log((double)2) + 0.5f);

    pAgicCtx->ProcRes.ProcResV21.regdarkthrestep = int(log(double(pAgicCtx->ConfigData.ConfigV21.regdarktthrehi - pAgicCtx->ConfigData.ConfigV21.regdarkthre)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV21.regkgrad2 = (int)(log(double(pAgicCtx->ConfigData.ConfigV21.regkgrad2)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV21.regkgrad1 = (int)(log(double(pAgicCtx->ConfigData.ConfigV21.regkgrad1)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV21.reggbthre = int(log(double(pAgicCtx->ConfigData.ConfigV21.reggbthre)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV21.regmaxcorv = pAgicCtx->ConfigData.ConfigV21.regmaxcorv;
    pAgicCtx->ProcRes.ProcResV21.regmingradthr1 = pAgicCtx->ConfigData.ConfigV21.regmingradthr1;
    pAgicCtx->ProcRes.ProcResV21.regmingradthr2 = pAgicCtx->ConfigData.ConfigV21.regmingradthr2;
    pAgicCtx->ProcRes.ProcResV21.gr_ratio = pAgicCtx->ConfigData.ConfigV21.gr_ratio;
    pAgicCtx->ProcRes.ProcResV21.noise_scale = (pAgicCtx->ConfigData.ConfigV21.noise_scale * 128 + 0.5);
    pAgicCtx->ProcRes.ProcResV21.noise_base = (int)(pAgicCtx->ConfigData.ConfigV21.noise_base * 4096 + 0.5);

    for (int i = 0; i < 15; i++)
    {
        pAgicCtx->ProcRes.ProcResV21.sigma_y[i] = (int)(pAgicCtx->ConfigData.ConfigV21.sigma_y[i] * (1 << 7));
    }

    pAgicCtx->ProcRes.ProcResV21.diff_clip = pAgicCtx->ConfigData.ConfigV21.diff_clip;

    if (pAgicCtx->ProcRes.ProcResV21.regkgrad2dark < pAgicCtx->ProcRes.ProcResV21.regkgrad2)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV21.regkgrad2dark, pAgicCtx->ProcRes.ProcResV21.regkgrad2);

    if (pAgicCtx->ProcRes.ProcResV21.regmingradthrdark1 < pAgicCtx->ProcRes.ProcResV21.regmingradthr1)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV21.regmingradthrdark1, pAgicCtx->ProcRes.ProcResV21.regmingradthr1);

    if (pAgicCtx->ProcRes.ProcResV21.regmingradthrdark2 < pAgicCtx->ProcRes.ProcResV21.regmingradthr2)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV21.regmingradthrdark2, pAgicCtx->ProcRes.ProcResV21.regmingradthr2);

    if (pAgicCtx->ProcRes.ProcResV21.regdarktthrehi < pAgicCtx->ProcRes.ProcResV21.regdarkthre)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV21.regdarktthrehi, pAgicCtx->ProcRes.ProcResV21.regdarkthre);


    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);

}

void AgicGetProcResultV20
(
    AgicContext_t*    pAgicCtx
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    pAgicCtx->ProcRes.gic_en = pAgicCtx->ConfigData.ConfigV20.gic_en == 0 ? false : true;
    pAgicCtx->ProcRes.ProcResV20.edge_open = pAgicCtx->ConfigData.ConfigV20.edge_open;
    pAgicCtx->ProcRes.ProcResV20.regmingradthrdark2 = pAgicCtx->ConfigData.ConfigV20.regmingradthrdark2;
    pAgicCtx->ProcRes.ProcResV20.regmingradthrdark1 = pAgicCtx->ConfigData.ConfigV20.regmingradthrdark1;
    pAgicCtx->ProcRes.ProcResV20.regminbusythre = pAgicCtx->ConfigData.ConfigV20.regminbusythre;
    pAgicCtx->ProcRes.ProcResV20.regdarkthre = pAgicCtx->ConfigData.ConfigV20.regdarkthre;
    pAgicCtx->ProcRes.ProcResV20.regmaxcorvboth = pAgicCtx->ConfigData.ConfigV20.regmaxcorvboth;
    pAgicCtx->ProcRes.ProcResV20.regdarktthrehi = pAgicCtx->ConfigData.ConfigV20.regdarktthrehi;
    pAgicCtx->ProcRes.ProcResV20.regkgrad2dark = (int)(log(double(pAgicCtx->ConfigData.ConfigV20.regkgrad2dark)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV20.regkgrad1dark = (int)(log(double(pAgicCtx->ConfigData.ConfigV20.regkgrad1dark)) / log((double)2) + 0.5f);

    pAgicCtx->ProcRes.ProcResV20.regstrengthglobal_fix =  (int)(pAgicCtx->ConfigData.ConfigV20.globalStrength * (1 << 7));
    if (pAgicCtx->ProcRes.ProcResV20.regstrengthglobal_fix > (1 << 7) - 1)
        pAgicCtx->ProcRes.ProcResV20.regstrengthglobal_fix = 7 + 1;
    else
        pAgicCtx->ProcRes.ProcResV20.regstrengthglobal_fix = int(log(double((1 << 7) - pAgicCtx->ProcRes.ProcResV20.regstrengthglobal_fix)) / log((double)2) + 0.5f);

    pAgicCtx->ProcRes.ProcResV20.regdarkthrestep = int(log(double(pAgicCtx->ConfigData.ConfigV20.regdarktthrehi - pAgicCtx->ConfigData.ConfigV20.regdarkthre)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV20.regkgrad2 = (int)(log(double(pAgicCtx->ConfigData.ConfigV20.regkgrad2)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV20.regkgrad1 = (int)(log(double(pAgicCtx->ConfigData.ConfigV20.regkgrad1)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV20.reggbthre = int(log(double(pAgicCtx->ConfigData.ConfigV20.reggbthre)) / log((double)2) + 0.5f);
    pAgicCtx->ProcRes.ProcResV20.regmaxcorv = pAgicCtx->ConfigData.ConfigV20.regmaxcorv;
    pAgicCtx->ProcRes.ProcResV20.regmingradthr1 = pAgicCtx->ConfigData.ConfigV20.regmingradthr1;
    pAgicCtx->ProcRes.ProcResV20.regmingradthr2 = pAgicCtx->ConfigData.ConfigV20.regmingradthr2;
    pAgicCtx->ProcRes.ProcResV20.gr_ratio = pAgicCtx->ConfigData.ConfigV20.gr_ratio;
    pAgicCtx->ProcRes.ProcResV20.dnloscale = (int)(pAgicCtx->ConfigData.ConfigV20.dnloscale * (1 << 7));
    pAgicCtx->ProcRes.ProcResV20.dnhiscale = (int)(pAgicCtx->ConfigData.ConfigV20.dnhiscale * (1 << 7));
    pAgicCtx->ProcRes.ProcResV20.reglumapointsstep = pAgicCtx->ConfigData.ConfigV20.reglumapointsstep;
    pAgicCtx->ProcRes.ProcResV20.gvaluelimitlo = (int)pAgicCtx->ConfigData.ConfigV20.gvaluelimitlo;
    pAgicCtx->ProcRes.ProcResV20.gvaluelimithi = (int)pAgicCtx->ConfigData.ConfigV20.gvaluelimithi;
    pAgicCtx->ProcRes.ProcResV20.fusionratiohilimt1 = (int)(pAgicCtx->ConfigData.ConfigV20.fusionratiohilimt1 * (1 << 7));
    pAgicCtx->ProcRes.ProcResV20.regstrength_fix = (int)(pAgicCtx->ConfigData.ConfigV20.textureStrength * (1 << 7));

    for (int i = 0; i < 15; i++)
    {
        pAgicCtx->ProcRes.ProcResV20.sigma_y[i] = (int)(pAgicCtx->ConfigData.ConfigV20.sigma_y[i] * (1 << 7));
    }

    pAgicCtx->ProcRes.ProcResV20.noise_cut_en = pAgicCtx->ConfigData.ConfigV20.noise_cut_en;
    pAgicCtx->ProcRes.ProcResV20.noise_coe_a = pAgicCtx->ConfigData.ConfigV20.noise_coe_a;
    pAgicCtx->ProcRes.ProcResV20.noise_coe_b = pAgicCtx->ConfigData.ConfigV20.noise_coe_b;
    pAgicCtx->ProcRes.ProcResV20.diff_clip = pAgicCtx->ConfigData.ConfigV20.diff_clip;

    if (pAgicCtx->ProcRes.ProcResV20.regkgrad2dark < pAgicCtx->ProcRes.ProcResV20.regkgrad2)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV20.regkgrad2dark, pAgicCtx->ProcRes.ProcResV20.regkgrad2);

    if (pAgicCtx->ProcRes.ProcResV20.regmingradthrdark1 < pAgicCtx->ProcRes.ProcResV20.regmingradthr1)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV20.regmingradthrdark1, pAgicCtx->ProcRes.ProcResV20.regmingradthr1);

    if (pAgicCtx->ProcRes.ProcResV20.regmingradthrdark2 < pAgicCtx->ProcRes.ProcResV20.regmingradthr2)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV20.regmingradthrdark2, pAgicCtx->ProcRes.ProcResV20.regmingradthr2);

    if (pAgicCtx->ProcRes.ProcResV20.regdarktthrehi < pAgicCtx->ProcRes.ProcResV20.regdarkthre)
        GIC_SWAP(int, pAgicCtx->ProcRes.ProcResV20.regdarktthrehi, pAgicCtx->ProcRes.ProcResV20.regdarkthre);


    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);

}


void AgicProcessV20
(
    AgicContext_t *pAgicCtx,
    int ISO
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    float ave1 = 0.0f, noiseSigma = 0.0f;
    short ratio = 0;
    short LumaPoints[] = { 0, 128, 256, 384, 512, 640, 768, 896, 1024, 1536, 2048, 2560, 3072, 3584, 4096 };
    short min_busy_threHi = 0, min_busy_threLo = 0;
    short min_grad_thrHi = 0, min_grad_thrLo = 0, min_grad_thr2Hi = 0, min_grad_thr2Lo = 0;
    short k_grad1Hi = 0, k_grad1Lo = 0, k_grad2Hi = 0, k_grad2Lo = 0;
    short gb_threHi = 0, gb_threLo = 0, maxCorVHi = 0, maxCorVLo = 0;
    short maxCorVbothHi = 0, maxCorVbothLo = 0;
    short dark_threHi = 0, dark_threLo = 0, dark_threUpHi = 0, dark_threUpLo = 0;
    short k_grad1_darkHi = 0, k_grad1_darkLo = 0, k_grad2_darkHi = 0, k_grad2_darkLo = 0, min_grad_thr_dark1Hi = 0;
    short min_grad_thr_dark1Lo = 0, min_grad_thr_dark2Hi = 0, min_grad_thr_dark2Lo = 0;
    short noiseCoeaHi = 0, noiseCoeaLo = 0, noiseCoebHi = 0, noiseCoebLo = 0, diffClipHi = 0, diffClipLo = 0;
    float scaleHiHi = 0.0f, scaleHiLo = 0.0f;
    float scaleLoHi = 0.0f, scaleLoLo = 0.0f;
    float strengthHi = 0.0f, strengthLo = 0.0f;
    float strengthGlobalHi = 0.0f, strengthGlobalLo = 0.0f;
    float gValueLimitHiHi = 0.0f, gValueLimitHiLo = 0.0f;
    float gValueLimitLoHi = 0.0f, gValueLimitLoLo = 0.0f;
    int index, iso_hi = 0, iso_lo = 0;
    float pNoiseCurveGicHi_0 = 0.0f, pNoiseCurveGicHi_1 = 0.0f;
    float pNoiseCurveGicLo_0 = 0.0f, pNoiseCurveGicLo_1 = 0.0f;

    LOGI_AGIC("%s(%d): enter, ISO=%d\n", __FUNCTION__, __LINE__, ISO);

    if(pAgicCtx == NULL)
        LOGE_AGIC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);

    if(ISO <= 50) {
        index = 0;
        ratio = 0;
    } else if (ISO > 12800) {
        index = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ISO_len - 2;
        ratio = (1 << 4);
    } else {
        for (index = 0; index < (pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ISO_len - 2); index++)
        {
            iso_lo = (int)(pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ISO[index]);
            iso_hi = (int)(pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ISO[index + 1]);
            LOGD_AGIC("index=%d,  iso_lo=%d, iso_hi=%d\n", index, iso_lo, iso_hi);
            if (ISO > iso_lo && ISO <= iso_hi)
            {
                break;
            }
        }
        ratio = ((ISO - iso_lo) * (1 << 4)) / (iso_hi - iso_lo);
    }
    min_busy_threHi      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_busy_thre[index + 1];
    min_busy_threLo      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_busy_thre[index];
    min_grad_thrHi       = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr1[index + 1];
    min_grad_thrLo       = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr1[index];
    min_grad_thr2Hi      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr2[index + 1];
    min_grad_thr2Lo      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr2[index];
    k_grad1Hi            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad1[index + 1];
    k_grad1Lo            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad1[index];
    k_grad2Hi            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad2[index + 1];
    k_grad2Lo            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad2[index];
    gb_threHi            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.gb_thre[index + 1];
    gb_threLo            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.gb_thre[index];
    maxCorVHi            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.maxCorV[index + 1];
    maxCorVLo            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.maxCorV[index];
    maxCorVbothHi        = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.maxCorVboth[index + 1];
    maxCorVbothLo        = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.maxCorVboth[index];
    dark_threHi          = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.dark_thre[index + 1];
    dark_threLo          = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.dark_thre[index];
    dark_threUpHi        = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.dark_threHi[index + 1];
    dark_threUpLo        = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.dark_threHi[index];
    k_grad1_darkHi       = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad1_dark[index + 1];
    k_grad1_darkLo       = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad1_dark[index];
    k_grad2_darkHi       = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad2_dark[index + 1];
    k_grad2_darkLo       = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.k_grad2_dark[index];
    min_grad_thr_dark1Hi = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr_dark1[index + 1];
    min_grad_thr_dark1Lo = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr_dark1[index];
    min_grad_thr_dark2Hi = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr_dark2[index + 1];
    min_grad_thr_dark2Lo = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.min_grad_thr_dark2[index];
    pNoiseCurveGicHi_0 = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noiseCurve_0[index + 1];
    pNoiseCurveGicLo_0 = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noiseCurve_0[index];
    pNoiseCurveGicHi_1 = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noiseCurve_1[index + 1];
    pNoiseCurveGicLo_1 = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noiseCurve_1[index];
    scaleHiHi            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ScaleHi[index + 1];
    scaleHiLo            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ScaleHi[index];
    scaleLoHi            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ScaleLo[index + 1];
    scaleLoLo            = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.ScaleLo[index];
    strengthHi           = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.textureStrength[index + 1];
    strengthLo           = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.textureStrength[index];
    strengthGlobalHi     = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.globalStrength[index + 1];
    strengthGlobalLo     = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.globalStrength[index];
    gValueLimitHiHi      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.GValueLimitHi[index + 1];
    gValueLimitHiLo      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.GValueLimitHi[index];
    gValueLimitLoHi      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.GValueLimitLo[index + 1];
    gValueLimitLoLo      = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.GValueLimitLo[index];
    noiseCoeaHi          = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noise_coea[index + 1];
    noiseCoeaLo          = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noise_coea[index];
    noiseCoebHi          = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noise_coeb[index + 1];
    noiseCoebLo          = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.noise_coeb[index];
    diffClipHi           = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.diff_clip[index + 1];
    diffClipLo           = pAgicCtx->full_param.gic_v20->GicTuningPara.GicData.diff_clip[index];

    float ratioF = ratio / 16.0f;
    pAgicCtx->ConfigData.ConfigV20.gic_en = pAgicCtx->full_param.gic_v20->GicTuningPara.enable ? 1 : 0;
    pAgicCtx->ConfigData.ConfigV20.edge_open = pAgicCtx->full_param.gic_v20->GicTuningPara.edge_en ? 1 : 0;
    pAgicCtx->ConfigData.ConfigV20.regmingradthrdark1 = (ratio * (min_grad_thr_dark1Hi - min_grad_thr_dark1Lo) + min_grad_thr_dark1Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regmingradthrdark2 = (ratio * (min_grad_thr_dark2Hi - min_grad_thr_dark2Lo) + min_grad_thr_dark2Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regminbusythre = (ratio * (min_busy_threHi - min_busy_threLo) + min_busy_threLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regdarkthre = (ratio * (dark_threHi - dark_threLo) + dark_threLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regmaxcorvboth = (ratio * (maxCorVbothHi - maxCorVbothLo) + maxCorVbothLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regdarktthrehi = (ratio * (dark_threUpHi - dark_threUpLo) + dark_threUpLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regkgrad2dark = (ratio * (k_grad2_darkHi - k_grad2_darkLo) + k_grad2_darkLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regkgrad1dark = (ratio * (k_grad1_darkHi - k_grad1_darkLo) + k_grad1_darkLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.globalStrength = ratioF * (strengthGlobalHi - strengthGlobalLo) + strengthGlobalLo;
    pAgicCtx->ConfigData.ConfigV20.regkgrad2 = (ratio * (k_grad2Hi - k_grad2Lo) + k_grad2Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regkgrad1 = (ratio * (k_grad1Hi - k_grad1Lo) + k_grad1Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.reggbthre = (ratio * (gb_threHi - gb_threLo) + gb_threLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regmaxcorv = (ratio * (maxCorVHi - maxCorVLo) + maxCorVLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regmingradthr1 = (ratio * (min_grad_thrHi - min_grad_thrLo) + min_grad_thrLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.regmingradthr2 = (ratio * (min_grad_thr2Hi - min_grad_thr2Lo) + min_grad_thr2Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.gr_ratio = pAgicCtx->full_param.gic_v20->GicTuningPara.gr_ration;
    pAgicCtx->ConfigData.ConfigV20.dnhiscale = ratioF * (scaleHiHi - scaleHiLo) + scaleHiLo;
    pAgicCtx->ConfigData.ConfigV20.dnloscale = ratioF * (scaleLoHi - scaleLoLo) + scaleLoLo;
    pAgicCtx->ConfigData.ConfigV20.reglumapointsstep = 7;
    pAgicCtx->ConfigData.ConfigV20.gvaluelimithi = ratioF * (gValueLimitHiHi - gValueLimitHiLo) + gValueLimitHiLo;
    pAgicCtx->ConfigData.ConfigV20.gvaluelimitlo = ratioF * (gValueLimitLoHi - gValueLimitLoLo) + gValueLimitLoLo;
    pAgicCtx->ConfigData.ConfigV20.fusionratiohilimt1 = 0.75;
    pAgicCtx->ConfigData.ConfigV20.textureStrength = ratioF * (strengthHi - strengthLo) + strengthLo;
    pAgicCtx->ConfigData.ConfigV20.noiseCurve_0 = ratioF * (pNoiseCurveGicHi_0 - pNoiseCurveGicLo_0) + pNoiseCurveGicLo_0;
    pAgicCtx->ConfigData.ConfigV20.noiseCurve_1 =  ratioF * (pNoiseCurveGicHi_1 - pNoiseCurveGicLo_1) + pNoiseCurveGicLo_1;

    for (int i = 0; i < 15; i++) {
        ave1 = LumaPoints[i];
        noiseSigma = pAgicCtx->ConfigData.ConfigV20.noiseCurve_0 * sqrt(ave1) +  pAgicCtx->ConfigData.ConfigV20.noiseCurve_1;
        if (noiseSigma < 0)
        {
            noiseSigma = 0;
        }
        pAgicCtx->ConfigData.ConfigV20.sigma_y[i] = noiseSigma;
    }

    pAgicCtx->ConfigData.ConfigV20.noise_cut_en = pAgicCtx->full_param.gic_v20->GicTuningPara.noise_cut_en ? 1 : 0;
    pAgicCtx->ConfigData.ConfigV20.noise_coe_a = (ratio * (noiseCoeaHi - noiseCoeaLo) + noiseCoeaLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.noise_coe_b = (ratio * (noiseCoebHi - noiseCoebLo) + noiseCoebLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV20.diff_clip = (ratio * (diffClipHi - diffClipLo) +  diffClipLo * (1 << 4) + (1 << 3)) >> 4;


    short mulBit = 0;
    int bitValue = RKAIQ_GIC_BITS;
    if(bitValue > 10)
    {
        mulBit = 1 << (bitValue - 10);
    }
    else
    {
        mulBit = 1;
    }
    pAgicCtx->ConfigData.ConfigV20.regminbusythre *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regmingradthr1 *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regmingradthr2 *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.reggbthre *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regmaxcorv *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regmaxcorvboth *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regdarkthre *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regdarktthrehi *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regmingradthrdark1 *= mulBit;
    pAgicCtx->ConfigData.ConfigV20.regmingradthrdark2 *= mulBit;

    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);

}

void AgicProcessV21
(
    AgicContext_t *pAgicCtx,
    int ISO
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    float ave1 = 0.0f, noiseSigma = 0.0f;
    short ratio = 0;
    short LumaPoints[] = { 0, 128, 256, 384, 512, 640, 768, 896, 1024, 1536, 2048, 2560, 3072, 3584, 4096 };
    short min_busy_threHi = 0, min_busy_threLo = 0;
    short min_grad_thrHi = 0, min_grad_thrLo = 0, min_grad_thr2Hi = 0, min_grad_thr2Lo = 0;
    short k_grad1Hi = 0, k_grad1Lo = 0, k_grad2Hi = 0, k_grad2Lo = 0;
    short gb_threHi = 0, gb_threLo = 0, maxCorVHi = 0, maxCorVLo = 0;
    short maxCorVbothHi = 0, maxCorVbothLo = 0;
    short dark_threHi = 0, dark_threLo = 0, dark_threUpHi = 0, dark_threUpLo = 0;
    short k_grad1_darkHi = 0, k_grad1_darkLo = 0, k_grad2_darkHi = 0, k_grad2_darkLo = 0, min_grad_thr_dark1Hi = 0;
    short min_grad_thr_dark1Lo = 0, min_grad_thr_dark2Hi = 0, min_grad_thr_dark2Lo = 0;
    short diffClipHi = 0, diffClipLo = 0;
    float strengthGlobalHi = 0.0f, strengthGlobalLo = 0.0f;
    float NoiseScaleHi = 0.0f, NoiseScaleLo = 0.0f;
    float NoiseBaseHi = 0.0f, NoiseBaseLo = 0.0f;
    int index, iso_hi = 0, iso_lo = 0;
    float pNoiseCurveGicHi_0 = 0.0f, pNoiseCurveGicHi_1 = 0.0f;
    float pNoiseCurveGicLo_0 = 0.0f, pNoiseCurveGicLo_1 = 0.0f;

    LOGI_AGIC("%s(%d): enter, ISO=%d\n", __FUNCTION__, __LINE__, ISO);

    if(pAgicCtx == NULL)
        LOGE_AGIC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);


    if(ISO <= 50) {
        index = 0;
        ratio = 0;
    } else if (ISO > 12800) {
        index = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.ISO_len - 2;
        ratio = (1 << 4);
    } else {
        for (index = 0; index < (pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.ISO_len - 1); index++)
        {
            iso_lo = (int)(pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.ISO[index]);
            iso_hi = (int)(pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.ISO[index + 1]);
            LOGD_AGIC("index=%d,  iso_lo=%d, iso_hi=%d\n", index, iso_lo, iso_hi);
            if (ISO > iso_lo && ISO <= iso_hi)
            {
                break;
            }
        }
        ratio = ((ISO - iso_lo) * (1 << 4)) / (iso_hi - iso_lo);
    }

    min_busy_threHi      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_busy_thre[index + 1];
    min_busy_threLo      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_busy_thre[index];
    min_grad_thrHi       = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr1[index + 1];
    min_grad_thrLo       = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr1[index];
    min_grad_thr2Hi      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr2[index + 1];
    min_grad_thr2Lo      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr2[index];
    k_grad1Hi            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad1[index + 1];
    k_grad1Lo            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad1[index];
    k_grad2Hi            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad2[index + 1];
    k_grad2Lo            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad2[index];
    gb_threHi            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.gb_thre[index + 1];
    gb_threLo            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.gb_thre[index];
    maxCorVHi            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.maxCorV[index + 1];
    maxCorVLo            = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.maxCorV[index];
    maxCorVbothHi        = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.maxCorVboth[index + 1];
    maxCorVbothLo        = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.maxCorVboth[index];
    dark_threHi          = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.dark_thre[index + 1];
    dark_threLo          = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.dark_thre[index];
    dark_threUpHi        = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.dark_threHi[index + 1];
    dark_threUpLo        = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.dark_threHi[index];
    k_grad1_darkHi       = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad1_dark[index + 1];
    k_grad1_darkLo       = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad1_dark[index];
    k_grad2_darkHi       = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad2_dark[index + 1];
    k_grad2_darkLo       = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.k_grad2_dark[index];
    min_grad_thr_dark1Hi = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr_dark1[index + 1];
    min_grad_thr_dark1Lo = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr_dark1[index];
    min_grad_thr_dark2Hi = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr_dark2[index + 1];
    min_grad_thr_dark2Lo = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.min_grad_thr_dark2[index];
    pNoiseCurveGicHi_0 = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.noiseCurve_0[index + 1];
    pNoiseCurveGicLo_0 = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.noiseCurve_0[index];
    pNoiseCurveGicHi_1 = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.noiseCurve_1[index + 1];
    pNoiseCurveGicLo_1 = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.noiseCurve_1[index];
    strengthGlobalHi     = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.globalStrength[index + 1];
    strengthGlobalLo     = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.globalStrength[index];
    diffClipHi           = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.diff_clip[index + 1];
    diffClipLo           = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.diff_clip[index];
    NoiseScaleHi      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.NoiseScale[index + 1];
    NoiseScaleLo      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.NoiseScale[index];
    NoiseBaseHi      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.NoiseBase[index + 1];
    NoiseBaseLo      = pAgicCtx->full_param.gic_v21->GicTuningPara.GicData.NoiseBase[index];

    float ratioF = ratio / 16.0f;
    pAgicCtx->ConfigData.ConfigV21.gic_en = pAgicCtx->full_param.gic_v21->GicTuningPara.enable ? 1 : 0;
    pAgicCtx->ConfigData.ConfigV21.regmingradthrdark1 = (ratio * (min_grad_thr_dark1Hi - min_grad_thr_dark1Lo) + min_grad_thr_dark1Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regmingradthrdark2 = (ratio * (min_grad_thr_dark2Hi - min_grad_thr_dark2Lo) + min_grad_thr_dark2Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regminbusythre = (ratio * (min_busy_threHi - min_busy_threLo) + min_busy_threLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regdarkthre = (ratio * (dark_threHi - dark_threLo) + dark_threLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regmaxcorvboth = (ratio * (maxCorVbothHi - maxCorVbothLo) + maxCorVbothLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regdarktthrehi = (ratio * (dark_threUpHi - dark_threUpLo) + dark_threUpLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regkgrad1dark = (ratio * (k_grad1_darkHi - k_grad1_darkLo) + k_grad1_darkLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regkgrad2dark = (ratio * (k_grad2_darkHi - k_grad2_darkLo) + k_grad2_darkLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regkgrad1 = (ratio * (k_grad1Hi - k_grad1Lo) + k_grad1Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regkgrad2 = (ratio * (k_grad2Hi - k_grad2Lo) + k_grad2Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.reggbthre = (ratio * (gb_threHi - gb_threLo) + gb_threLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regmaxcorv = (ratio * (maxCorVHi - maxCorVLo) + maxCorVLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regmingradthr1 = (ratio * (min_grad_thrHi - min_grad_thrLo) + min_grad_thrLo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.regmingradthr2 = (ratio * (min_grad_thr2Hi - min_grad_thr2Lo) + min_grad_thr2Lo * (1 << 4) + (1 << 3)) >> 4;
    pAgicCtx->ConfigData.ConfigV21.gr_ratio = pAgicCtx->full_param.gic_v21->GicTuningPara.gr_ration;
    pAgicCtx->ConfigData.ConfigV21.noise_scale = ratioF * (NoiseScaleHi - NoiseScaleLo) + NoiseScaleLo;
    pAgicCtx->ConfigData.ConfigV21.noise_base = ratioF * (NoiseBaseHi - NoiseBaseLo) + NoiseBaseLo;
    pAgicCtx->ConfigData.ConfigV21.noiseCurve_0 = ratioF * (pNoiseCurveGicHi_0 - pNoiseCurveGicLo_0) + pNoiseCurveGicLo_0;
    pAgicCtx->ConfigData.ConfigV21.noiseCurve_1 =  ratioF * (pNoiseCurveGicHi_1 - pNoiseCurveGicLo_1) + pNoiseCurveGicLo_1;

    for (int i = 0; i < 15; i++) {
        ave1 = LumaPoints[i];
        noiseSigma = pAgicCtx->ConfigData.ConfigV21.noiseCurve_0 * sqrt(ave1) +  pAgicCtx->ConfigData.ConfigV21.noiseCurve_1;
        if (noiseSigma < 0)
        {
            noiseSigma = 0;
        }
        pAgicCtx->ConfigData.ConfigV20.sigma_y[i] = noiseSigma;
    }

    pAgicCtx->ConfigData.ConfigV21.globalStrength = ratioF * (strengthGlobalHi - strengthGlobalLo) + strengthGlobalLo;
    pAgicCtx->ConfigData.ConfigV21.diff_clip = (ratio * (diffClipHi - diffClipLo) +  diffClipLo * (1 << 4) + (1 << 3)) >> 4;


    short mulBit = 0;
    int bitValue = RKAIQ_GIC_BITS;
    if(bitValue > 10)
    {
        mulBit = 1 << (bitValue - 10);
    }
    else
    {
        mulBit = 1;
    }
    pAgicCtx->ConfigData.ConfigV21.regminbusythre *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regmingradthr1 *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regmingradthr2 *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.reggbthre *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regmaxcorv *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regmaxcorvboth *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regdarkthre *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regdarktthrehi *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regmingradthrdark1 *= mulBit;
    pAgicCtx->ConfigData.ConfigV21.regmingradthrdark2 *= mulBit;

    LOGD_AGIC("%s(%d): gic_en:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.gic_en);
    LOGD_AGIC("%s(%d): regmingradthrdark2:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regmingradthrdark2);
    LOGD_AGIC("%s(%d): regmingradthrdark1:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regmingradthrdark1);
    LOGD_AGIC("%s(%d): regminbusythre:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regminbusythre);
    LOGD_AGIC("%s(%d): regdarkthre:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regdarkthre);
    LOGD_AGIC("%s(%d): regmaxcorvboth:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regmaxcorvboth);
    LOGD_AGIC("%s(%d): regdarktthrehi:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regdarktthrehi);
    LOGD_AGIC("%s(%d): regkgrad2dark:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regkgrad2dark);
    LOGD_AGIC("%s(%d): regkgrad1dark:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regkgrad1dark);
    LOGD_AGIC("%s(%d): regkgrad2:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regkgrad2);
    LOGD_AGIC("%s(%d): regkgrad1:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regkgrad1);
    LOGD_AGIC("%s(%d): reggbthre:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.reggbthre);
    LOGD_AGIC("%s(%d): regmaxcorv:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regmaxcorv);
    LOGD_AGIC("%s(%d): regmingradthr2:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regmingradthr2);
    LOGD_AGIC("%s(%d): regmingradthr1:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.regmingradthr1);
    LOGD_AGIC("%s(%d): gr_ratio:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.gr_ratio);
    LOGD_AGIC("%s(%d): noise_scale:%f\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.noise_scale);
    LOGD_AGIC("%s(%d): noise_base:%f\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.noise_base);
    LOGD_AGIC("%s(%d): globalStrength:%f\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.globalStrength);
    LOGD_AGIC("%s(%d): diff_clip:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.diff_clip);
    LOGD_AGIC("%s(%d): sigma_y[0]:%d ", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.sigma_y[0]);
    for(int i = 1; i < 7; i++)
        LOGD_AGIC("%s(%d): sigma_y[%d]:%d ", __FUNCTION__, __LINE__, i, pAgicCtx->ConfigData.ConfigV21.sigma_y[i]);
    LOGD_AGIC("%s(%d): sigma_y[7]:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.sigma_y[7]);
    LOGD_AGIC("%s(%d): sigma_y[8]:%d ", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.sigma_y[8]);
    for(int i = 9; i < 14; i++)
        LOGD_AGIC("%s(%d): sigma_y[%d]:%d ", __FUNCTION__, __LINE__, i, pAgicCtx->ConfigData.ConfigV21.sigma_y[i]);
    LOGD_AGIC("%s(%d): sigma_y[14]:%d\n", __FUNCTION__, __LINE__, pAgicCtx->ConfigData.ConfigV21.sigma_y[14]);

    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);

}

XCamReturn
AgicProcess
(
    AgicContext_t *pAgicCtx,
    int ISO,
    int mode
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    if(CHECK_ISP_HW_V20())
        AgicProcessV20(pAgicCtx, ISO);
    else if(CHECK_ISP_HW_V21())
        AgicProcessV21(pAgicCtx, ISO);
    else
        LOGE_AGIC(" %s:Wrong hardware version!! \n", __func__);

    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
    return XCAM_RETURN_NO_ERROR;

}

XCamReturn
AgicGetProcResult
(
    AgicContext_t*    pAgicCtx
)
{
    LOGI_AGIC("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    if(pAgicCtx == NULL) {
        LOGE_AGIC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return XCAM_RETURN_ERROR_PARAM;
    }

    if(CHECK_ISP_HW_V20())
        AgicGetProcResultV20(pAgicCtx);
    else if(CHECK_ISP_HW_V21())
        AgicGetProcResultV21(pAgicCtx);
    else
        LOGE_AGIC(" %s:Wrong hardware version!! \n", __func__);

    LOGI_AGIC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
    return XCAM_RETURN_NO_ERROR;
}