/******************************************************************************
 *
 * Copyright 2019, Fuzhou Rockchip Electronics Co.Ltd. All rights reserved.
 * No part of this work may be reproduced, modified, distributed, transmitted,
 * transcribed, or translated into any language or computer format, in any form
 * or by any means without written permission of:
 * Fuzhou Rockchip Electronics Co.Ltd .
 *
 *
 *****************************************************************************/
/**
 * @file adrc.cpp
 *
 * @brief
 *   ADD_DESCRIPTION_HERE
 *
 *****************************************************************************/
#include "math.h"
#include "rk_aiq_types_adrc_algo_int.h"
#include "xcam_log.h"
#include "rk_aiq_types_adrc_algo_prvt.h"


/******************************************************************************
 * AdrcStart()
 *****************************************************************************/
XCamReturn AdrcStart
(
    AdrcHandle_t pAdrcCtx
) {

    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    // initial checks
    if (pAdrcCtx == NULL) {
        return (XCAM_RETURN_ERROR_MEM);
    }

    if ((ADRC_STATE_RUNNING == pAdrcCtx->state)
            || (ADRC_STATE_LOCKED == pAdrcCtx->state)) {
        return (XCAM_RETURN_ERROR_PARAM);
    }

    pAdrcCtx->state = ADRC_STATE_RUNNING;

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

/******************************************************************************
 * DrcGetCurrPara()
 *****************************************************************************/
float DrcGetCurrPara
(
    float           inPara,
    float*         inMatrixX,
    float*         inMatrixY,
    int Max_Knots
) {
    LOG1_AMERGE( "%s:enter!\n", __FUNCTION__);
    float x1 = 0.0f;
    float x2 = 0.0f;
    float value1 = 0.0f;
    float value2 = 0.0f;
    float outPara = 0.0f;

    if(inPara < inMatrixX[0])
        outPara = inMatrixY[0];
    else if (inPara >= inMatrixX[Max_Knots - 1])
        outPara = inMatrixY[Max_Knots - 1];
    else
        for(int i = 0; i < Max_Knots - 1; i++)
        {
            if(inPara >= inMatrixX[i] && inPara < inMatrixX[i + 1])
            {
                x1 = inMatrixX[i];
                x2 = inMatrixX[i + 1];
                value1 = inMatrixY[i];
                value2 = inMatrixY[i + 1];
                outPara = value1 + (inPara - x1) * (value1 - value2) / (x1 - x2);
                break;
            }
            else
                continue;
        }

    return outPara;
    LOG1_AMERGE( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcStop()
 *****************************************************************************/
XCamReturn AdrcStop
(
    AdrcHandle_t pAdrcCtx
) {

    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    // initial checks
    if (pAdrcCtx == NULL) {
        return (XCAM_RETURN_ERROR_MEM);
    }

    // before stopping, unlock the AHDR if locked
    if (ADRC_STATE_LOCKED == pAdrcCtx->state) {
        return (XCAM_RETURN_ERROR_PARAM);
    }

    pAdrcCtx->state = ADRC_STATE_STOPPED;

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);

    return (XCAM_RETURN_NO_ERROR);
}
/******************************************************************************
 * DrcNewMalloc()
 ***************************************************************************/
void DrcNewMalloc
(
    AdrcConfig_t*           pConfig,
    CalibDbV2_drc_t*         pCalibDb
) {
    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    // initial checks
    DCT_ASSERT(pConfig != NULL);
    DCT_ASSERT(pCalibDb != NULL);
    LOG1_ATMO( "%s: Pre DrcGain len:%d, Cur DrcGain len:%d\n", __FUNCTION__, pConfig->DrcGain.len, pCalibDb->DrcTuningPara.DrcGain.EnvLv_len);
    LOG1_ATMO( "%s: Pre HiLit len:%d, Cur HiLit len:%d\n", __FUNCTION__, pConfig->HiLit.len, pCalibDb->DrcTuningPara.HiLight.EnvLv_len);
    LOG1_ATMO( "%s: Pre Local len:%d, Cur Local len:%d\n", __FUNCTION__, pConfig->Local.len, pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len);

    //drc gain
    if(pConfig->DrcGain.len != pCalibDb->DrcTuningPara.DrcGain.EnvLv_len) {
        free(pConfig->DrcGain.EnvLv);
        free(pConfig->DrcGain.DrcGain);
        free(pConfig->DrcGain.Alpha);
        free(pConfig->DrcGain.Clip);
        pConfig->DrcGain.len = pCalibDb->DrcTuningPara.DrcGain.EnvLv_len;
        pConfig->DrcGain.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.DrcGain.EnvLv_len));
        pConfig->DrcGain.DrcGain = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.DrcGain.EnvLv_len));
        pConfig->DrcGain.Alpha = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.DrcGain.EnvLv_len));
        pConfig->DrcGain.Clip = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.DrcGain.EnvLv_len));
    }

    //hilit
    if(pConfig->HiLit.len != pCalibDb->DrcTuningPara.HiLight.EnvLv_len) {
        free(pConfig->HiLit.EnvLv);
        free(pConfig->HiLit.Strength);
        pConfig->HiLit.len = pCalibDb->DrcTuningPara.HiLight.EnvLv_len;
        pConfig->HiLit.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.HiLight.EnvLv_len));
        pConfig->HiLit.Strength = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.HiLight.EnvLv_len));
    }

    //local
    if(pConfig->Local.len != pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len) {
        free(pConfig->Local.EnvLv);
        free(pConfig->Local.LocalWeit);
        free(pConfig->Local.GlobalContrast);
        free(pConfig->Local.LoLitContrast);
        pConfig->Local.len = pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len;
        pConfig->Local.EnvLv = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
        pConfig->Local.LocalWeit = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
        pConfig->Local.GlobalContrast = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
        pConfig->Local.LoLitContrast = (float*)malloc(sizeof(float) * (pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
    }

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
* CalibrateDrcGainY()
*****************************************************************************/
void CalibrateDrcGainY( DrcProcRes_t *para, float DraGain, float alpha)
{
    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);

    float tmp = 0;
    float luma[17] = { 0, 256, 512, 768, 1024, 1280, 1536, 1792, 2048, 2304, 2560, 2816, 3072, 3328, 3584, 3840, 4096 };
    float gainTable[17];

    for(int i = 0; i < 17; ++i) {
        tmp = luma[i];
        tmp = 1 - alpha * pow((1 - tmp / 4096), 2);
        gainTable[i] = 1024 * pow(DraGain, tmp);
        para->sw_drc_gain_y[i] = (int)(gainTable[i]) ;
    }

    LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);

}

/******************************************************************************
 * AdrcApiOffConfig()
 *set default Config data
 *****************************************************************************/
void AdrcApiOffConfig
(
    AdrcHandle_t           pAdrcCtx
) {
    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);




    LOGI_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * Config()
 *set default Config data
 *****************************************************************************/
void Config
(
    AdrcHandle_t           pAdrcCtx
) {
    LOGI_ATMO( "%s:enter!\n", __FUNCTION__);

    // initial checks
    DCT_ASSERT(pAdrcCtx != NULL);

    if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_API_OFF)
    {
        AdrcApiOffConfig(pAdrcCtx);
        LOGD_ATMO("%s: Ahdr Api is OFF!!!:\n", __FUNCTION__);
    }
    else
        LOGD_ATMO("%s: Ahdr Api is ON!!!:\n", __FUNCTION__);

    //config default PrevData data
    pAdrcCtx->PrevData.frameCnt = 0;
    pAdrcCtx->PrevData.EnvLv = 0;
    pAdrcCtx->PrevData.ApiMode = DRC_OPMODE_API_OFF;
    pAdrcCtx->PrevData.HandleData.DrcGain = 4.0;
    pAdrcCtx->PrevData.HandleData.Alpha = 0.2;
    pAdrcCtx->PrevData.HandleData.Clip = 16.0 ;
    pAdrcCtx->PrevData.HandleData.Strength = 0.01 ;
    pAdrcCtx->PrevData.HandleData.LocalWeit = 1.00 ;
    pAdrcCtx->PrevData.HandleData.GlobalContrast = 0 ;
    pAdrcCtx->PrevData.HandleData.LoLitContrast = 0;

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}
void AdrcGetAeResult
(
    AdrcHandle_t           pAdrcCtx,
    AecPreResult_t  AecHdrPreResult
) {
    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    //get Ae Pre Result
    pAdrcCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[AecHdrPreResult.NormalIndex];
    pAdrcCtx->CurrAeResult.M2S_Ratio = AecHdrPreResult.M2S_ExpRatio;
    pAdrcCtx->CurrAeResult.M2S_Ratio = pAdrcCtx->CurrAeResult.M2S_Ratio < 1 ? 1 : pAdrcCtx->CurrAeResult.M2S_Ratio;
    pAdrcCtx->CurrAeResult.L2M_Ratio = AecHdrPreResult.L2M_ExpRatio;
    pAdrcCtx->CurrAeResult.L2M_Ratio = pAdrcCtx->CurrAeResult.L2M_Ratio < 1 ? 1 : pAdrcCtx->CurrAeResult.L2M_Ratio;

    //transfer CurrAeResult data into AhdrHandle
    switch (pAdrcCtx->FrameNumber)
    {
    case 1:
        pAdrcCtx->CurrData.Ratio = 1;
        pAdrcCtx->CurrAeResult.ISO = AecHdrPreResult.LinearExp.exp_real_params.analog_gain * 50.0;
        pAdrcCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[0];
        pAdrcCtx->CurrAeResult.AEMaxRatio = 1.0;
        break;
    case 2:
        pAdrcCtx->CurrData.Ratio = pAdrcCtx->CurrAeResult.M2S_Ratio;
        pAdrcCtx->CurrAeResult.ISO = AecHdrPreResult.HdrExp[1].exp_real_params.analog_gain * 50.0;
        pAdrcCtx->CurrAeResult.GlobalEnvLv = AecHdrPreResult.GlobalEnvLv[1];
        //todo
        pAdrcCtx->CurrAeResult.AEMaxRatio = 64.0;
        break;
    default:
        LOGE_ATMO("%s:  Wrong frame number in HDR mode!!!\n", __FUNCTION__);
        break;
    }

    //Normalize the current envLv for AEC
    float maxEnvLuma = 65 / 10;
    float minEnvLuma = 0;
    pAdrcCtx->CurrData.EnvLv = (pAdrcCtx->CurrAeResult.GlobalEnvLv  - minEnvLuma) / (maxEnvLuma - minEnvLuma);
    pAdrcCtx->CurrData.EnvLv = LIMIT_VALUE(pAdrcCtx->CurrData.EnvLv, 1, 0);

    LOGD_ATMO("%s:  Current Ratio:%f\n", __FUNCTION__, pAdrcCtx->CurrData.Ratio);

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

void AdrcGetSensorInfo
(
    AdrcHandle_t     pAdrcCtx,
    AecProcResult_t  AecHdrProcResult
) {
    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    pAdrcCtx->SensorInfo.LongFrmMode = AecHdrProcResult.LongFrmMode;

    for(int i = 0; i < 3; i++)
    {
#if 0 // TODO Merge
        pAdrcCtx->SensorInfo.HdrMinGain[i] = AecHdrProcResult.HdrExpRange.stGainRange[i].Min;
        pAdrcCtx->SensorInfo.HdrMaxGain[i] = AecHdrProcResult.HdrExpRange.stGainRange[i].Max;
        pAdrcCtx->SensorInfo.HdrMinIntegrationTime[i] = AecHdrProcResult.HdrExpRange.stExpTimeRange[i].Min;
        pAdrcCtx->SensorInfo.HdrMaxIntegrationTime[i] = AecHdrProcResult.HdrExpRange.stExpTimeRange[i].Max;
#endif
    }

    if(pAdrcCtx->FrameNumber == 1) {
        pAdrcCtx->SensorInfo.MaxExpoL = 0;
        pAdrcCtx->SensorInfo.MinExpoL = 0;
    }
    else if(pAdrcCtx->FrameNumber == 2) {
        pAdrcCtx->SensorInfo.MaxExpoL = pAdrcCtx->SensorInfo.HdrMaxGain[1] * pAdrcCtx->SensorInfo.HdrMaxIntegrationTime[2];
        pAdrcCtx->SensorInfo.MinExpoL = pAdrcCtx->SensorInfo.HdrMinGain[1] * pAdrcCtx->SensorInfo.HdrMinIntegrationTime[2];
    }

    pAdrcCtx->SensorInfo.MaxExpoS = pAdrcCtx->SensorInfo.HdrMaxGain[0] * pAdrcCtx->SensorInfo.HdrMaxIntegrationTime[0];
    pAdrcCtx->SensorInfo.MinExpoS = pAdrcCtx->SensorInfo.HdrMinGain[0] * pAdrcCtx->SensorInfo.HdrMinIntegrationTime[0];


    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcIQUpdate()
 *
 *****************************************************************************/
void AdrcIQUpdate
(
    AdrcHandle_t     pAdrcCtx
)
{
    LOG1_ATMO("%s:enter!\n", __FUNCTION__);

    //get Drc gain
    pAdrcCtx->CurrData.HandleData.DrcGain = DrcGetCurrPara(pAdrcCtx->CurrData.EnvLv,
                                            pAdrcCtx->Config.DrcGain.EnvLv, pAdrcCtx->Config.DrcGain.DrcGain, pAdrcCtx->Config.DrcGain.len);
    pAdrcCtx->CurrData.HandleData.Alpha = DrcGetCurrPara(pAdrcCtx->CurrData.EnvLv,
                                          pAdrcCtx->Config.DrcGain.EnvLv, pAdrcCtx->Config.DrcGain.Alpha, pAdrcCtx->Config.DrcGain.len);
    pAdrcCtx->CurrData.HandleData.Clip = DrcGetCurrPara(pAdrcCtx->CurrData.EnvLv,
                                         pAdrcCtx->Config.DrcGain.EnvLv, pAdrcCtx->Config.DrcGain.Clip, pAdrcCtx->Config.DrcGain.len);

    //get hi lit
    pAdrcCtx->CurrData.HandleData.Strength = DrcGetCurrPara(pAdrcCtx->CurrData.EnvLv,
            pAdrcCtx->Config.HiLit.EnvLv, pAdrcCtx->Config.HiLit.Strength, pAdrcCtx->Config.HiLit.len);

    //get local
    pAdrcCtx->CurrData.HandleData.LocalWeit = DrcGetCurrPara(pAdrcCtx->CurrData.EnvLv,
            pAdrcCtx->Config.Local.EnvLv, pAdrcCtx->Config.Local.LocalWeit, pAdrcCtx->Config.Local.len);
    pAdrcCtx->CurrData.HandleData.GlobalContrast = DrcGetCurrPara(pAdrcCtx->CurrData.EnvLv,
            pAdrcCtx->Config.Local.EnvLv, pAdrcCtx->Config.Local.GlobalContrast, pAdrcCtx->Config.Local.len);
    pAdrcCtx->CurrData.HandleData.LoLitContrast = DrcGetCurrPara(pAdrcCtx->CurrData.EnvLv,
            pAdrcCtx->Config.Local.EnvLv, pAdrcCtx->Config.Local.LoLitContrast, pAdrcCtx->Config.Local.len);

    //compress
    pAdrcCtx->CurrData.HandleData.Mode = pAdrcCtx->Config.Compress.Mode;
    for(int i = 0; i < ADRC_Y_NUM; i++)
        pAdrcCtx->CurrData.HandleData.Manual_curve[i] = pAdrcCtx->Config.Compress.Manual_curve[i];

    //others
    if(0 != memcmp(&pAdrcCtx->CurrData.Others, &pAdrcCtx->Config.Others, sizeof(DrcOhters_t)))
        memcpy(&pAdrcCtx->CurrData.Others, &pAdrcCtx->Config.Others, sizeof(DrcOhters_t));//load iq paras

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcTranferData2Api()
 *
 *****************************************************************************/
void AdrcTranferData2Api
(
    AdrcHandle_t     pAdrcCtx
)
{
    LOG1_ATMO("%s:enter!\n", __FUNCTION__);

    //info
    pAdrcCtx->drcAttr.Info.EnvLv = pAdrcCtx->CurrData.EnvLv;

    //reg
    pAdrcCtx->drcAttr.stManual.DrcGain.DrcGain = pAdrcCtx->CurrData.HandleData.DrcGain;
    pAdrcCtx->drcAttr.stManual.DrcGain.Alpha = pAdrcCtx->CurrData.HandleData.Alpha;
    pAdrcCtx->drcAttr.stManual.DrcGain.Clip = pAdrcCtx->CurrData.HandleData.Clip;

    pAdrcCtx->drcAttr.stManual.HiLit.Strength = pAdrcCtx->CurrData.HandleData.Strength;

    pAdrcCtx->drcAttr.stManual.Local.LocalWeit = pAdrcCtx->CurrData.HandleData.LocalWeit;
    pAdrcCtx->drcAttr.stManual.Local.GlobalContrast = pAdrcCtx->CurrData.HandleData.GlobalContrast;
    pAdrcCtx->drcAttr.stManual.Local.LoLitContrast = pAdrcCtx->CurrData.HandleData.LoLitContrast;


    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcApiManualUpdate()
 *
 *****************************************************************************/
void AdrcApiManualUpdate
(
    CurrData_t*     pAdrcCurr,
    mdrcAttr_t*  pStManual

)
{
    LOG1_ATMO("%s:enter!\n", __FUNCTION__);

    //get Drc gain
    pAdrcCurr->HandleData.DrcGain = pStManual->DrcGain.DrcGain;
    pAdrcCurr->HandleData.Alpha = pStManual->DrcGain.Alpha;
    pAdrcCurr->HandleData.Clip = pStManual->DrcGain.Clip;

    //get hi lit
    pAdrcCurr->HandleData.Strength = pStManual->HiLit.Strength;

    //get local
    pAdrcCurr->HandleData.LocalWeit = pStManual->Local.LocalWeit;
    pAdrcCurr->HandleData.GlobalContrast = pStManual->Local.GlobalContrast;
    pAdrcCurr->HandleData.LoLitContrast = pStManual->Local.LoLitContrast;

    //compress
    pAdrcCurr->HandleData.Mode = pStManual->Compress.Mode;
    for(int i = 0; i < ADRC_Y_NUM; i++)
        pAdrcCurr->HandleData.Manual_curve[i] = pStManual->Compress.Manual_curve[i];

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcUpdateConfig()
 *transfer html parameter into handle
 ***************************************************************************/
void AdrcUpdateConfig
(
    AdrcHandle_t           pAdrcCtx,
    CalibDbV2_drc_t*         pCalibDb
) {
    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    // initial checks
    DCT_ASSERT(pAdrcCtx != NULL);
    DCT_ASSERT(pCalibDb != NULL);

    //enbale
    pAdrcCtx->Config.Enable = pCalibDb->DrcTuningPara.Enable;
    pAdrcCtx->Config.OutPutLongFrame = pCalibDb->DrcTuningPara.OutPutLongFrame;

    //drc gain
    for (int i = 0; i < pAdrcCtx->Config.DrcGain.len; i++ ) {
        pAdrcCtx->Config.DrcGain.EnvLv[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.DrcGain.EnvLv[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
        pAdrcCtx->Config.DrcGain.DrcGain[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.DrcGain.DrcGain[i], DRCGAINMAX, DRCGAINMIN);
        pAdrcCtx->Config.DrcGain.Alpha[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.DrcGain.Alpha[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
        pAdrcCtx->Config.DrcGain.Clip[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.DrcGain.Clip[i], CLIPMAX, CLIPMIN);
    }
    //hight ligjt
    for (int i = 0; i < pAdrcCtx->Config.HiLit.len; i++ ) {
        pAdrcCtx->Config.HiLit.EnvLv[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.HiLight.EnvLv[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
        pAdrcCtx->Config.HiLit.Strength[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.HiLight.Strength[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    }
    // local
    for (int i = 0; i < pAdrcCtx->Config.Local.len; i++ ) {
        pAdrcCtx->Config.Local.EnvLv[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
        pAdrcCtx->Config.Local.LocalWeit[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.LocalWeit[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
        pAdrcCtx->Config.Local.GlobalContrast[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.GlobalContrast[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
        pAdrcCtx->Config.Local.LoLitContrast[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.LocalTMOData.LoLitContrast[i], ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    }
    //others
    pAdrcCtx->Config.Others.curPixWeit = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.curPixWeit, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    pAdrcCtx->Config.Others.preFrameWeit = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.preFrameWeit, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    pAdrcCtx->Config.Others.Range_force_sgm = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.Range_force_sgm, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    pAdrcCtx->Config.Others.Range_sgm_cur = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.Range_sgm_cur, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    pAdrcCtx->Config.Others.Range_sgm_pre = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.Range_sgm_pre, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    pAdrcCtx->Config.Others.Space_sgm_cur = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.Space_sgm_cur, SPACESGMMAX, SPACESGMMIN);
    pAdrcCtx->Config.Others.Space_sgm_pre = LIMIT_VALUE(pCalibDb->DrcTuningPara.LocalTMOSetting.Space_sgm_pre, SPACESGMMAX, SPACESGMMIN);
    //compress and scale y
    pAdrcCtx->Config.Compress.Mode = pCalibDb->DrcTuningPara.CompressSetting.Mode;
    for(int i = 0; i < ADRC_Y_NUM; i++ ) {
        pAdrcCtx->Config.Others.Scale_y[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.Scale_y[i], SCALEYMAX, SCALEYMIN);
        pAdrcCtx->Config.Compress.Manual_curve[i] = LIMIT_VALUE(pCalibDb->DrcTuningPara.CompressSetting.Manual_curve[i], MANUALCURVEMAX, MANUALCURVEMIN);
    }
    pAdrcCtx->Config.Others.ByPassThr = LIMIT_VALUE(pCalibDb->DrcTuningPara.ByPassThr, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    pAdrcCtx->Config.Others.Edge_Weit = LIMIT_VALUE(pCalibDb->DrcTuningPara.Edge_Weit, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);
    pAdrcCtx->Config.Others.IIR_frame = LIMIT_VALUE(pCalibDb->DrcTuningPara.IIR_frame, IIRFRAMEMAX, IIRFRAMEMIN);
    pAdrcCtx->Config.Others.Tolerance = LIMIT_VALUE(pCalibDb->DrcTuningPara.Tolerance, IIRFRAMEMAX, IIRFRAMEMIN);
    pAdrcCtx->Config.Others.damp = LIMIT_VALUE(pCalibDb->DrcTuningPara.damp, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);


    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}
/******************************************************************************
 * AdrcDamping()
 *****************************************************************************/
void AdrcDamping
(
    CurrData_t* pCurrData,
    AdrcPrevData_t* pPreData,
    drc_OpMode_t opMode,
    int FrameCnt
)
{
    LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
    float Drc_damp = pCurrData->Others.damp;
    bool enDamp;
    bool ifHDRModeChange = pCurrData->frameCnt == pPreData->frameCnt ? false : true;

    if((opMode == DRC_OPMODE_API_OFF || opMode == DRC_OPMODE_AUTO) && FrameCnt != 0 && !ifHDRModeChange)
    {
        float diff = 0.0;

        diff = ABS(pCurrData->EnvLv - pPreData->EnvLv);
        diff = diff / pPreData->EnvLv;
        if (diff < pCurrData->Others.Tolerance)
            enDamp = false;
        else
            enDamp = true;

        //get finnal cfg data by damp
        if (enDamp) {
            pCurrData->HandleData.DrcGain = Drc_damp * pCurrData->HandleData.DrcGain
                                            + (1 - Drc_damp) * pPreData->HandleData.DrcGain;
            pCurrData->HandleData.Alpha = Drc_damp * pCurrData->HandleData.Alpha
                                          + (1 - Drc_damp) * pPreData->HandleData.Alpha;
            pCurrData->HandleData.Clip = Drc_damp * pCurrData->HandleData.Clip
                                         + (1 - Drc_damp) * pPreData->HandleData.Clip;
            pCurrData->HandleData.Strength = Drc_damp * pCurrData->HandleData.Strength
                                             + (1 - Drc_damp) * pPreData->HandleData.Strength;
            pCurrData->HandleData.LocalWeit = Drc_damp * pCurrData->HandleData.LocalWeit
                                              + (1 - Drc_damp) * pPreData->HandleData.LocalWeit;
            pCurrData->HandleData.GlobalContrast = Drc_damp * pCurrData->HandleData.GlobalContrast
                                                   + (1 - Drc_damp) * pPreData->HandleData.GlobalContrast;
            pCurrData->HandleData.LoLitContrast = Drc_damp * pCurrData->HandleData.LoLitContrast
                                                  + (1 - Drc_damp) * pPreData->HandleData.LoLitContrast;
        }


    }

    LOG1_ATMO("%s:Eixt!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcGetCurrProcRes()
 *****************************************************************************/
void AdrcGetCurrProcRes
(
    AdrcProcResData_t*           pAdrcProcRes,
    CurrData_t*          pCurrData,
    bool LongFrmMode,
    int FrameNumber,
    int FrameCnt,
    bool OutPutLongFrame
) {
    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    //enable
    if(FrameNumber == 2 || FrameNumber == 3) {
        pAdrcProcRes->bTmoEn = true;
        pAdrcProcRes->isLinearTmo = false;
    }
    else if(FrameNumber == 1) {
        pAdrcProcRes->bTmoEn = pCurrData->Enable;
        pAdrcProcRes->isLinearTmo = pAdrcProcRes->bTmoEn;

    }

    //Long Frame mode
    pAdrcProcRes->LongFrameMode = LongFrmMode;

    //Global tmo
    pAdrcProcRes->isHdrGlobalTmo = pCurrData->HandleData.LocalWeit == 0 ? true : false;

    //compress mode
    pAdrcProcRes->CompressMode = pCurrData->HandleData.Mode;

    //DrcProcRes
    pAdrcProcRes->DrcProcRes.sw_drc_offset_pow2 = SW_DRC_OFFSET_POW2_FIX;
    pAdrcProcRes->DrcProcRes.sw_drc_position = (int)(SHIFT8BIT(pCurrData->HandleData.Clip) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_hpdetail_ratio = (int)(SHIFT12BIT(pCurrData->HandleData.LoLitContrast) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_lpdetail_ratio = (int)(SHIFT12BIT(pCurrData->HandleData.GlobalContrast) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_weicur_pix = (int)(SHIFT8BIT(pCurrData->Others.curPixWeit) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_weipre_frame = (int)(SHIFT8BIT(pCurrData->Others.preFrameWeit) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_weipre_frame = LIMIT_VALUE(pAdrcProcRes->DrcProcRes.sw_drc_weipre_frame, 255, 0);
    pAdrcProcRes->DrcProcRes.sw_drc_force_sgm_inv0 = (int)(SHIFT13BIT(pCurrData->Others.Range_force_sgm) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_edge_scl = (int)(SHIFT8BIT(pCurrData->Others.Edge_Weit) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_motion_scl = SW_DRC_MOTION_SCL_FIX;
    pAdrcProcRes->DrcProcRes.sw_drc_space_sgm_inv1 = (int)(pCurrData->Others.Space_sgm_cur);
    pAdrcProcRes->DrcProcRes.sw_drc_space_sgm_inv0 = (int)(pCurrData->Others.Space_sgm_pre);
    pAdrcProcRes->DrcProcRes.sw_drc_range_sgm_inv1 = (int)(SHIFT13BIT(pCurrData->Others.Range_sgm_cur) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_range_sgm_inv0 = (int)(SHIFT13BIT(pCurrData->Others.Range_sgm_pre) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_weig_maxl = (int)(SHIFT4BIT(pCurrData->HandleData.Strength) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_adrc_gain = pCurrData->HandleData.DrcGain;
    pAdrcProcRes->DrcProcRes.sw_drc_weig_bilat = (int)(SHIFT4BIT(pCurrData->HandleData.LocalWeit) + 0.5);
    pAdrcProcRes->DrcProcRes.sw_drc_min_ogain = OutPutLongFrame ? 1 : 0;
    for(int i = 0; i < ADRC_Y_NUM; ++i) {
        pAdrcProcRes->DrcProcRes.sw_drc_scale_y[i] = (int)(pCurrData->Others.Scale_y[i]) ;
        pAdrcProcRes->DrcProcRes.sw_drc_compres_y[i] = pCurrData->HandleData.Manual_curve[i] ;
    }

    //get sw_drc_gain_y
    CalibrateDrcGainY(&pAdrcProcRes->DrcProcRes, pAdrcProcRes->DrcProcRes.sw_drc_adrc_gain, pCurrData->HandleData.Alpha) ;

    float iir_frame = (float)(MIN(FrameCnt + 1, pCurrData->Others.IIR_frame));
    pAdrcProcRes->DrcProcRes.sw_drc_iir_weight = (int)(SHIFT6BIT((iir_frame - 1) / iir_frame) + 0.5);

    pAdrcProcRes->DrcProcRes.sw_drc_compres_scl =  20000.0;

    //sw_drc_delta_scalein FIX
    int ISP_RAW_BIT = 12;
    int MFHDR_LOG_Q_BITS = 11;
    int dstbits = ISP_RAW_BIT << MFHDR_LOG_Q_BITS;
    int offsetbits_int = SW_DRC_OFFSET_POW2_FIX;
    int offsetbits = offsetbits_int << MFHDR_LOG_Q_BITS;
    int validbits = dstbits - offsetbits;
    int delta_scalein = (256 << MFHDR_LOG_Q_BITS) / validbits;
    pAdrcProcRes->DrcProcRes.sw_drc_delta_scalein = delta_scalein;


    LOGD_ATMO("%s:Current damp Enable:%d DrcGain:%f Alpha:%f Clip:%f Strength:%f LocalWeit:%f GlobalContrast:%f LoLitContrast:%f CompressMode:%d\n", __FUNCTION__, pAdrcProcRes->bTmoEn,
              pCurrData->HandleData.DrcGain, pCurrData->HandleData.Alpha, pCurrData->HandleData.Clip, pCurrData->HandleData.Strength,
              pCurrData->HandleData.LocalWeit, pCurrData->HandleData.GlobalContrast, pCurrData->HandleData.LoLitContrast, pCurrData->HandleData.Mode);

    LOGV_ATMO("%s:  sw_drc_adrc_gain:%f Alpha:%f\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_adrc_gain, pCurrData->HandleData.Alpha);
    LOGV_ATMO("%s:  sw_drc_offset_pow2:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_offset_pow2);
    LOGV_ATMO("%s:  sw_drc_compres_scl:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_compres_scl);
    LOGV_ATMO("%s:  sw_drc_position:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_position);
    LOGV_ATMO("%s:  sw_drc_delta_scalein:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_delta_scalein);
    LOGV_ATMO("%s:  sw_drc_hpdetail_ratio:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_hpdetail_ratio);
    LOGV_ATMO("%s:  sw_drc_lpdetail_ratio:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_lpdetail_ratio);
    LOGV_ATMO("%s:  sw_drc_weicur_pix:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_weicur_pix);
    LOGV_ATMO("%s:  sw_drc_weipre_frame:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_weipre_frame);
    LOGV_ATMO("%s:  sw_drc_force_sgm_inv0:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_force_sgm_inv0);
    LOGV_ATMO("%s:  sw_drc_edge_scl:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_edge_scl);
    LOGV_ATMO("%s:  sw_drc_space_sgm_inv1:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_space_sgm_inv1);
    LOGV_ATMO("%s:  sw_drc_space_sgm_inv0:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_space_sgm_inv0);
    LOGV_ATMO("%s:  sw_drc_range_sgm_inv1:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_range_sgm_inv1);
    LOGV_ATMO("%s:  sw_drc_range_sgm_inv0:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_range_sgm_inv0);
    LOGV_ATMO("%s:  sw_drc_weig_maxl:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_weig_maxl);
    LOGV_ATMO("%s:  sw_drc_weig_bilat:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_weig_bilat);
    LOGV_ATMO("%s:  sw_drc_adrc_gain:%f\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_adrc_gain);
    LOGV_ATMO("%s:  sw_drc_iir_weight:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_iir_weight);
    LOGV_ATMO("%s:  sw_drc_min_ogain:%d\n", __FUNCTION__, pAdrcProcRes->DrcProcRes.sw_drc_min_ogain);
    for(int i = 0; i < 17; i++)
        LOGV_ATMO("%s:  sw_drc_gain_y[%d]:%d\n", __FUNCTION__, i, pAdrcProcRes->DrcProcRes.sw_drc_gain_y[i]);

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcGetCurrData()
 *****************************************************************************/
void AdrcGetCurrData
(
    AdrcHandle_t pAdrcCtx
) {

    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);

    //damp
    AdrcDamping(&pAdrcCtx->CurrData, &pAdrcCtx->PrevData, pAdrcCtx->drcAttr.opMode, pAdrcCtx->frameCnt);

    //get io data
    AdrcGetCurrProcRes(&pAdrcCtx->AdrcProcRes, &pAdrcCtx->CurrData, pAdrcCtx->SensorInfo.LongFrmMode,
                       pAdrcCtx->FrameNumber, pAdrcCtx->frameCnt, pAdrcCtx->Config.OutPutLongFrame);

    // store current handle data to pre data for next loop
    pAdrcCtx->PrevData.EnvLv = pAdrcCtx->CurrData.EnvLv;
    pAdrcCtx->PrevData.ISO = pAdrcCtx->CurrData.ISO;
    if(0 != memcmp(&pAdrcCtx->PrevData.HandleData, &pAdrcCtx->CurrData.HandleData, sizeof(DrcHandleData_t)))
        memcpy(&pAdrcCtx->PrevData.HandleData, &pAdrcCtx->CurrData.HandleData, sizeof(DrcHandleData_t));
    ++pAdrcCtx->frameCnt;

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcProcessing()
 *get handle para by config and current variate
 *****************************************************************************/
void AdrcProcessing
(
    AdrcHandle_t     pAdrcCtx
)
{
    LOG1_ATMO("%s:enter!\n", __FUNCTION__);
    pAdrcCtx->CurrData.frameCnt = pAdrcCtx->frameCnt;

    //enable setting
    if(pAdrcCtx->drcAttr.Enable)
        pAdrcCtx->CurrData.Enable = true;
    else
        pAdrcCtx->CurrData.Enable = pAdrcCtx->Config.Enable;

    //para setting
    AdrcIQUpdate(pAdrcCtx);

    //api
    if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_API_OFF)
        LOGD_ATMO("%s:  Adrc api OFF!! Current Handle data:\n", __FUNCTION__);
    else if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_MANU) {
        LOGD_ATMO("%s:  Adrc api Manual!! Current Handle data:\n", __FUNCTION__);
        AdrcApiManualUpdate(&pAdrcCtx->CurrData, &pAdrcCtx->drcAttr.stManual);
    } else if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_AUTO)
        LOGD_ATMO("%s:  Adrc api ATUO!! Current Handle data:\n", __FUNCTION__);
    else if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_DRC_GAIN) {
        LOGD_ATMO("%s:  Adrc api GDRC Gain!! Current Handle data:\n", __FUNCTION__);
        pAdrcCtx->CurrData.HandleData.DrcGain = pAdrcCtx->drcAttr.stManual.DrcGain.DrcGain;
        pAdrcCtx->CurrData.HandleData.Alpha = pAdrcCtx->drcAttr.stManual.DrcGain.Alpha;
        pAdrcCtx->CurrData.HandleData.Clip = pAdrcCtx->drcAttr.stManual.DrcGain.Clip;
    }
    else if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_HILIT) {
        LOGD_ATMO("%s:  Adrc api HiLit!! Current Handle data:\n", __FUNCTION__);
        pAdrcCtx->CurrData.HandleData.Strength = pAdrcCtx->drcAttr.stManual.HiLit.Strength;
    }
    else if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_LOCAL_TMO) {
        LOGD_ATMO("%s:  Adrc api Local TMO!! Current Handle data:\n", __FUNCTION__);
        pAdrcCtx->CurrData.HandleData.LocalWeit = pAdrcCtx->drcAttr.stManual.Local.LocalWeit;
        pAdrcCtx->CurrData.HandleData.GlobalContrast = pAdrcCtx->drcAttr.stManual.Local.GlobalContrast;
        pAdrcCtx->CurrData.HandleData.LoLitContrast = pAdrcCtx->drcAttr.stManual.Local.LoLitContrast;
    }
    else if(pAdrcCtx->drcAttr.opMode == DRC_OPMODE_COMPRESS) {
        LOGD_ATMO("%s:  Adrc api Compress!! Current Handle data:\n", __FUNCTION__);
        pAdrcCtx->CurrData.HandleData.Mode = pAdrcCtx->drcAttr.stManual.Compress.Mode;
        for(int i = 0; i < ADRC_Y_NUM; i++)
            pAdrcCtx->CurrData.HandleData.Manual_curve[i] = pAdrcCtx->drcAttr.stManual.Compress.Manual_curve[i];
    }
    else
        LOGE_ATMO("%s:  Adrc wrong mode!!!\n", __FUNCTION__);

    //clip drc gain
    if(pAdrcCtx->CurrAeResult.AEMaxRatio * pAdrcCtx->CurrData.HandleData.DrcGain > MAX_AE_DRC_GAIN) {
        LOGE_ATMO("%s:  AERatio*DrcGain > 256!!!\n", __FUNCTION__);
        pAdrcCtx->CurrData.HandleData.DrcGain = MAX_AE_DRC_GAIN / pAdrcCtx->CurrAeResult.AEMaxRatio;
    }

    LOGD_ATMO("%s:Current Enable:%d DrcGain:%f Alpha:%f Clip:%f Strength:%f LocalWeit:%f GlobalContrast:%f LoLitContrast:%f CompressMode:%d\n", __FUNCTION__, pAdrcCtx->CurrData.Enable,
              pAdrcCtx->CurrData.HandleData.DrcGain, pAdrcCtx->CurrData.HandleData.Alpha, pAdrcCtx->CurrData.HandleData.Clip, pAdrcCtx->CurrData.HandleData.Strength,
              pAdrcCtx->CurrData.HandleData.LocalWeit, pAdrcCtx->CurrData.HandleData.GlobalContrast, pAdrcCtx->CurrData.HandleData.LoLitContrast
              , pAdrcCtx->CurrData.HandleData.Mode);

    //transfer data to api
    AdrcTranferData2Api(pAdrcCtx);

    //get io and store data in proc res
    AdrcGetCurrData(pAdrcCtx);

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
}

/******************************************************************************
 * AdrcByPassProcessing()
 *get handle para by config and current variate
 *****************************************************************************/
bool AdrcByPassProcessing
(
    AdrcHandle_t     pAdrcCtx,
    AecPreResult_t  AecHdrPreResult
)
{
    LOG1_ATMO("%s:enter!\n", __FUNCTION__);

    bool bypass = false;
    float diff = 0.0;

    if(pAdrcCtx->frameCnt <= 2)//start frame
        bypass = false;
    else if(pAdrcCtx->drcAttr.opMode > DRC_OPMODE_API_OFF)//api
        bypass = false;
    else if(pAdrcCtx->drcAttr.opMode !=  pAdrcCtx->PrevData.ApiMode)//api change
        bypass = false;
    else { //EnvLv change
        //get current ae data from AecPreRes
        AdrcGetAeResult(pAdrcCtx, AecHdrPreResult);

        //transfer ae data to CurrHandle
        pAdrcCtx->CurrData.EnvLv = LIMIT_VALUE(pAdrcCtx->CurrData.EnvLv, ADRCNORMALIZEMAX, ADRCNORMALIZEMIN);

        pAdrcCtx->CurrData.ISO = pAdrcCtx->CurrAeResult.ISO;
        pAdrcCtx->CurrData.ISO = LIMIT_VALUE(pAdrcCtx->CurrData.ISO, ISOMAX, ISOMIN);

        //use Envlv for now
        diff = pAdrcCtx->PrevData.EnvLv - pAdrcCtx->CurrData.EnvLv;
        if(pAdrcCtx->PrevData.EnvLv == 0.0) {
            diff = pAdrcCtx->CurrData.EnvLv;
            if(diff == 0.0)
                bypass = true;
            else
                bypass = false;
        }
        else {
            diff /= pAdrcCtx->PrevData.EnvLv;
            if(diff >= pAdrcCtx->Config.Others.ByPassThr || diff <= (0 - pAdrcCtx->Config.Others.ByPassThr))
                bypass = false;
            else
                bypass = true;
        }
    }

    LOG1_ATMO( "%s:CtrlEnvLv:%f PrevEnvLv:%f diff:%f ByPassThr:%f opMode:%d bypass:%d!\n", __FUNCTION__, pAdrcCtx->CurrData.EnvLv,
               pAdrcCtx->PrevData.EnvLv, diff, pAdrcCtx->Config.Others.ByPassThr, pAdrcCtx->drcAttr.opMode, bypass);

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);
    return bypass;
}

/******************************************************************************
 * AdrcInit()
 *****************************************************************************/
XCamReturn AdrcInit
(
    AdrcInstanceConfig_t* pInstConfig,
    CamCalibDbV2Context_t* calibv2
) {

    AdrcContext_s *pAdrcCtx;

    LOG1_ATMO("%s:enter!\n", __FUNCTION__);

    XCamReturn result = XCAM_RETURN_NO_ERROR;

    // initial checks
    if (pInstConfig == NULL)
        return (XCAM_RETURN_ERROR_PARAM);

    // allocate Adrc control context
    pAdrcCtx = (AdrcContext_s*)calloc(sizeof(AdrcContext_t), 1);
    if (NULL == pAdrcCtx) {
        LOGE_ATMO( "%s: Can't allocate Adrc context\n",  __FUNCTION__);
        return (XCAM_RETURN_ERROR_OUTOFRANGE);
    }

    CalibDbV2_drc_t* calibv2_adrc_calib =
        (CalibDbV2_drc_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, adrc_calib));

    // pre-initialize context
    memset(pAdrcCtx, 0x00, sizeof(*pAdrcCtx));

    //malloc DrcGain
    pAdrcCtx->Config.DrcGain.len = calibv2_adrc_calib->DrcTuningPara.DrcGain.EnvLv_len;
    pAdrcCtx->Config.DrcGain.EnvLv = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.DrcGain.EnvLv_len));
    pAdrcCtx->Config.DrcGain.DrcGain = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.DrcGain.EnvLv_len));
    pAdrcCtx->Config.DrcGain.Alpha = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.DrcGain.EnvLv_len));
    pAdrcCtx->Config.DrcGain.Clip = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.DrcGain.EnvLv_len));

    //malloc HiLit
    pAdrcCtx->Config.HiLit.len = calibv2_adrc_calib->DrcTuningPara.HiLight.EnvLv_len;
    pAdrcCtx->Config.HiLit.EnvLv = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.HiLight.EnvLv_len));
    pAdrcCtx->Config.HiLit.Strength = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.HiLight.EnvLv_len));

    //malloc local
    pAdrcCtx->Config.Local.len = calibv2_adrc_calib->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len;
    pAdrcCtx->Config.Local.EnvLv = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
    pAdrcCtx->Config.Local.LocalWeit = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
    pAdrcCtx->Config.Local.GlobalContrast = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
    pAdrcCtx->Config.Local.LoLitContrast = (float*)malloc(sizeof(float) * (calibv2_adrc_calib->DrcTuningPara.LocalTMOSetting.LocalTMOData.EnvLv_len));
    pAdrcCtx->drcAttr.Enable = false;
    pAdrcCtx->drcAttr.opMode = DRC_OPMODE_API_OFF;
    pAdrcCtx->frameCnt = 0;
    Config(pAdrcCtx); //set default para
    memcpy(&pAdrcCtx->pCalibDB, calibv2_adrc_calib, sizeof(CalibDbV2_drc_t));//load iq paras
    //memcpy(&pAdrcCtx->drcAttr.stAuto, calibv2_adrc_calib, sizeof(CalibDbV2_drc_t));//load iq paras to stTool

    pAdrcCtx->state = ADRC_STATE_INITIALIZED;

    pInstConfig->hAdrc = (AdrcHandle_t)pAdrcCtx;

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);

    return (XCAM_RETURN_NO_ERROR);
}
/******************************************************************************
 * AhdrRelease()
 *****************************************************************************/
XCamReturn AdrcRelease
(
    AdrcHandle_t pAdrcCtx
) {

    LOG1_ATMO( "%s:enter!\n", __FUNCTION__);
    XCamReturn result = XCAM_RETURN_NO_ERROR;

    // initial checks
    if (NULL == pAdrcCtx) {
        return (XCAM_RETURN_ERROR_PARAM);
    }

    result = AdrcStop(pAdrcCtx);
    if (result != XCAM_RETURN_NO_ERROR) {
        LOGE_ATMO( "%s: AHDRStop() failed!\n", __FUNCTION__);
        return (result);
    }

    // check state
    if ((ADRC_STATE_RUNNING == pAdrcCtx->state)
            || (ADRC_STATE_LOCKED == pAdrcCtx->state)) {
        return (XCAM_RETURN_ERROR_MEM);
    }

    free(pAdrcCtx->Config.DrcGain.EnvLv);
    free(pAdrcCtx->Config.DrcGain.DrcGain);
    free(pAdrcCtx->Config.DrcGain.Alpha);
    free(pAdrcCtx->Config.DrcGain.Clip);
    free(pAdrcCtx->Config.HiLit.EnvLv);
    free(pAdrcCtx->Config.HiLit.Strength);
    free(pAdrcCtx->Config.Local.EnvLv);
    free(pAdrcCtx->Config.Local.LocalWeit);
    free(pAdrcCtx->Config.Local.GlobalContrast);
    free(pAdrcCtx->Config.Local.LoLitContrast);
    memset(pAdrcCtx, 0, sizeof(AdrcContext_t));
    free(pAdrcCtx);
    pAdrcCtx = NULL;

    LOG1_ATMO( "%s:exit!\n", __FUNCTION__);

    return (XCAM_RETURN_NO_ERROR);
}