#include "rk_aiq_uapi_anr_int.h"
#include "anr/rk_aiq_types_anr_algo_prvt.h"
#include "anr/rk_aiq_anr_algo.h"
#include "bayernr_xml2json_v1.h"
#include "mfnr_xml2json_v1.h"
#include "uvnr_xml2json_v1.h"
#include "ynr_xml2json_v1.h"



#define NR_STRENGTH_MAX_PERCENT (50.0)
#define NR_LUMA_TF_STRENGTH_MAX_PERCENT NR_STRENGTH_MAX_PERCENT
#define NR_LUMA_SF_STRENGTH_MAX_PERCENT (100.0)
#define NR_CHROMA_TF_STRENGTH_MAX_PERCENT NR_STRENGTH_MAX_PERCENT
#define NR_CHROMA_SF_STRENGTH_MAX_PERCENT NR_STRENGTH_MAX_PERCENT
#define NR_RAWNR_SF_STRENGTH_MAX_PERCENT (80.0)

XCamReturn
rk_aiq_uapi_anr_SetAttrib(RkAiqAlgoContext *ctx,
                          rk_aiq_nr_attrib_t *attr,
                          bool need_sync)
{

    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    pAnrCtx->eMode = attr->eMode;
    pAnrCtx->stAuto = attr->stAuto;
    pAnrCtx->stManual = attr->stManual;

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi_anr_GetAttrib(const RkAiqAlgoContext *ctx,
                          rk_aiq_nr_attrib_t *attr)
{

    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    attr->eMode = pAnrCtx->eMode;
    memcpy(&attr->stAuto, &pAnrCtx->stAuto, sizeof(ANR_Auto_Attr_t));
    memcpy(&attr->stManual, &pAnrCtx->stManual, sizeof(ANR_Manual_Attr_t));

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi_anr_SetIQPara(RkAiqAlgoContext *ctx,
                          rk_aiq_nr_IQPara_t *pPara,
                          bool need_sync)
{

    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    if(pPara->module_bits & (1 << ANR_MODULE_BAYERNR)) {
        //pAnrCtx->stBayernrCalib = pPara->stBayernrPara;
        CalibDb_BayerNr_2_t stBayernr;
        stBayernr.mode_num = sizeof(pPara->stBayernrPara.mode_cell) / sizeof(CalibDb_BayerNr_ModeCell_t);
        stBayernr.mode_cell = (CalibDb_BayerNr_ModeCell_t *)malloc(stBayernr.mode_num * sizeof(CalibDb_BayerNr_ModeCell_t));
        stBayernr.enable = pPara->stBayernrPara.enable;
        strcpy(stBayernr.version, pPara->stBayernrPara.version);
        for(int i = 0; i < stBayernr.mode_num; i++) {
            stBayernr.mode_cell[i] = pPara->stBayernrPara.mode_cell[i];
        }

#if(ANR_USE_JSON_PARA)
        bayernrV1_calibdb_to_calibdbV2(&stBayernr, &pAnrCtx->bayernr_v1, 0);
#else
        pAnrCtx->stBayernrCalib.enable = stBayernr.enable;
        strcpy(pAnrCtx->stBayernrCalib.version, stBayernr.version);
        for(int i = 0; i < stBayernr.mode_num && i < pAnrCtx->stBayernrCalib.mode_num; i++) {
            pAnrCtx->stBayernrCalib.mode_cell[i] = stBayernr.mode_cell[i];
        }
        pAnrCtx->isIQParaUpdate = true;
#endif

        free(stBayernr.mode_cell);
    }

    if(pPara->module_bits & (1 << ANR_MODULE_MFNR)) {
        //pAnrCtx->stMfnrCalib = pPara->stMfnrPara;
        CalibDb_MFNR_2_t stMfnr;
        stMfnr.mode_num = sizeof(pPara->stMfnrPara.mode_cell) / sizeof(CalibDb_MFNR_ModeCell_t);
        stMfnr.mode_cell = (CalibDb_MFNR_ModeCell_t *)malloc(stMfnr.mode_num * sizeof(CalibDb_MFNR_ModeCell_t));

        stMfnr.enable = pPara->stMfnrPara.enable;
        strcpy(stMfnr.version, pPara->stMfnrPara.version);
        stMfnr.local_gain_en = pPara->stMfnrPara.local_gain_en;
        stMfnr.motion_detect_en = pPara->stMfnrPara.motion_detect_en;
        stMfnr.mode_3to1 = pPara->stMfnrPara.mode_3to1;
        stMfnr.max_level = pPara->stMfnrPara.max_level;
        stMfnr.max_level_uv = pPara->stMfnrPara.max_level_uv;
        stMfnr.back_ref_num = pPara->stMfnrPara.back_ref_num;
        for(int i = 0; i < 4; i++) {
            stMfnr.uv_ratio[i] = pPara->stMfnrPara.uv_ratio[i];
        }
        for(int i = 0; i < stMfnr.mode_num; i++) {
            stMfnr.mode_cell[i] = pPara->stMfnrPara.mode_cell[i];
        }

#if(ANR_USE_JSON_PARA)
        mfnrV1_calibdb_to_calibdbV2(&stMfnr, &pAnrCtx->mfnr_v1, 0);
#else
        pAnrCtx->stMfnrCalib.enable = stMfnr.enable;
        strcpy(pAnrCtx->stMfnrCalib.version, stMfnr.version);
        pAnrCtx->stMfnrCalib.local_gain_en = stMfnr.local_gain_en;
        pAnrCtx->stMfnrCalib.motion_detect_en = stMfnr.motion_detect_en;
        pAnrCtx->stMfnrCalib.mode_3to1 = stMfnr.mode_3to1;
        pAnrCtx->stMfnrCalib.max_level = stMfnr.max_level;
        pAnrCtx->stMfnrCalib.max_level_uv = stMfnr.max_level_uv;
        pAnrCtx->stMfnrCalib.back_ref_num = stMfnr.back_ref_num;
        for(int i = 0; i < 4; i++) {
            pAnrCtx->stMfnrCalib.uv_ratio[i] = stMfnr.uv_ratio[i];
        }
        for(int i = 0; i < stMfnr.mode_num && i < pAnrCtx->stMfnrCalib.mode_num; i++) {
            pAnrCtx->stMfnrCalib.mode_cell[i] = stMfnr.mode_cell[i];
        }
#endif
        pAnrCtx->isIQParaUpdate = true;

        free(stMfnr.mode_cell);
    }

    if(pPara->module_bits & (1 << ANR_MODULE_UVNR)) {
        //pAnrCtx->stUvnrCalib = pPara->stUvnrPara;
        CalibDb_UVNR_2_t stUvnr;
        stUvnr.mode_num = sizeof(pPara->stUvnrPara.mode_cell) / sizeof(CalibDb_UVNR_ModeCell_t);
        stUvnr.mode_cell = (CalibDb_UVNR_ModeCell_t *)malloc(stUvnr.mode_num * sizeof(CalibDb_UVNR_ModeCell_t));
        stUvnr.enable = pPara->stUvnrPara.enable;
        strcpy(stUvnr.version, pPara->stUvnrPara.version);
        for(int i = 0; i < stUvnr.mode_num; i++) {
            stUvnr.mode_cell[i] = pPara->stUvnrPara.mode_cell[i];
        }

#if(ANR_USE_JSON_PARA)
        uvnrV1_calibdb_to_calibdbV2(&stUvnr, &pAnrCtx->uvnr_v1, 0);
#else
        pAnrCtx->stUvnrCalib.enable = stUvnr.enable;
        strcpy(pAnrCtx->stUvnrCalib.version, stUvnr.version);
        for(int i = 0; i < stUvnr.mode_num && i < pAnrCtx->stUvnrCalib.mode_num; i++) {
            pAnrCtx->stUvnrCalib.mode_cell[i] = stUvnr.mode_cell[i];
        }
#endif
        pAnrCtx->isIQParaUpdate = true;

        free(stUvnr.mode_cell);
    }

    if(pPara->module_bits & (1 << ANR_MODULE_YNR)) {
        //pAnrCtx->stYnrCalib = pPara->stYnrPara;
        CalibDb_YNR_2_t stYnr;
        stYnr.mode_num = sizeof(pPara->stYnrPara.mode_cell) / sizeof(CalibDb_YNR_ModeCell_t);
        stYnr.mode_cell = (CalibDb_YNR_ModeCell_t *)malloc(stYnr.mode_num * sizeof(CalibDb_YNR_ModeCell_t));
        stYnr.enable = pPara->stYnrPara.enable;
        strcpy(stYnr.version, pPara->stYnrPara.version);
        for(int i = 0; i < stYnr.mode_num; i++) {
            stYnr.mode_cell[i] = pPara->stYnrPara.mode_cell[i];
        }


#if(ANR_USE_JSON_PARA)
        ynrV1_calibdb_to_calibdbV2(&stYnr, &pAnrCtx->ynr_v1, 0);
#else
        pAnrCtx->stYnrCalib.enable = stYnr.enable;
        strcpy(pAnrCtx->stYnrCalib.version, stYnr.version);
        for(int i = 0; i < stYnr.mode_num && i < pAnrCtx->stYnrCalib.mode_num; i++) {
            pAnrCtx->stYnrCalib.mode_cell[i] = stYnr.mode_cell[i];
        }
#endif
        pAnrCtx->isIQParaUpdate = true;

        free(stYnr.mode_cell);
    }

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_GetIQPara(RkAiqAlgoContext *ctx,
                          rk_aiq_nr_IQPara_t *pPara)
{

    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    //pPara->stBayernrPara = pAnrCtx->stBayernrCalib;
    CalibDb_BayerNr_2_t stBayernr;
    stBayernr.mode_num = sizeof(pPara->stBayernrPara.mode_cell) / sizeof(CalibDb_BayerNr_ModeCell_t);
    stBayernr.mode_cell = (CalibDb_BayerNr_ModeCell_t *)malloc(stBayernr.mode_num * sizeof(CalibDb_BayerNr_ModeCell_t));

#if(ANR_USE_JSON_PARA)
    bayernrV1_calibdbV2_to_calibdb(&pAnrCtx->bayernr_v1, &stBayernr, 0);
#else
    stBayernr.enable = pAnrCtx->stBayernrCalib.enable;
    strcpy(stBayernr.version, pAnrCtx->stBayernrCalib.version);
    for(int i = 0; i < pAnrCtx->stBayernrCalib.mode_num && i < stBayernr.mode_num; i++) {
        stBayernr.mode_cell[i] = pAnrCtx->stBayernrCalib.mode_cell[i];
    }
#endif

    memset(&pPara->stBayernrPara, 0x00, sizeof(CalibDb_BayerNr_t));
    pPara->stBayernrPara.enable = stBayernr.enable;
    strcpy(pPara->stBayernrPara.version, stBayernr.version);
    for(int i = 0; i < stBayernr.mode_num; i++) {
        pPara->stBayernrPara.mode_cell[i] = stBayernr.mode_cell[i];
    }
    free(stBayernr.mode_cell);


    //pPara->stMfnrPara = pAnrCtx->stMfnrCalib;
    CalibDb_MFNR_2_t stMfnr;
    stMfnr.mode_num = sizeof(pPara->stMfnrPara.mode_cell) / sizeof(CalibDb_MFNR_ModeCell_t);
    stMfnr.mode_cell = (CalibDb_MFNR_ModeCell_t *)malloc(stMfnr.mode_num * sizeof(CalibDb_MFNR_ModeCell_t));
#if(ANR_USE_JSON_PARA)
    mfnrV1_calibdbV2_to_calibdb(&pAnrCtx->mfnr_v1, &stMfnr, 0);
#else
    stMfnr.enable = pAnrCtx->stMfnrCalib.enable;
    strcpy(stMfnr.version, pAnrCtx->stMfnrCalib.version);
    stMfnr.local_gain_en = pAnrCtx->stMfnrCalib.local_gain_en;
    stMfnr.motion_detect_en = pAnrCtx->stMfnrCalib.motion_detect_en;
    stMfnr.mode_3to1 = pAnrCtx->stMfnrCalib.mode_3to1;
    stMfnr.max_level = pAnrCtx->stMfnrCalib.max_level;
    stMfnr.max_level_uv = pAnrCtx->stMfnrCalib.max_level_uv;
    stMfnr.back_ref_num = pAnrCtx->stMfnrCalib.back_ref_num;
    for(int i = 0; i < 4; i++) {
        stMfnr.uv_ratio[i] = pAnrCtx->stMfnrCalib.uv_ratio[i];
    }
    for(int i = 0; i < stMfnr.mode_num && i < pAnrCtx->stMfnrCalib.mode_num; i++) {
        stMfnr.mode_cell[i] = pAnrCtx->stMfnrCalib.mode_cell[i];
    }
#endif

    memset(&pPara->stMfnrPara, 0x00, sizeof(CalibDb_MFNR_t));
    pPara->stMfnrPara.enable = stMfnr.enable;
    strcpy(pPara->stMfnrPara.version, stMfnr.version);
    pPara->stMfnrPara.local_gain_en = stMfnr.local_gain_en;
    pPara->stMfnrPara.motion_detect_en = stMfnr.motion_detect_en;
    pPara->stMfnrPara.mode_3to1 = stMfnr.mode_3to1;
    pPara->stMfnrPara.max_level = stMfnr.max_level;
    pPara->stMfnrPara.max_level_uv = stMfnr.max_level_uv;
    pPara->stMfnrPara.back_ref_num = stMfnr.back_ref_num;
    for(int i = 0; i < 4; i++) {
        pPara->stMfnrPara.uv_ratio[i] = stMfnr.uv_ratio[i];
    }
    for(int i = 0; i < stMfnr.mode_num; i++) {
        pPara->stMfnrPara.mode_cell[i] = stMfnr.mode_cell[i];
    }
    free(stMfnr.mode_cell);


    //pPara->stUvnrPara = pAnrCtx->stUvnrCalib;
    CalibDb_UVNR_2_t stUvnr;
    stUvnr.mode_num = sizeof(pPara->stUvnrPara.mode_cell) / sizeof(CalibDb_UVNR_ModeCell_t);
    stUvnr.mode_cell = (CalibDb_UVNR_ModeCell_t *)malloc(stUvnr.mode_num * sizeof(CalibDb_UVNR_ModeCell_t));
#if(ANR_USE_JSON_PARA)
    uvnrV1_calibdbV2_to_calibdb(&pAnrCtx->uvnr_v1, &stUvnr, 0);
#else
    stUvnr.enable = pAnrCtx->stUvnrCalib.enable;
    strcpy(stUvnr.version, pAnrCtx->stUvnrCalib.version);
    for(int i = 0; i < stUvnr.mode_num && i < pAnrCtx->stUvnrCalib.mode_num; i++) {
        stUvnr.mode_cell[i] = pAnrCtx->stUvnrCalib.mode_cell[i];
    }
#endif
    memset(&pPara->stUvnrPara, 0x00, sizeof(CalibDb_UVNR_t));
    pPara->stUvnrPara.enable = stUvnr.enable;
    memcpy(pPara->stUvnrPara.version, stUvnr.version, sizeof(pPara->stUvnrPara.version));
    for(int i = 0; i < stUvnr.mode_num; i++) {
        pPara->stUvnrPara.mode_cell[i] = stUvnr.mode_cell[i];
    }
    free(stUvnr.mode_cell);


    //pPara->stYnrPara = pAnrCtx->stYnrCalib;
    CalibDb_YNR_2_t stYnr;
    stYnr.mode_num = sizeof(pPara->stYnrPara.mode_cell) / sizeof(CalibDb_YNR_ModeCell_t);
    stYnr.mode_cell = (CalibDb_YNR_ModeCell_t *)malloc(stYnr.mode_num * sizeof(CalibDb_YNR_ModeCell_t));
#if(ANR_USE_JSON_PARA)
    ynrV1_calibdbV2_to_calibdb(&pAnrCtx->ynr_v1, &stYnr, 0);
#else
    stYnr.enable = pAnrCtx->stYnrCalib.enable;
    strcpy(stYnr.version, pAnrCtx->stYnrCalib.version);
    for(int i = 0; i < stYnr.mode_num && i < pAnrCtx->stYnrCalib.mode_num; i++) {
        stYnr.mode_cell[i] = pAnrCtx->stYnrCalib.mode_cell[i];
    }
#endif
    memset(&pPara->stYnrPara, 0x00, sizeof(CalibDb_YNR_t));
    pPara->stYnrPara.enable = stYnr.enable;
    memcpy(pPara->stYnrPara.version, stYnr.version, sizeof(pPara->stYnrPara.version));
    for(int i = 0; i < stYnr.mode_num; i++) {
        pPara->stYnrPara.mode_cell[i] = stYnr.mode_cell[i];
    }
    free(stYnr.mode_cell);

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_SetLumaSFStrength(const RkAiqAlgoContext *ctx,
                                  float fPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0f;
    float fMax = NR_LUMA_SF_STRENGTH_MAX_PERCENT;


    if(fPercent <= 0.5) {
        fStrength =  fPercent / 0.5;
    } else {
        fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
    }

    if(fStrength > 1) {
        pAnrCtx->fRawnr_SF_Strength = fStrength;
        pAnrCtx->fLuma_SF_Strength = 1;
    } else {
        pAnrCtx->fRawnr_SF_Strength = fStrength;
        pAnrCtx->fLuma_SF_Strength = fStrength;
    }

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_SetLumaTFStrength(const RkAiqAlgoContext *ctx,
                                  float fPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0;
    float fMax = NR_LUMA_TF_STRENGTH_MAX_PERCENT;

    if(fPercent <= 0.5) {
        fStrength =  fPercent / 0.5;
    } else {
        fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
    }

    pAnrCtx->fLuma_TF_Strength = fStrength;

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_GetLumaSFStrength(const RkAiqAlgoContext *ctx,
                                  float *pPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0f;
    float fMax = NR_LUMA_SF_STRENGTH_MAX_PERCENT;


    fStrength = pAnrCtx->fRawnr_SF_Strength;

    if(fStrength <= 1) {
        *pPercent = fStrength * 0.5;
    } else {
        *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
    }

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_GetLumaTFStrength(const RkAiqAlgoContext *ctx,
                                  float *pPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0;
    float fMax = NR_LUMA_TF_STRENGTH_MAX_PERCENT;

    fStrength = pAnrCtx->fLuma_TF_Strength;

    if(fStrength <= 1) {
        *pPercent = fStrength * 0.5;
    } else {
        *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
    }

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_SetChromaSFStrength(const RkAiqAlgoContext *ctx,
                                    float fPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0f;
    float fMax = NR_CHROMA_SF_STRENGTH_MAX_PERCENT;

    if(fPercent <= 0.5) {
        fStrength =  fPercent / 0.5;
    } else {
        fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
    }

    pAnrCtx->fChroma_SF_Strength = fStrength;

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_SetChromaTFStrength(const RkAiqAlgoContext *ctx,
                                    float fPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0;
    float fMax = NR_CHROMA_TF_STRENGTH_MAX_PERCENT;

    if(fPercent <= 0.5) {
        fStrength =  fPercent / 0.5;
    } else {
        fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
    }

    pAnrCtx->fChroma_TF_Strength = fStrength;

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_GetChromaSFStrength(const RkAiqAlgoContext *ctx,
                                    float *pPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0f;
    float fMax = NR_CHROMA_SF_STRENGTH_MAX_PERCENT;

    fStrength = pAnrCtx->fChroma_SF_Strength;


    if(fStrength <= 1) {
        *pPercent = fStrength * 0.5;
    } else {
        *pPercent =  (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
    }


    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_GetChromaTFStrength(const RkAiqAlgoContext *ctx,
                                    float *pPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0;
    float fMax = NR_CHROMA_TF_STRENGTH_MAX_PERCENT;

    fStrength = pAnrCtx->fChroma_TF_Strength;

    if(fStrength <= 1) {
        *pPercent = fStrength * 0.5;
    } else {
        *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
    }

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_SetRawnrSFStrength(const RkAiqAlgoContext *ctx,
                                   float fPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0;
    float fMax = NR_RAWNR_SF_STRENGTH_MAX_PERCENT;

    if(fPercent <= 0.5) {
        fStrength =  fPercent / 0.5;
    } else {
        fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
    }

    pAnrCtx->fRawnr_SF_Strength = fStrength;

    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_GetRawnrSFStrength(const RkAiqAlgoContext *ctx,
                                   float *pPercent)
{
    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    float fStrength = 1.0f;
    float fMax = NR_RAWNR_SF_STRENGTH_MAX_PERCENT;

    fStrength = pAnrCtx->fRawnr_SF_Strength;


    if(fStrength <= 1) {
        *pPercent = fStrength * 0.5;
    } else {
        *pPercent = (fStrength - 1) / ((fMax - 1) * 2)  + 0.5;
    }


    return XCAM_RETURN_NO_ERROR;
}


XCamReturn
rk_aiq_uapi_anr_SetJsonPara(RkAiqAlgoContext *ctx,
                            rk_aiq_nr_JsonPara_t *pPara,
                            bool need_sync)
{

    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    if(pPara->module_bits & (1 << ANR_MODULE_BAYERNR)) {
        //pAnrCtx->stBayernrCalib = pPara->stBayernrPara;
        bayernr_calibdbV2_assign(&pAnrCtx->bayernr_v1, &pPara->bayernr_v1);
        pAnrCtx->isIQParaUpdate = true;
    }

    if(pPara->module_bits & (1 << ANR_MODULE_MFNR)) {
        //pAnrCtx->stMfnrCalib = pPara->stMfnrPara;
        mfnr_calibdbV2_assign(&pAnrCtx->mfnr_v1, &pPara->mfnr_v1);
        pAnrCtx->isIQParaUpdate = true;
    }

    if(pPara->module_bits & (1 << ANR_MODULE_UVNR)) {
        //pAnrCtx->stUvnrCalib = pPara->stUvnrPara;
        uvnr_calibdbV2_assign(&pAnrCtx->uvnr_v1, &pPara->uvnr_v1);
        pAnrCtx->isIQParaUpdate = true;
    }

    if(pPara->module_bits & (1 << ANR_MODULE_YNR)) {
        //pAnrCtx->stYnrCalib = pPara->stYnrPara;
        ynr_calibdbV2_assign(&pAnrCtx->ynr_v1, &pPara->ynr_v1);
        pAnrCtx->isIQParaUpdate = true;
    }

    return XCAM_RETURN_NO_ERROR;
}



XCamReturn
rk_aiq_uapi_anr_GetJsonPara(RkAiqAlgoContext *ctx,
                            rk_aiq_nr_JsonPara_t *pPara)
{

    ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;

    //pPara->stBayernrPara = pAnrCtx->stBayernrCalib;
    bayernr_calibdbV2_assign(&pPara->bayernr_v1, &pAnrCtx->bayernr_v1);
    mfnr_calibdbV2_assign(&pPara->mfnr_v1, &pAnrCtx->mfnr_v1);
    uvnr_calibdbV2_assign(&pPara->uvnr_v1, &pAnrCtx->uvnr_v1);
    ynr_calibdbV2_assign(&pPara->ynr_v1, &pAnrCtx->ynr_v1);

    return XCAM_RETURN_NO_ERROR;
}