#include "rk_aiq_asharp_algo_sharp_v3.h"

RKAIQ_BEGIN_DECLARE


Asharp3_result_t sharp_get_mode_by_name_V3(struct list_head* pCalibdbList, char *name, Calibdb_Sharp_V3_t** ppProfile)
{
    int i = 0;
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;
    LOGI_ASHARP("%s(%d): enter \n", __FUNCTION__, __LINE__);

    if(pCalibdbList == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(name == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(ppProfile == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    LOGD_ASHARP("%s(%d): moden:%s \n", __FUNCTION__, __LINE__, name);

#if 1
    *ppProfile = NULL;
    struct list_head* p;
    p = pCalibdbList->next;

    int num = get_list_num(pCalibdbList);
    LOGD_ASHARP("%s(%d): list num:%d list:%p \n", __FUNCTION__, __LINE__, num, pCalibdbList);


    while (p != pCalibdbList)
    {
        Calibdb_Sharp_V3_t* pProfile = container_of(p, Calibdb_Sharp_V3_t, listItem);
        LOGD_ASHARP("%s:%d %s  %p \n",
                    __FUNCTION__, __LINE__, pProfile->modeName, p);
        if (!strncmp(pProfile->modeName, name, sizeof(pProfile->modeName))) {
            *ppProfile = pProfile;
            return res;
        }
        p = p->next;
    }

    if(pCalibdbList->next != pCalibdbList) {
        Calibdb_Sharp_V3_t* pProfile = container_of(pCalibdbList->next, Calibdb_Sharp_V3_t, listItem);
        *ppProfile = pProfile;
    }
#else


#endif

    LOGI_ASHARP("%s(%d): exit \n", __FUNCTION__, __LINE__);
    return res;

}


Asharp3_result_t sharp_get_setting_by_name_V3(struct list_head *pSettingList, char *name, Calibdb_Sharp_params_V3_t** ppSetting)
{
    int i = 0;
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;

    LOGI_ASHARP("%s(%d): enter  \n", __FUNCTION__, __LINE__);

    if(pSettingList == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(name == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(ppSetting == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    LOGD_ASHARP("%s(%d): name:%s  \n", __FUNCTION__, __LINE__, name);

    *ppSetting = NULL;

    struct list_head* p;
    p = pSettingList->next;

    int num = get_list_num(pSettingList);
    LOGD_ASHARP("%s(%d): list num:%d list:%p \n", __FUNCTION__, __LINE__, num, pSettingList);

    while (p != pSettingList)
    {
        Calibdb_Sharp_params_V3_t* pSetting = container_of(p, Calibdb_Sharp_params_V3_t, listItem);
        LOGD_ASHARP("%s:%d:  %s  %p \n",
                    __FUNCTION__, __LINE__, pSetting->snr_mode, p);
        if (!strncmp(pSetting->snr_mode, name, sizeof(pSetting->snr_mode))) {
            *ppSetting = pSetting;
            return res;
        }
        p = p->next;
    }

    if(pSettingList->next != pSettingList) {
        Calibdb_Sharp_params_V3_t* pSetting = container_of(pSettingList->next, Calibdb_Sharp_params_V3_t, listItem);
        *ppSetting = pSetting;
    }

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

    return res;
}



Asharp3_result_t sharp_config_setting_param_V3(RK_SHARP_Params_V3_t *pParams, struct list_head *pCalibdbList, char* param_mode, char * snr_name)
{
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;
    Calibdb_Sharp_V3_t *pProfile;
    Calibdb_Sharp_params_V3_t *pCalibParms;

    LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);

    if(pParams == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(pCalibdbList == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(param_mode == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(snr_name == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    LOGD_ASHARP("%s(%d): mode:%s  setting:%s \n", __FUNCTION__, __LINE__, param_mode, snr_name);

    res = sharp_get_mode_by_name_V3(pCalibdbList, param_mode, &pProfile);
    if(res != ASHARP3_RET_SUCCESS) {
        LOGW_ASHARP("%s(%d): error!!!  can't find mode name in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
    }

    res = sharp_get_setting_by_name_V3(&pProfile->listHead, snr_name, &pCalibParms);
    if(res != ASHARP3_RET_SUCCESS) {
        LOGW_ASHARP("%s(%d): error!!!  can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
    }

    res = sharp_init_params_V3(pParams, pCalibParms);
    pParams->enable = pProfile->enable;

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

    return res;

}

Asharp3_result_t sharp_init_params_V3(RK_SHARP_Params_V3_t *pSharpParams, Calibdb_Sharp_params_V3_t* pCalibParms)
{
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;
    int i = 0;
    int j = 0;
    short isoCurveSectValue;
    short isoCurveSectValue1;
    float ave1, ave2, ave3, ave4;
    int bit_calib = 12;
    int bit_proc;
    int bit_shift;

    LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);

    if(pSharpParams == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(pCalibParms == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    for(i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++) {
        pSharpParams->luma_point[i] = pCalibParms->luma_point[i];
    }

    for(i = 0; i < RK_SHARP_V3_MAX_ISO_NUM; i++) {
        pSharpParams->iso[i] = pCalibParms->iso[i];

        for(j = 0; j < RK_SHARP_V3_LUMA_POINT_NUM; j++) {
            pSharpParams->luma_sigma[i][j] = pCalibParms->luma_sigma[i][j];
            pSharpParams->lum_clip_h[i][j] = pCalibParms->lum_clip_h[i][j];
            pSharpParams->ehf_th[i][j] = pCalibParms->ehf_th[i][j];
            pSharpParams->clip_hf[i][j] = pCalibParms->clip_hf[i][j];
            pSharpParams->clip_mf[i][j] = pCalibParms->clip_mf[i][j];
            pSharpParams->clip_lf[i][j] = pCalibParms->clip_lf[i][j];
            pSharpParams->local_wgt[i][j] = pCalibParms->local_wgt[i][j];
        }

        pSharpParams->pbf_gain[i] = pCalibParms->pbf_gain[i];
        pSharpParams->pbf_add[i] = pCalibParms->pbf_add[i];
        pSharpParams->pbf_ratio[i] = pCalibParms->pbf_ratio[i];
        pSharpParams->gaus_ratio[i] = pCalibParms->gaus_ratio[i];
        pSharpParams->sharp_ratio[i] = pCalibParms->sharp_ratio[i];
        pSharpParams->bf_gain[i] = pCalibParms->bf_gain[i];
        pSharpParams->bf_add[i] = pCalibParms->bf_add[i];
        pSharpParams->bf_ratio[i] = pCalibParms->bf_ratio[i];

        for(j = 0; j < 3; j++) {
            pSharpParams->kernel_bila_filter[i][j] = pCalibParms->kernel_bila_filter[j][i];
            pSharpParams->kernel_pre_bila_filter[i][j] = pCalibParms->kernel_pre_bila_filter[j][i];
            pSharpParams->kernel_range_filter[i][j] = pCalibParms->kernel_range_filter[j][i];
            LOGD_ASHARP("kernel: index[%d][%d] = %f\n", i, j, pSharpParams->kernel_bila_filter[i][j]);
        }

        pSharpParams->sharp_ratio_h[i] = pCalibParms->sharp_ratio_h[i];
        pSharpParams->sharp_ratio_m[i] = pCalibParms->sharp_ratio_m[i];
        pSharpParams->sharp_ratio_l[i] = pCalibParms->sharp_ratio_l[i];
    }

    LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
    return res;
}


Asharp3_result_t sharp_select_params_by_ISO_V3(
    RK_SHARP_Params_V3_t *pParams,
    RK_SHARP_Params_V3_Select_t *pSelect,
    Asharp3_ExpInfo_t *pExpInfo
)
{
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;

    int i;
    int iso = 50;
    int iso_div = 50;
    float ratio = 0.0f;
    int iso_low = iso, iso_high = iso;
    int gain_high = 0, gain_low = 0;
    int max_iso_step = RK_SHARP_V3_MAX_ISO_NUM;
    int sum_coeff, offset;

    LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);

    if(pParams == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(pSelect == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(pExpInfo == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    iso = pExpInfo->arIso[pExpInfo->hdr_mode];

#ifndef RK_SIMULATOR_HW
    for (i = 0; i < max_iso_step - 1; i++) {
        if (iso >=  pParams->iso[i]  &&  iso <=  pParams->iso[i + 1] ) {
            iso_low = pParams->iso[i] ;
            iso_high = pParams->iso[i + 1];
            gain_low = i;
            gain_high = i + 1;
            ratio = (float)(iso - iso_low) / (iso_high - iso_low);
            break;
        }
    }

    if(iso < pParams->iso[0] ) {
        iso_low = pParams->iso[0] ;
        iso_high = pParams->iso[1];
        gain_low = 0;
        gain_high = 1;
        ratio = 0;
    }

    if(iso > pParams->iso[max_iso_step - 1] ) {
        iso_low = pParams->iso[max_iso_step - 2] ;
        iso_high = pParams->iso[max_iso_step - 1];
        gain_low = max_iso_step - 2;
        gain_high = max_iso_step - 1;
        ratio = 1;
    }
#else
    for (i = max_iso_step - 1; i >= 0; i--)
    {
        if (iso < iso_div * (2 << i))
        {
            iso_low = iso_div * (2 << (i)) / 2;
            iso_high = iso_div * (2 << i);
        }
    }

    ratio = (float)(iso - iso_low) / (iso_high - iso_low);
    if (iso_low == iso)
    {
        iso_high = iso;
        ratio = 0;
    }
    if (iso_high == iso )
    {
        iso_low = iso;
        ratio = 1;
    }
    gain_high = (int)(log((float)iso_high / 50) / log((float)2));
    gain_low = (int)(log((float)iso_low / 50) / log((float)2));


    gain_low = MIN(MAX(gain_low, 0), max_iso_step - 1);
    gain_high = MIN(MAX(gain_high, 0), max_iso_step - 1);
#endif

    LOGD_ASHARP("%s:%d iso:%d gainlow:%d gian_high:%d\n", __FUNCTION__, __LINE__, iso, gain_high, gain_high);

    pSelect->enable = pParams->enable;
    pSelect->pbf_gain = INTERP_V3(pParams->pbf_gain[gain_low], pParams->pbf_gain[gain_high], ratio);
    pSelect->pbf_add = INTERP_V3(pParams->pbf_add[gain_low], pParams->pbf_add[gain_high], ratio);
    pSelect->pbf_ratio = INTERP_V3(pParams->pbf_ratio[gain_low], pParams->pbf_ratio[gain_high], ratio);

    pSelect->gaus_ratio = INTERP_V3(pParams->gaus_ratio[gain_low], pParams->gaus_ratio[gain_high], ratio);
    pSelect->sharp_ratio = INTERP_V3(pParams->sharp_ratio[gain_low], pParams->sharp_ratio[gain_high], ratio);

    pSelect->bf_gain = INTERP_V3(pParams->bf_gain[gain_low], pParams->bf_gain[gain_high], ratio);
    pSelect->bf_add = INTERP_V3(pParams->bf_add[gain_low], pParams->bf_add[gain_high], ratio);
    pSelect->bf_ratio = INTERP_V3(pParams->bf_ratio[gain_low], pParams->bf_ratio[gain_high], ratio);

    for(int i = 0; i < RK_SHARP_V3_PBF_DIAM * RK_SHARP_V3_PBF_DIAM; i++) {
        pSelect->kernel_pre_bila_filter[i] = INTERP_V3(pParams->kernel_pre_bila_filter [gain_low][i], pParams->kernel_pre_bila_filter[gain_high][i], ratio);
    }

    for(int i = 0; i < RK_SHARP_V3_RF_DIAM * RK_SHARP_V3_RF_DIAM; i++) {
        pSelect->kernel_range_filter[i] = INTERP_V3(pParams->kernel_range_filter [gain_low][i], pParams->kernel_range_filter[gain_high][i], ratio);
    }

    for(int i = 0; i < RK_SHARP_V3_BF_DIAM * RK_SHARP_V3_BF_DIAM; i++) {
        pSelect->kernel_bila_filter[i] = INTERP_V3(pParams->kernel_bila_filter [gain_low][i], pParams->kernel_bila_filter[gain_high][i], ratio);
    }

    //////////////////////////////////////////////////////////////////////////
    // test params
    pSelect->sharp_ratio_h = INTERP_V3(pParams->sharp_ratio_h[gain_low], pParams->sharp_ratio_h[gain_high], ratio);
    pSelect->sharp_ratio_m = INTERP_V3(pParams->sharp_ratio_m[gain_low], pParams->sharp_ratio_m[gain_high], ratio);
    pSelect->sharp_ratio_l = INTERP_V3(pParams->sharp_ratio_l[gain_low], pParams->sharp_ratio_l[gain_high], ratio);
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++) {
        pSelect->luma_point[i] = pParams->luma_point[i];
        pSelect->luma_sigma[i] = INTERP_V3(pParams->luma_sigma[gain_low][i], pParams->luma_sigma[gain_high][i], ratio);
        pSelect->lum_clip_h[i] = (int16_t)ROUND_F(INTERP_V3(pParams->lum_clip_h[gain_low][i],  pParams->lum_clip_h[gain_high][i], ratio));
        pSelect->ehf_th[i] = (int16_t)ROUND_F(INTERP_V3(pParams->ehf_th[gain_low][i], pParams->ehf_th[gain_high][i], ratio));

        //////////////////////////////////////////////////////////////////////////
        pSelect->clip_hf[i] = (int16_t)ROUND_F(INTERP_V3(pParams->clip_hf[gain_low][i],  pParams->clip_hf[gain_high][i], ratio));
        pSelect->clip_mf[i] = (int16_t)ROUND_F(INTERP_V3(pParams->clip_mf[gain_low][i],  pParams->clip_mf[gain_high][i], ratio));
        pSelect->clip_lf[i] = (int16_t)ROUND_F(INTERP_V3(pParams->clip_lf[gain_low][i],  pParams->clip_lf[gain_high][i], ratio));
        pSelect->local_wgt[i] = (int16_t)ROUND_F(INTERP_V3(pParams->local_wgt[gain_low][i],  pParams->local_wgt[gain_high][i], ratio));
    }

    //////////////////////////////////////////////////////////////////////////
    for(int i = 0; i < RK_SHARP_V3_HF_DIAM * RK_SHARP_V3_HF_DIAM; i++) {
        pSelect->kernel_hf_filter[i] = INTERP_V3(pParams->kernel_hf_filter[gain_low][i], pParams->kernel_hf_filter[gain_high][i], ratio);
    }

    for(int i = 0; i < RK_SHARP_V3_MF_DIAM * RK_SHARP_V3_MF_DIAM; i++)
    {
        pSelect->kernel_mf_filter[i] = INTERP_V3(pParams->kernel_mf_filter[gain_low][i], pParams->kernel_mf_filter[gain_high][i], ratio);
    }

    for(int i = 0; i < RK_SHARP_V3_LF_DIAM * RK_SHARP_V3_LF_DIAM; i++)
    {
        pSelect->kernel_lf_filter[i] = INTERP_V3(pParams->kernel_lf_filter[gain_low][i], pParams->kernel_lf_filter[gain_high][i], ratio);
    }

    LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
    return res;
}



Asharp3_result_t sharp_fix_transfer_V3(RK_SHARP_Params_V3_Select_t *pSelect, RK_SHARP_Fix_V3_t* pFix, float fPercent)
{
    int sum_coeff, offset;
    int pbf_sigma_shift = 0;
    int bf_sigma_shift = 0;
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;
    int tmp = 0;

    LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);

    if(pSelect == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(pFix == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    if(fPercent <= 0.0) {
        fPercent = 0.000001;
    }

    // SHARP_SHARP_EN (0x0000)
    pFix->sharp_bypass = 0;
    pFix->sharp_en = pSelect->enable;

    // SHARP_SHARP_RATIO  (0x0004)
    tmp = (int)ROUND_F(pSelect->sharp_ratio * fPercent * (1 << rk_sharp_V3_sharp_ratio_fix_bits));
    pFix->sharp_sharp_ratio = CLIP(tmp, 0, 63);
    tmp = (int)ROUND_F(pSelect->bf_ratio / fPercent * (1 << rk_sharp_V3_bf_ratio_fix_bits));
    pFix->sharp_bf_ratio = CLIP(tmp, 0, 128);
    tmp = (int)ROUND_F(pSelect->gaus_ratio / fPercent * (1 << rk_sharp_V3_gaus_ratio_fix_bits));
    pFix->sharp_gaus_ratio = CLIP(tmp, 0, 128);
    tmp = (int)ROUND_F(pSelect->pbf_ratio / fPercent * (1 << rk_sharp_V3_bf_ratio_fix_bits));
    pFix->sharp_pbf_ratio = CLIP(tmp, 0, 128);

    // SHARP_SHARP_LUMA_DX (0x0008)
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM - 1; i++)
    {
        tmp = ( log((float)(pSelect->luma_point[i + 1] - pSelect->luma_point[i])) / log((float)2) );
        pFix->sharp_luma_dx[i] = CLIP(tmp, 0, 15);
    }

    // SHARP_SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
    // pre bf sigma inv
    int sigma_deci_bits = 9;
    int sigma_inte_bits = 1;
    int max_val         = 0;
    int min_val         = 65536;
    int shf_bits        = 0;
    short sigma_bits[3];
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
    {
        int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->pbf_gain + pSelect->pbf_add) / fPercent );
        if(max_val < cur_sigma)
            max_val = cur_sigma;
        if(min_val > cur_sigma)
            min_val = cur_sigma;
    }
    sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
    sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
    sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
    pbf_sigma_shift = sigma_bits[2] - 5;
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
    {
        tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->pbf_gain + pSelect->pbf_add) * fPercent  * (1 << sigma_bits[2]));
        pFix->sharp_pbf_sigma_inv[i] = CLIP(tmp, 0, 1023);
    }

    // SHARP_SHARP_BF_SIGMA_INV_0 (0x0018 -  0x0020)
    // bf sigma inv
    sigma_deci_bits = 9;
    sigma_inte_bits = 1;
    max_val         = 0;
    min_val         = 65536;
    shf_bits        = 0;
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
    {
        int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->bf_gain + pSelect->bf_add) / fPercent );
        if(max_val < cur_sigma)
            max_val = cur_sigma;
        if(min_val > cur_sigma)
            min_val = cur_sigma;
    }
    sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
    sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
    sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
    bf_sigma_shift = sigma_bits[2] - 5;
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
    {
        tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->bf_gain + pSelect->bf_add) * fPercent  * (1 << sigma_bits[2]));
        pFix->sharp_bf_sigma_inv[i] = CLIP(tmp, 0, 1023);
    }

    // SHARP_SHARP_SIGMA_SHIFT (0x00024)
    pFix->sharp_pbf_sigma_shift = CLIP(bf_sigma_shift, 0, 15);
    pFix->sharp_bf_sigma_shift = CLIP(pbf_sigma_shift, 0, 15);

    // SHARP_SHARP_EHF_TH_0 (0x0028 -  0x0030)
    // wgt = hf * ehf_th
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
    {
        tmp = (int)(pSelect->ehf_th[i] * fPercent);
        pFix->sharp_ehf_th[i] = CLIP(tmp, 0, 1023);
    }

    // SHARP_SHARP_CLIP_HF_0 (0x0034 -  0x003c)
    for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
    {
        tmp = (int)(pSelect->lum_clip_h[i] * fPercent);
        pFix->sharp_clip_hf[i] = CLIP(tmp, 0, 1023);
    }

    // SHARP_SHARP_PBF_COEF (0x00040)
    // filter coeff
    // bf coeff
    // rk_sharp_V3_pbfCoeff : [4], [1], [0]
    tmp = (int)ROUND_F(pSelect->kernel_pre_bila_filter[0] * (1 << rk_sharp_V3_pbfCoeff_fix_bits));
    pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);
    tmp = (int)ROUND_F(pSelect->kernel_pre_bila_filter[1] * (1 << rk_sharp_V3_pbfCoeff_fix_bits));
    pFix->sharp_pbf_coef[1] = CLIP(tmp, 0, 127);
    tmp = (int)ROUND_F(pSelect->kernel_pre_bila_filter[2] * (1 << rk_sharp_V3_pbfCoeff_fix_bits));
    pFix->sharp_pbf_coef[2] = CLIP(tmp, 0, 127);
    sum_coeff   = pFix->sharp_pbf_coef[0] + 4 * pFix->sharp_pbf_coef[1] + 4 * pFix->sharp_pbf_coef[2];
    offset      = (1 << rk_sharp_V3_pbfCoeff_fix_bits) - sum_coeff;
    tmp = (int)(pFix->sharp_pbf_coef[0] + offset);
    pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);

    // SHARP_SHARP_BF_COEF (0x00044)
    // bf coeff
    // rk_sharp_V3_bfCoeff : [4], [1], [0]
    tmp = (int)ROUND_F(pSelect->kernel_bila_filter[0] * (1 << rk_sharp_V3_hbfCoeff_fix_bits));
    pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);
    tmp = (int)ROUND_F(pSelect->kernel_bila_filter[1] * (1 << rk_sharp_V3_hbfCoeff_fix_bits));
    pFix->sharp_bf_coef[1] = CLIP(tmp, 0, 127);
    tmp = (int)ROUND_F(pSelect->kernel_bila_filter[2] * (1 << rk_sharp_V3_hbfCoeff_fix_bits));
    pFix->sharp_bf_coef[2] = CLIP(tmp, 0, 127);
    sum_coeff   = pFix->sharp_bf_coef[0] + 4 * pFix->sharp_bf_coef[1] + 4 * pFix->sharp_bf_coef[2];
    offset      = (1 << rk_sharp_V3_hbfCoeff_fix_bits) - sum_coeff;
    tmp = (int)(pFix->sharp_bf_coef[0] + offset);
    pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);

    // SHARP_SHARP_GAUS_COEF (0x00048)
    // rk_sharp_V3_rfCoeff :  [4], [1], [0]
    tmp = (int)ROUND_F(pSelect->kernel_range_filter[0] * (1 << rk_sharp_V3_rfCoeff_fix_bits));
    pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);
    tmp = (int)ROUND_F(pSelect->kernel_range_filter[1] * (1 << rk_sharp_V3_rfCoeff_fix_bits));
    pFix->sharp_gaus_coef[1] = CLIP(tmp, 0, 127);
    tmp = (int)ROUND_F(pSelect->kernel_range_filter[2] * (1 << rk_sharp_V3_rfCoeff_fix_bits));
    pFix->sharp_gaus_coef[2] = CLIP(tmp, 0, 127);
    sum_coeff = pFix->sharp_gaus_coef[0] + 4 * pFix->sharp_gaus_coef[1] + 4 * pFix->sharp_gaus_coef[2];
    offset = (1 << rk_sharp_V3_rfCoeff_fix_bits) - sum_coeff;
    tmp = (int)(pFix->sharp_gaus_coef[0] + offset);
    pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);


#if 0
    //////////////////////////////////params clip////////////////////////////////////////
    pFix->sharp_sharp_ratio = CLIP(pFix->sharp_sharp_ratio, 0, 63);
    pFix->sharp_bf_ratio = CLIP(pFix->sharp_bf_ratio, 0, 128);
    pFix->sharp_gaus_ratio = CLIP(pFix->sharp_gaus_ratio, 0, 128);
    pFix->sharp_pbf_ratio = CLIP(pFix->sharp_pbf_ratio, 0, 128);

    for(int k = 0; k < RK_SHARP_V3_LUMA_POINT_NUM - 1; k ++) {
        pFix->sharp_luma_dx[k] = CLIP(pFix->sharp_luma_dx[k], 0, 15);
    }

    for(int k = 0; k < RK_SHARP_V3_LUMA_POINT_NUM; k ++) {
        pFix->sharp_pbf_sigma_inv[k] = CLIP(pFix->sharp_pbf_sigma_inv[k], 0, 1023);
        pFix->sharp_bf_sigma_inv[k] = CLIP(pFix->sharp_bf_sigma_inv[k], 0, 1023);
        pFix->sharp_clip_hf[k] = CLIP(pFix->sharp_clip_hf[k], 0, 1023);
        pFix->sharp_ehf_th[k] = CLIP(pFix->sharp_ehf_th[k], 0, 1023);
    }

    for(int k = 0; k < 3; k ++) {
        pFix->sharp_pbf_coef[k] = CLIP(pFix->sharp_pbf_coef[k], 0, 127);
        pFix->sharp_gaus_coef[k] = CLIP(pFix->sharp_gaus_coef[k], 0, 127);
        pFix->sharp_bf_coef[k] = CLIP(pFix->sharp_bf_coef[k], 0, 127);
    }
    pFix->sharp_pbf_sigma_shift = CLIP(pFix->sharp_pbf_sigma_shift, 0, 15);
    pFix->sharp_bf_sigma_shift = CLIP(pFix->sharp_bf_sigma_shift, 0, 15);
#endif

#if 0
    sharp_fix_printf_V3(pFix);
#endif

    LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
    return res;
}


Asharp3_result_t sharp_fix_printf_V3(RK_SHARP_Fix_V3_t  * pFix)
{
    int i = 0;
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;

    LOGI_ASHARP("%s:(%d) enter \n", __FUNCTION__, __LINE__);

    if(pFix == NULL) {
        LOGI_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    // SHARP_SHARP_EN (0x0000)
    LOGD_ASHARP("(0x0000) sharp_bypass:0x%x sharp_en:0x%x \n",
                pFix->sharp_bypass,
                pFix->sharp_en);


    // SHARP_SHARP_RATIO  (0x0004)
    LOGD_ASHARP("(0x0004) sharp_sharp_ratio:0x%x sharp_bf_ratio:0x%x sharp_gaus_ratio:0x%x sharp_pbf_ratio:0x%x \n",
                pFix->sharp_sharp_ratio,
                pFix->sharp_bf_ratio,
                pFix->sharp_gaus_ratio,
                pFix->sharp_pbf_ratio);

    // SHARP_SHARP_LUMA_DX (0x0008)
    for(int i = 0; i < 7; i++) {
        LOGD_ASHARP("(0x0008) sharp_luma_dx[%d]:0x%x \n",
                    i, pFix->sharp_luma_dx[i]);
    }

    // SHARP_SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
    for(int i = 0; i < 8; i++) {
        LOGD_ASHARP("(0x000c - 0x0014) sharp_pbf_sigma_inv[%d]:0x%x \n",
                    i, pFix->sharp_pbf_sigma_inv[i]);
    }

    // SHARP_SHARP_BF_SIGMA_INV_0 (0x0018 -  0x0020)
    for(int i = 0; i < 8; i++) {
        LOGD_ASHARP("(0x0018 - 0x0020) sharp_bf_sigma_inv[%d]:0x%x \n",
                    i, pFix->sharp_bf_sigma_inv[i]);
    }

    // SHARP_SHARP_SIGMA_SHIFT (0x00024)
    LOGD_ASHARP("(0x00024) sharp_bf_sigma_shift:0x%x sharp_pbf_sigma_shift:0x%x \n",
                pFix->sharp_bf_sigma_shift,
                pFix->sharp_pbf_sigma_shift);

    // SHARP_SHARP_EHF_TH_0 (0x0028 -  0x0030)
    for(int i = 0; i < 8; i++) {
        LOGD_ASHARP("(0x0028 - 0x0030) sharp_ehf_th[%d]:0x%x \n",
                    i, pFix->sharp_ehf_th[i]);
    }

    // SHARP_SHARP_CLIP_HF_0 (0x0034 -  0x003c)
    for(int i = 0; i < 8; i++) {
        LOGD_ASHARP("(0x0034 - 0x003c) sharp_clip_hf[%d]:0x%x \n",
                    i, pFix->sharp_clip_hf[i]);
    }

    // SHARP_SHARP_PBF_COEF (0x00040)
    for(int i = 0; i < 3; i++) {
        LOGD_ASHARP("(0x00040) sharp_pbf_coef[%d]:0x%x \n",
                    i, pFix->sharp_pbf_coef[i]);
    }

    // SHARP_SHARP_BF_COEF (0x00044)
    for(int i = 0; i < 3; i++) {
        LOGD_ASHARP("(0x00044) sharp_bf_coef[%d]:0x%x \n",
                    i, pFix->sharp_bf_coef[i]);
    }

    // SHARP_SHARP_GAUS_COEF (0x00048)
    for(int i = 0; i < 3; i++) {
        LOGD_ASHARP("(0x00048) sharp_gaus_coef[%d]:0x%x \n",
                    i, pFix->sharp_gaus_coef[i]);
    }

    return res;
}




Asharp3_result_t sharp_get_setting_by_name_json_V3(CalibDbV2_SharpV3_t *pCalibdbV2, char *name, int *tuning_idx)
{
    int i = 0;
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;

    LOGI_ASHARP("%s(%d): enter  \n", __FUNCTION__, __LINE__);

    if(pCalibdbV2 == NULL || name == NULL || tuning_idx == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    for(i = 0; i < pCalibdbV2->TuningPara.Setting_len; i++) {
        if(strncmp(name, pCalibdbV2->TuningPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
            break;
        }
    }

    if(i < pCalibdbV2->TuningPara.Setting_len) {
        *tuning_idx = i;
    } else {
        *tuning_idx = 0;
    }

    LOGI_ASHARP("%s:%d snr_name:%s  snr_idx:%d i:%d \n",
                __FUNCTION__, __LINE__,
                name, *tuning_idx, i);
    return res;
}


Asharp3_result_t sharp_init_params_json_V3(RK_SHARP_Params_V3_t *pSharpParams, CalibDbV2_SharpV3_t *pCalibdbV2, int tuning_idx)
{
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;
    int i = 0;
    int j = 0;
    short isoCurveSectValue;
    short isoCurveSectValue1;
    float ave1, ave2, ave3, ave4;
    int bit_calib = 12;
    int bit_proc;
    int bit_shift;
    CalibDbV2_SharpV3_TuningPara_Setting_ISO_t *pTuningISO;

    LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);

    if(pSharpParams == NULL || pCalibdbV2 == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }


    for(i = 0; i < pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO_len && i < RK_SHARP_V3_MAX_ISO_NUM; i++) {
        pTuningISO = &pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO[i];
        pSharpParams->iso[i] = pTuningISO->iso;

        for(j = 0; j < RK_SHARP_V3_LUMA_POINT_NUM; j++) {
            pSharpParams->luma_point[j] = pTuningISO->luma_para.luma_point[j];
            pSharpParams->luma_sigma[i][j] = pTuningISO->luma_para.luma_sigma[j];
            pSharpParams->lum_clip_h[i][j] = pTuningISO->luma_para.hf_clip[j];
            pSharpParams->ehf_th[i][j] = pTuningISO->luma_para.local_sharp_strength[j];
        }

        pSharpParams->pbf_gain[i] = pTuningISO->pbf_gain;
        pSharpParams->pbf_add[i] = pTuningISO->pbf_add;
        pSharpParams->pbf_ratio[i] = pTuningISO->pbf_ratio;
        pSharpParams->gaus_ratio[i] = pTuningISO->gaus_ratio;
        pSharpParams->sharp_ratio[i] = pTuningISO->sharp_ratio;
        pSharpParams->bf_gain[i] = pTuningISO->bf_gain;
        pSharpParams->bf_add[i] = pTuningISO->bf_add;
        pSharpParams->bf_ratio[i] = pTuningISO->bf_ratio;

        for(j = 0; j < 3; j++) {
            pSharpParams->kernel_bila_filter[i][j] = pTuningISO->kernel_para.GaussianFilter_coeff[j];
            pSharpParams->kernel_pre_bila_filter[i][j] = pTuningISO->kernel_para.prefilter_coeff[j];
            pSharpParams->kernel_range_filter[i][j] = pTuningISO->kernel_para.hfBilateralFilter_coeff[j];
            LOGD_ASHARP("kernel: index[%d][%d] = %f\n", i, j, pSharpParams->kernel_bila_filter[i][j]);
        }
    }

    LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
    return res;
}


Asharp3_result_t sharp_config_setting_param_json_V3(RK_SHARP_Params_V3_t *pParams, CalibDbV2_SharpV3_t *pCalibdbV2, char* param_mode, char * snr_name)
{
    Asharp3_result_t res = ASHARP3_RET_SUCCESS;
    int tuning_idx = 0;

    LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);

    if(pParams == NULL || pCalibdbV2 == NULL || param_mode == NULL || snr_name == NULL) {
        LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ASHARP3_RET_NULL_POINTER;
    }

    LOGD_ASHARP("%s(%d): mode:%s  setting:%s \n", __FUNCTION__, __LINE__, param_mode, snr_name);

    res = sharp_get_setting_by_name_json_V3(pCalibdbV2, snr_name, &tuning_idx);
    if(res != ASHARP3_RET_SUCCESS) {
        LOGW_ASHARP("%s(%d): error!!!  can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
    }

    res = sharp_init_params_json_V3(pParams, pCalibdbV2, tuning_idx);
    pParams->enable = pCalibdbV2->TuningPara.enable;

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

    return res;

}

RKAIQ_END_DECLARE