#include "rk_aiq_anr_algo.h"
#include "rk_aiq_algo_anr_itf.h"

RKAIQ_BEGIN_DECLARE

ANRresult_t ANRStart(ANRContext_t *pANRCtx) 
{
    LOGI_ANR( "%s:enter!\n", __FUNCTION__);

    // initial checks
    if (pANRCtx == NULL) {
        return (ANR_RET_NULL_POINTER);
    }

    if ((ANR_STATE_RUNNING == pANRCtx->eState)
            || (ANR_STATE_LOCKED == pANRCtx->eState)) {
        return (ANR_RET_FAILURE);
    }

    pANRCtx->eState = ANR_STATE_RUNNING;

    LOGI_ANR( "%s:exit!\n", __FUNCTION__);
    return (ANR_RET_SUCCESS);
}


ANRresult_t ANRStop(ANRContext_t *pANRCtx) 
{
    LOGI_ANR( "%s:enter!\n", __FUNCTION__);

    // initial checks
    if (pANRCtx == NULL) {
        return (ANR_RET_NULL_POINTER);
    }

    if (ANR_STATE_LOCKED == pANRCtx->eState) {
        return (ANR_RET_FAILURE);
    }

    pANRCtx->eState = ANR_STATE_STOPPED;

    LOGI_ANR( "%s:exit!\n", __FUNCTION__);
    return (ANR_RET_SUCCESS);
}


//anr inint
ANRresult_t ANRInit(ANRContext_t **ppANRCtx, CamCalibDbContext_t *pCalibDb)
{
    ANRContext_t * pANRCtx;

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

    pANRCtx = (ANRContext_t *)malloc(sizeof(ANRContext_t));
    if(pANRCtx == NULL) {
        LOGE_ANR("%s(%d): malloc fail\n", __FUNCTION__, __LINE__);
        return ANR_RET_NULL_POINTER;
    }

    memset(pANRCtx, 0x00, sizeof(ANRContext_t));

    //gain state init
    pANRCtx->stGainState.gain_stat_full_last = -1;
    pANRCtx->stGainState.gainState = -1;
    pANRCtx->stGainState.gainState_last = -1;
    pANRCtx->stGainState.gain_th0[0]    = 2.0;
    pANRCtx->stGainState.gain_th1[0]    = 4.0;
    pANRCtx->stGainState.gain_th0[1]    = 32.0;
    pANRCtx->stGainState.gain_th1[1]    = 64.0;
	
	pANRCtx->fLuma_SF_Strength = 1.0;
	pANRCtx->fLuma_TF_Strength = 1.0;
	pANRCtx->fChroma_SF_Strength = 1.0;
	pANRCtx->fChroma_TF_Strength = 1.0;
	pANRCtx->fRawnr_SF_Strength = 1.0;

    pANRCtx->eState = ANR_STATE_INITIALIZED;
    *ppANRCtx = pANRCtx;

    pANRCtx->refYuvBit = 8;
    pANRCtx->eMode = ANR_OP_MODE_AUTO;
	pANRCtx->isIQParaUpdate = false;
	pANRCtx->isGrayMode = false;

#if ANR_USE_XML_FILE
    //read v1 params from xml
    pANRCtx->stBayernrCalib =
        *(CalibDb_BayerNr_2_t*)(CALIBDB_GET_MODULE_PTR((void*)pCalibDb, bayerNr));
    pANRCtx->stUvnrCalib =
        *(CalibDb_UVNR_2_t*)(CALIBDB_GET_MODULE_PTR((void*)pCalibDb, uvnr));
    pANRCtx->stYnrCalib =
        *(CalibDb_YNR_2_t*)(CALIBDB_GET_MODULE_PTR((void*)pCalibDb, ynr));
    pANRCtx->stMfnrCalib =
        *(CalibDb_MFNR_2_t*)(CALIBDB_GET_MODULE_PTR((void*)pCalibDb, mfnr));
#endif

#if RK_SIMULATOR_HW
    //just for v2 params from html
    FILE *fp2 = fopen("rkaiq_anr_html_params.bin", "rb");
    if(fp2 != NULL) {
        memset(&pANRCtx->stAuto.stBayernrParams, 0, sizeof(RKAnr_Bayernr_Params_t));
        fread(&pANRCtx->stAuto.stBayernrParams, 1, sizeof(RKAnr_Bayernr_Params_t), fp2);
        memset(&pANRCtx->stAuto.stMfnrParams, 0, sizeof(RKAnr_Mfnr_Params_t));
        fread(&pANRCtx->stAuto.stMfnrParams, 1, sizeof(RKAnr_Mfnr_Params_t), fp2);
        memset(&pANRCtx->stAuto.stUvnrParams, 0, sizeof(RKAnr_Uvnr_Params_t));
        fread(&pANRCtx->stAuto.stUvnrParams, 1, sizeof(RKAnr_Uvnr_Params_t), fp2);
        memset(&pANRCtx->stAuto.stYnrParams, 0, sizeof(RKAnr_Ynr_Params_t));
        fread(&pANRCtx->stAuto.stYnrParams, 1, sizeof(RKAnr_Ynr_Params_t), fp2);
        LOGD_ANR("oyyf: %s:(%d) read anr param html file sucess! \n", __FUNCTION__, __LINE__);
    } else {
        LOGE_ANR("oyyf: %s:(%d) read anr param html file failed! \n", __FUNCTION__, __LINE__);
        return ANR_RET_FAILURE;
    }
#endif

#if ANR_USE_XML_FILE
	pANRCtx->stExpInfo.snr_mode = 0;
	pANRCtx->eParamMode = ANR_PARAM_MODE_NORMAL;
	ANRConfigSettingParam(pANRCtx, pANRCtx->eParamMode, pANRCtx->stExpInfo.snr_mode);
#endif

    LOGD_ANR("%s(%d): bayernr %f %f %f %d %d %f", __FUNCTION__, __LINE__,
             pANRCtx->stAuto.stBayernrParams.filtpar[0],
             pANRCtx->stAuto.stBayernrParams.filtpar[4],
             pANRCtx->stAuto.stBayernrParams.filtpar[8],
             pANRCtx->stAuto.stBayernrParams.peaknoisesigma,
             pANRCtx->stAuto.stBayernrParams.sw_bayernr_edge_filter_en,
             pANRCtx->stAuto.stBayernrParams.sw_bayernr_filter_strength[0]);


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




//anr inint
ANRresult_t ANRInit_json(ANRContext_t **ppANRCtx, CamCalibDbV2Context_t *pCalibDbV2)
{
    ANRContext_t * pANRCtx;

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

    pANRCtx = (ANRContext_t *)malloc(sizeof(ANRContext_t));
    if(pANRCtx == NULL) {
        LOGE_ANR("%s(%d): malloc fail\n", __FUNCTION__, __LINE__);
        return ANR_RET_NULL_POINTER;
    }

    memset(pANRCtx, 0x00, sizeof(ANRContext_t));

    //gain state init
    pANRCtx->stGainState.gainState = -1;
    pANRCtx->stGainState.gain_th0[0]    = 2.0;
    pANRCtx->stGainState.gain_th1[0]    = 8.0;
    pANRCtx->stGainState.gain_th0[1]    = 32.0;
    pANRCtx->stGainState.gain_th1[1]    = 128.0;
	
	pANRCtx->fLuma_SF_Strength = 1.0;
	pANRCtx->fLuma_TF_Strength = 1.0;
	pANRCtx->fChroma_SF_Strength = 1.0;
	pANRCtx->fChroma_TF_Strength = 1.0;
	pANRCtx->fRawnr_SF_Strength = 1.0;

    pANRCtx->eState = ANR_STATE_INITIALIZED;
    *ppANRCtx = pANRCtx;

    pANRCtx->refYuvBit = 8;
    pANRCtx->eMode = ANR_OP_MODE_AUTO;
	pANRCtx->isIQParaUpdate = false;
	pANRCtx->isGrayMode = false;


#if ANR_USE_JSON_PARA
    //read v1 params from xml
    CalibDbV2_BayerNrV1_t* calibv2_bayernr_v1 =
            (CalibDbV2_BayerNrV1_t*)(CALIBDBV2_GET_MODULE_PTR(pCalibDbV2, bayernr_v1));
	bayernr_calibdbV2_assign(&pANRCtx->bayernr_v1, calibv2_bayernr_v1);

    CalibDbV2_MFNR_t* calibv2_mfnr_v1 =
            (CalibDbV2_MFNR_t*)(CALIBDBV2_GET_MODULE_PTR(pCalibDbV2, mfnr_v1));
	mfnr_calibdbV2_assign(&pANRCtx->mfnr_v1, calibv2_mfnr_v1);

    CalibDbV2_YnrV1_t* calibv2_ynr_v1 =
            (CalibDbV2_YnrV1_t*)(CALIBDBV2_GET_MODULE_PTR(pCalibDbV2, ynr_v1));
	ynr_calibdbV2_assign(&pANRCtx->ynr_v1, calibv2_ynr_v1);

    CalibDbV2_UVNR_t* calibv2_uvnr_v1 =
            (CalibDbV2_UVNR_t*)(CALIBDBV2_GET_MODULE_PTR(pCalibDbV2, uvnr_v1));
    uvnr_calibdbV2_assign(&pANRCtx->uvnr_v1, calibv2_uvnr_v1);
#endif

#if RK_SIMULATOR_HW
    //just for v2 params from html
    FILE *fp2 = fopen("rkaiq_anr_html_params.bin", "rb");
    if(fp2 != NULL) {
        memset(&pANRCtx->stAuto.stBayernrParams, 0, sizeof(RKAnr_Bayernr_Params_t));
        fread(&pANRCtx->stAuto.stBayernrParams, 1, sizeof(RKAnr_Bayernr_Params_t), fp2);
        memset(&pANRCtx->stAuto.stMfnrParams, 0, sizeof(RKAnr_Mfnr_Params_t));
        fread(&pANRCtx->stAuto.stMfnrParams, 1, sizeof(RKAnr_Mfnr_Params_t), fp2);
        memset(&pANRCtx->stAuto.stUvnrParams, 0, sizeof(RKAnr_Uvnr_Params_t));
        fread(&pANRCtx->stAuto.stUvnrParams, 1, sizeof(RKAnr_Uvnr_Params_t), fp2);
        memset(&pANRCtx->stAuto.stYnrParams, 0, sizeof(RKAnr_Ynr_Params_t));
        fread(&pANRCtx->stAuto.stYnrParams, 1, sizeof(RKAnr_Ynr_Params_t), fp2);
        LOGD_ANR("oyyf: %s:(%d) read anr param html file sucess! \n", __FUNCTION__, __LINE__);
    } else {
        LOGE_ANR("oyyf: %s:(%d) read anr param html file failed! \n", __FUNCTION__, __LINE__);
        return ANR_RET_FAILURE;
    }
#endif

#if ANR_USE_JSON_PARA
	pANRCtx->stExpInfo.snr_mode = 0;
	pANRCtx->eParamMode = ANR_PARAM_MODE_NORMAL;
	ANRConfigParamJson(pANRCtx, pANRCtx->eParamMode, pANRCtx->stExpInfo.snr_mode);
#endif

    LOGD_ANR("%s(%d): bayernr %f %f %f %d %d %f", __FUNCTION__, __LINE__,
             pANRCtx->stAuto.stBayernrParams.filtpar[0],
             pANRCtx->stAuto.stBayernrParams.filtpar[4],
             pANRCtx->stAuto.stBayernrParams.filtpar[8],
             pANRCtx->stAuto.stBayernrParams.peaknoisesigma,
             pANRCtx->stAuto.stBayernrParams.sw_bayernr_edge_filter_en,
             pANRCtx->stAuto.stBayernrParams.sw_bayernr_filter_strength[0]);


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



//anr release
ANRresult_t ANRRelease(ANRContext_t *pANRCtx)
{
	ANRresult_t result = ANR_RET_SUCCESS;
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);
    if(pANRCtx == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_NULL_POINTER;
    }

	result = ANRStop(pANRCtx);
    if (result != ANR_RET_SUCCESS) {
        LOGE_ANR( "%s: ANRStop() failed!\n", __FUNCTION__);
        return (result);
    }

    // check state
    if ((ANR_STATE_RUNNING == pANRCtx->eState)
            || (ANR_STATE_LOCKED == pANRCtx->eState)) {
        return (ANR_RET_BUSY);
    }

	#if ANR_USE_JSON_PARA
	bayernr_calibdbV2_free(&pANRCtx->bayernr_v1);
	mfnr_calibdbV2_free(&pANRCtx->mfnr_v1);
	uvnr_calibdbV2_free(&pANRCtx->uvnr_v1);	
	ynr_calibdbV2_free(&pANRCtx->ynr_v1);
	#endif
	
    memset(pANRCtx, 0x00, sizeof(ANRContext_t));
    free(pANRCtx);

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

//anr config
ANRresult_t ANRPrepare(ANRContext_t *pANRCtx, ANRConfig_t* pANRConfig)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    if(pANRCtx == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_INVALID_PARM;
    }

    if(pANRConfig == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_INVALID_PARM;
    }

    //pANRCtx->eMode = pANRConfig->eMode;
    //pANRCtx->eState = pANRConfig->eState;
    //pANRCtx->refYuvBit = pANRConfig->refYuvBit;

	//update iq calibdb to context
	if(!!(pANRCtx->prepare_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB)){	
		ANRIQParaUpdate(pANRCtx);
	}
	
    ANRStart(pANRCtx);

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

//anr reconfig
ANRresult_t ANRReConfig(ANRContext_t *pANRCtx, ANRConfig_t* pANRConfig)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);
    //need todo what?

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

//anr reconfig
ANRresult_t ANRIQParaUpdate(ANRContext_t *pANRCtx)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);
    //need todo what?

	if(pANRCtx->isIQParaUpdate){
		LOGD_ANR("IQ data reconfig\n");
		#if (ANR_USE_JSON_PARA)
			ANRConfigParamJson(pANRCtx, pANRCtx->eParamMode, pANRCtx->stExpInfo.snr_mode);
		#else
			ANRConfigSettingParam(pANRCtx, pANRCtx->eParamMode, pANRCtx->stExpInfo.snr_mode);
		#endif

		
		pANRCtx->isIQParaUpdate = false;
	}

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


//anr preprocess
ANRresult_t ANRPreProcess(ANRContext_t *pANRCtx)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);
    //need todo what?

	ANRIQParaUpdate(pANRCtx);
	
    LOGI_ANR("%s(%d): exit!\n", __FUNCTION__, __LINE__);
    return ANR_RET_SUCCESS;
}

//anr process
ANRresult_t ANRProcess(ANRContext_t *pANRCtx, ANRExpInfo_t *pExpInfo)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);
	ANRParamMode_t mode = ANR_PARAM_MODE_INVALID;
	
    if(pANRCtx == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_INVALID_PARM;
    }

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

	if(pANRCtx->eState != ANR_STATE_RUNNING){
		return ANR_RET_SUCCESS;
	}
	
    ANRGainRatioProcess(&pANRCtx->stGainState, pExpInfo);

    ANRParamModeProcess(pANRCtx, pExpInfo, &mode);   
	#if ANR_USE_JSON_PARA
	pExpInfo->mfnr_mode_3to1 = pANRCtx->mfnr_v1.TuningPara.mode_3to1;
	#else
	pExpInfo->mfnr_mode_3to1 = pANRCtx->stMfnrCalib.mode_3to1;
	#endif
	
	if(pExpInfo->mfnr_mode_3to1){
		pExpInfo->snr_mode = pExpInfo->pre_snr_mode;
	}else{
		pExpInfo->snr_mode = pExpInfo->cur_snr_mode;
	}
	
    if(pANRCtx->eMode == ANR_OP_MODE_AUTO) {

        LOGD_ANR("%s(%d): refYuvBit:%d\n", __FUNCTION__, __LINE__, pANRCtx->refYuvBit);

		#if ANR_USE_XML_FILE
		if(pExpInfo->snr_mode != pANRCtx->stExpInfo.snr_mode || pANRCtx->eParamMode != mode){
			LOGD_ANR("param mode:%d snr_mode:%d\n", mode, pExpInfo->snr_mode);
			pANRCtx->eParamMode = mode;
			#if(ANR_USE_JSON_PARA)
			ANRConfigParamJson(pANRCtx, pANRCtx->eParamMode, pExpInfo->snr_mode);	
			#else
			ANRConfigSettingParam(pANRCtx, pANRCtx->eParamMode, pExpInfo->snr_mode);	
			#endif
		}
		#endif
        
        //select param
        select_bayernr_params_by_ISO(&pANRCtx->stAuto.stBayernrParams, &pANRCtx->stAuto.stBayernrParamSelect, pExpInfo);
        select_mfnr_params_by_ISO(&pANRCtx->stAuto.stMfnrParams, &pANRCtx->stAuto.stMfnrParamSelect, pExpInfo, pANRCtx->refYuvBit);
        select_ynr_params_by_ISO(&pANRCtx->stAuto.stYnrParams, &pANRCtx->stAuto.stYnrParamSelect, pExpInfo, pANRCtx->refYuvBit);
        select_uvnr_params_by_ISO(&pANRCtx->stAuto.stUvnrParams, &pANRCtx->stAuto.stUvnrParamSelect, pExpInfo);
	 mfnr_dynamic_calc(&pANRCtx->stAuto.stMfnr_dynamic, pExpInfo);

    } else if(pANRCtx->eMode == ANR_OP_MODE_MANUAL) {
        //TODO
    }

    memcpy(&pANRCtx->stExpInfo, pExpInfo, sizeof(ANRExpInfo_t));

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

}

ANRresult_t ANRSetGainMode(ANRProcResult_t* pANRResult)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    if(pANRResult == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_INVALID_PARM;
    }

    if(pANRResult->stGainFix.gain_table_en) {
        pANRResult->stMfnrFix.gain_en = 0;
        pANRResult->stUvnrFix.nr_gain_en = 0;

    } else {
        pANRResult->stMfnrFix.gain_en = 1;
        pANRResult->stUvnrFix.nr_gain_en = 1;
    }

    return ANR_RET_SUCCESS;
}


//anr get result
ANRresult_t ANRGetProcResult(ANRContext_t *pANRCtx, ANRProcResult_t* pANRResult)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    if(pANRCtx == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_INVALID_PARM;
    }

    if(pANRResult == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_INVALID_PARM;
    }

    if(pANRCtx->eMode == ANR_OP_MODE_AUTO) {

        pANRResult->stBayernrParamSelect = pANRCtx->stAuto.stBayernrParamSelect;
        pANRResult->stMfnrParamSelect = pANRCtx->stAuto.stMfnrParamSelect;
        pANRResult->stYnrParamSelect = pANRCtx->stAuto.stYnrParamSelect;
        pANRResult->stUvnrParamSelect = pANRCtx->stAuto.stUvnrParamSelect;

        pANRResult->bayernrEn = pANRCtx->stAuto.bayernrEn;
        pANRResult->mfnrEn = pANRCtx->stAuto.mfnrEn;
        pANRResult->ynrEN = pANRCtx->stAuto.ynrEn;
        pANRResult->uvnrEn = pANRCtx->stAuto.uvnrEn;

	 if(pANRCtx->stAuto.mfnrEn && pANRCtx->stAuto.stMfnr_dynamic.enable){
		pANRResult->mfnrEn = pANRCtx->stAuto.stMfnr_dynamic.mfnr_enable_state;
	 }

    } else if(pANRCtx->eMode == ANR_OP_MODE_MANUAL) {
        //TODO
        pANRResult->bayernrEn = pANRCtx->stManual.bayernrEn;
        pANRResult->stBayernrParamSelect = pANRCtx->stManual.stBayernrParamSelect;
        pANRResult->mfnrEn = pANRCtx->stManual.mfnrEn;
        pANRResult->stMfnrParamSelect = pANRCtx->stManual.stMfnrParamSelect;
        pANRResult->ynrEN = pANRCtx->stManual.ynrEn;
        pANRResult->stYnrParamSelect = pANRCtx->stManual.stYnrParamSelect;
        pANRResult->uvnrEn = pANRCtx->stManual.uvnrEn;
        pANRResult->stUvnrParamSelect = pANRCtx->stManual.stUvnrParamSelect;
 	 pANRCtx->fLuma_TF_Strength = 1.0;
 	 pANRCtx->fLuma_SF_Strength = 1.0;
	 pANRCtx->fChroma_SF_Strength = 1.0;
	 pANRCtx->fChroma_TF_Strength = 1.0;
	 pANRCtx->fRawnr_SF_Strength = 1.0;
    }

	//for bw setting
	if(pANRCtx->isGrayMode){
		LOGD_ANR("anr: set gray mode!\n");
		for(int i=0; i<MFNR_MAX_LVL_UV; i++){
			pANRResult->stMfnrParamSelect.weight_limit_uv[i] = MFNR_MAX_WEIGHT_LIMIT_UV;
		}
	}
		
    //transfer to reg value
    bayernr_fix_tranfer(&pANRResult->stBayernrParamSelect, &pANRResult->stBayernrFix, pANRCtx->fRawnr_SF_Strength);
    mfnr_fix_transfer(&pANRResult->stMfnrParamSelect, &pANRResult->stMfnrFix, &pANRCtx->stExpInfo, pANRCtx->stGainState.ratio, pANRCtx->fLuma_TF_Strength,  pANRCtx->fChroma_TF_Strength);
    ynr_fix_transfer(&pANRResult->stYnrParamSelect, &pANRResult->stYnrFix, pANRCtx->stGainState.ratio, pANRCtx->fLuma_SF_Strength);
    uvnr_fix_transfer(&pANRResult->stUvnrParamSelect, &pANRResult->stUvnrFix, &pANRCtx->stExpInfo, pANRCtx->stGainState.ratio, pANRCtx->fChroma_SF_Strength);
    gain_fix_transfer(&pANRResult->stMfnrParamSelect, &pANRResult->stGainFix, &pANRCtx->stExpInfo, pANRCtx->stGainState.ratio);
    pANRResult->stBayernrFix.rawnr_en = pANRResult->bayernrEn;
    pANRResult->stMfnrFix.tnr_en = pANRResult->mfnrEn;   
    pANRResult->stYnrFix.ynr_en = pANRResult->ynrEN;
    pANRResult->stUvnrFix.uvnr_en = pANRResult->uvnrEn;

	#if(ANR_USE_JSON_PARA)
	pANRResult->stMfnrFix.mode = pANRCtx->mfnr_v1.TuningPara.mode_3to1;
    pANRResult->stGainFix.gain_table_en = pANRCtx->mfnr_v1.TuningPara.local_gain_en;
	#else
	pANRResult->stMfnrFix.mode = pANRCtx->stMfnrCalib.mode_3to1;
    pANRResult->stGainFix.gain_table_en = pANRCtx->stMfnrCalib.local_gain_en;
	#endif

	
    ANRSetGainMode(pANRResult);

	//for bw setting
	if(pANRCtx->isGrayMode){
		//uvnr disable
		pANRResult->stUvnrFix.uvnr_step1_en = 0;
		pANRResult->stUvnrFix.uvnr_step2_en = 0;
	}

    LOGD_ANR("%s:%d xml:local:%d mode:%d  reg: local gain:%d  mfnr gain:%d mode:%d\n",
             __FUNCTION__, __LINE__,
             pANRResult->stGainFix.gain_table_en,
             pANRResult->stMfnrFix.mode,
             pANRResult->stGainFix.gain_table_en,
             pANRResult->stMfnrFix.gain_en,
             pANRResult->stMfnrFix.mode);

	 //select motion params
	#if ANR_USE_JSON_PARA
	pANRResult->stMotion = pANRCtx->stMotion;
	#else
	int mode_idx = 0;
	if(pANRCtx->eParamMode == ANR_PARAM_MODE_NORMAL){
		mfnr_get_mode_cell_idx_by_name(&pANRCtx->stMfnrCalib, "normal", &mode_idx);
	}else if(pANRCtx->eParamMode == ANR_PARAM_MODE_HDR){
		mfnr_get_mode_cell_idx_by_name(&pANRCtx->stMfnrCalib, "hdr", &mode_idx);
	}else if(pANRCtx->eParamMode == ANR_PARAM_MODE_GRAY){
		mfnr_get_mode_cell_idx_by_name(&pANRCtx->stMfnrCalib, "gray", &mode_idx);
	}else{
		LOGE_ANR("%s(%d): not support param mode!\n", __FUNCTION__, __LINE__);
	}	
	pANRResult->stMotion = pANRCtx->stMfnrCalib.mode_cell[mode_idx].motion;
	#endif
    LOGI_ANR("%s(%d): exit!\n", __FUNCTION__, __LINE__);
    return ANR_RET_SUCCESS;
}

ANRresult_t ANRGainRatioProcess(ANRGainState_t *pGainState, ANRExpInfo_t *pExpInfo)
{
    LOGI_ANR("%s(%d): enter!\n", __FUNCTION__, __LINE__);

    if(pGainState == NULL) {
        LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
        return ANR_RET_INVALID_PARM;
    }

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

    float gain_cur = pExpInfo->arAGain[pExpInfo->hdr_mode] * pExpInfo->arDGain[pExpInfo->hdr_mode];
    float th[2];
    float gain_th0[2];
    float gain_th1[2];
    for(int i = 0; i < 2; i++){
        gain_th0[i]     = pGainState->gain_th0[i];
        gain_th1[i]     = pGainState->gain_th1[i];
        th[i]           = pow(2.0, (log2(gain_th0[i])+log2(gain_th1[i])) / 2);
    }

    pGainState->gain_cur = gain_cur;

	int gain_stat_full = -1;
	int gain_stat_full_last = pGainState->gain_stat_full_last;
	int gain_stat_last = pGainState->gainState_last;
	int gain_stat_cur  = -1;
	int gain_stat = -1;

    if(gain_cur <= gain_th0[0])
	{
        gain_stat_full = 0;
        gain_stat_cur = 0;
	}
    else if(gain_cur <= gain_th1[0] && gain_cur >= gain_th0[0])
    {
        gain_stat_full = 1;
    }
    else if(gain_cur <= gain_th0[1] && gain_cur >= gain_th1[0])
    {
        gain_stat_full = 2;
        gain_stat_cur = 1;
  	 }
    else if(gain_cur <= gain_th1[1] && gain_cur >= gain_th0[1])
    {
        gain_stat_full = 3;
    }
    else if(gain_cur >= gain_th1[1])
	{
        gain_stat_full = 4;
        gain_stat_cur = 2;
	}
   if(gain_stat_last == -1 || (abs(gain_stat_full - gain_stat_full_last) >= 2 && gain_stat_cur == -1)) {
        if(gain_cur <= th[0])
            gain_stat_cur = 0;
        else if(gain_cur <= th[1])
            gain_stat_cur = 1;
        else
            gain_stat_cur = 2;
    }
    if (gain_stat_cur != -1) {
        gain_stat_last      = gain_stat_cur;
        gain_stat_full_last = gain_stat_full;
        gain_stat       = gain_stat_cur;
    } else {
        gain_stat       = gain_stat_last;
    }
    if (gain_stat ==0)
        pGainState->ratio = 16;
    else if (gain_stat == 1)
        pGainState->ratio = 1;
    else
        pGainState->ratio = 1.0/16.0;

	pGainState->gain_stat_full_last 	= gain_stat_full_last;
	pGainState->gainState 		= gain_stat;
	pGainState->gainState_last 	= gain_stat_last;

    LOGD_ANR("%s:%d gain_cur:%f gain th %f %fd %f %f ratio:%f gain_state:%d %d full    %d %d\n",
             __FUNCTION__, __LINE__,
             gain_cur, 
             gain_th0[0],gain_th0[1],
             gain_th1[0],gain_th1[1],
             pGainState->ratio,
             pGainState->gainState_last,
             pGainState->gainState,
             pGainState->gain_stat_full_last,
             gain_stat_full);
    

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

    return ANR_RET_SUCCESS;
}

ANRresult_t ANRConfigSettingParam(ANRContext_t *pANRCtx, ANRParamMode_t eParamMode, int snr_mode)
{
	char snr_name[CALIBDB_NR_SHARP_NAME_LENGTH];
	char param_mode_name[CALIBDB_MAX_MODE_NAME_LENGTH];
	memset(param_mode_name, 0x00, sizeof(param_mode_name));
	memset(snr_name, 0x00, sizeof(snr_name));
	
	if(pANRCtx == NULL) {
		LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
		return ANR_RET_INVALID_PARM;
	}

	 //select param mode first
	if(eParamMode == ANR_PARAM_MODE_NORMAL){
		sprintf(param_mode_name, "%s", "normal");
	}else if(eParamMode == ANR_PARAM_MODE_HDR){
		sprintf(param_mode_name, "%s", "hdr");
	}else if(eParamMode == ANR_PARAM_MODE_GRAY){
		sprintf(param_mode_name, "%s", "gray");
	}else{
		LOGE_ANR("%s(%d): not support param mode!\n", __FUNCTION__, __LINE__);
		sprintf(param_mode_name, "%s", "normal");
	}
	

	 //then select snr mode next
	if(snr_mode == 1){
		sprintf(snr_name, "%s", "HSNR");
	}else if(snr_mode == 0){
		sprintf(snr_name, "%s", "LSNR");
	}else{
		LOGE_ANR("%s(%d): not support snr mode!\n", __FUNCTION__, __LINE__);
		sprintf(snr_name, "%s", "LSNR");
	}
	
	pANRCtx->stAuto.bayernrEn = pANRCtx->stBayernrCalib.enable;
	bayernr_config_setting_param(&pANRCtx->stAuto.stBayernrParams, &pANRCtx->stBayernrCalib, param_mode_name, snr_name);

	pANRCtx->stAuto.uvnrEn = pANRCtx->stUvnrCalib.enable;
	uvnr_config_setting_param(&pANRCtx->stAuto.stUvnrParams, &pANRCtx->stUvnrCalib, param_mode_name, snr_name);
	
	pANRCtx->stAuto.ynrEn = pANRCtx->stYnrCalib.enable;
	ynr_config_setting_param(&pANRCtx->stAuto.stYnrParams, &pANRCtx->stYnrCalib, param_mode_name, snr_name);
	
	pANRCtx->stAuto.mfnrEn = pANRCtx->stMfnrCalib.enable;
	mfnr_config_setting_param(&pANRCtx->stAuto.stMfnrParams, &pANRCtx->stMfnrCalib, param_mode_name, snr_name);
	mfnr_config_dynamic_param(&pANRCtx->stAuto.stMfnr_dynamic, &pANRCtx->stMfnrCalib, param_mode_name);
	return ANR_RET_SUCCESS; 
}

ANRresult_t ANRParamModeProcess(ANRContext_t *pANRCtx, ANRExpInfo_t *pExpInfo, ANRParamMode_t *mode){
	ANRresult_t res  = ANR_RET_SUCCESS;
	*mode = pANRCtx->eParamMode;
		
	if(pANRCtx == NULL) {
    	LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
    	return ANR_RET_INVALID_PARM;
	}

	if(pANRCtx->isGrayMode){
		*mode = ANR_PARAM_MODE_GRAY;
	}else if(pExpInfo->hdr_mode == 0){
		*mode = ANR_PARAM_MODE_NORMAL;
	}else if(pExpInfo->hdr_mode >= 1){
		*mode = ANR_PARAM_MODE_HDR;
	}else{
		*mode = ANR_PARAM_MODE_NORMAL;
	}

	return res;
}



ANRresult_t ANRConfigParamJson(ANRContext_t *pANRCtx, ANRParamMode_t eParamMode, int snr_mode)
{
	char snr_name[CALIBDB_NR_SHARP_NAME_LENGTH];
	char param_mode_name[CALIBDB_MAX_MODE_NAME_LENGTH];
	memset(param_mode_name, 0x00, sizeof(param_mode_name));
	memset(snr_name, 0x00, sizeof(snr_name));
	
	if(pANRCtx == NULL) {
		LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
		return ANR_RET_INVALID_PARM;
	}

	 //select param mode first
	if(eParamMode == ANR_PARAM_MODE_NORMAL){
		sprintf(param_mode_name, "%s", "normal");
	}else if(eParamMode == ANR_PARAM_MODE_HDR){
		sprintf(param_mode_name, "%s", "hdr");
	}else if(eParamMode == ANR_PARAM_MODE_GRAY){
		sprintf(param_mode_name, "%s", "gray");
	}else{
		LOGE_ANR("%s(%d): not support param mode!\n", __FUNCTION__, __LINE__);
		sprintf(param_mode_name, "%s", "normal");
	}
	

	 //then select snr mode next
	if(snr_mode == 1){
		sprintf(snr_name, "%s", "HSNR");
	}else if(snr_mode == 0){
		sprintf(snr_name, "%s", "LSNR");
	}else{
		LOGE_ANR("%s(%d): not support snr mode!\n", __FUNCTION__, __LINE__);
		sprintf(snr_name, "%s", "LSNR");
	}
	
	pANRCtx->stAuto.bayernrEn = pANRCtx->bayernr_v1.TuningPara.enable;
	bayernr_config_setting_param_json(&pANRCtx->stAuto.stBayernrParams, &pANRCtx->bayernr_v1, param_mode_name, snr_name);

	pANRCtx->stAuto.uvnrEn = pANRCtx->uvnr_v1.TuningPara.enable;
	uvnr_config_setting_param_json(&pANRCtx->stAuto.stUvnrParams, &pANRCtx->uvnr_v1, param_mode_name, snr_name);
	
	pANRCtx->stAuto.ynrEn = pANRCtx->ynr_v1.TuningPara.enable;
	ynr_config_setting_param_json(&pANRCtx->stAuto.stYnrParams, &pANRCtx->ynr_v1, param_mode_name, snr_name);
	
	pANRCtx->stAuto.mfnrEn = pANRCtx->mfnr_v1.TuningPara.enable;
	mfnr_config_setting_param_json(&pANRCtx->stAuto.stMfnrParams, &pANRCtx->mfnr_v1, param_mode_name, snr_name);
	mfnr_config_dynamic_param_json(&pANRCtx->stAuto.stMfnr_dynamic, &pANRCtx->mfnr_v1, param_mode_name);
	mfnr_config_motion_param_json(&pANRCtx->stMotion, &pANRCtx->mfnr_v1, param_mode_name);
	
	return ANR_RET_SUCCESS; 
}

RKAIQ_END_DECLARE