/*
 *  Copyright (c) 2021 Rockchip Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include "rk_aiq_user_api2_custom_ae.h"
#include "RkAiqCalibDbV2Helper.h"

#ifdef RK_SIMULATOR_HW
#define CHECK_USER_API_ENABLE
#endif

RKAIQ_BEGIN_DECLARE

#define RKISP_ALGO_AE_DEMO_VERSION     "v0.0.1"
#define RKISP_ALGO_AE_DEMO_VENDOR      "Rockchip"
#define RKISP_ALGO_AE_DEMO_DESCRIPTION "Rockchip Custom Ae"

typedef struct rk_aiq_rkAe_config_s {
    int Working_mode;//values look up in rk_aiq_working_mode_t definiton
    int RawWidth;
    int RawHeight;
    CalibDb_Sensor_ParaV2_t stSensorInfo;
    RkAiqAecHwConfig_t    aeHwConfig;

    rk_aiq_sensor_nr_switch_t stNRswitch; //get from sensor
    float        LinePeriodsPerField; //get from sensor
    float        PixelClockFreqMHZ; //get from sensor
    float        PixelPeriodsPerLine; //get from sensor

    float last_fps;
    float init_fps;
    float last_vts;

    float vts_request;
    float fps_request;
    bool update_fps;

    uint8_t HdrFrmNum;
    bool IsHdr;
} rk_aiq_rkAe_config_t;

/* instance was created by AIQ framework when rk_aiq_uapi_sysctl_regLib called */
typedef struct _RkAiqAlgoContext {
    rk_aiq_customeAe_cbs_t cbs; // set by register
    union {
        rk_aiq_sys_ctx_t* aiq_ctx;  // set by register
        rk_aiq_camgroup_ctx_t* group_ctx;  // set by register
    };
    rk_aiq_rkAe_config_t rkCfg; // ae config of AIQ framework
    rk_aiq_customeAe_results_t customRes; // result of pfn_ae_run
    bool cutomAeInit;
    bool updateCalib;
    int camIdArray[6];
    int camIdArrayLen;
    bool isGroupMode;
} RkAiqAlgoContext;

/******************************************************************************
 * AeReg2RealConv()
 *****************************************************************************/
static XCamReturn AeReg2RealConv
(
    rk_aiq_rkAe_config_t* pConfig,
    int sensorGain,
    int sensorInttime,
    int sensorDcgmode,
    float& realGain,
    float& realInttime
) {

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    //gain
    if(pConfig->stSensorInfo.Gain2Reg.GainMode == EXPGAIN_MODE_LINEAR) {
        float gainRange[] = {1, 2, 128, 0, 1, 128, 255,
                             2, 4, 64, -248, 1, 376, 504,
                             4, 8, 32, -756, 1, 884, 1012,
                             8, 16, 16, -1784, 1, 1912, 2040
                            };

        float* pgainrange = NULL;
        uint32_t size = 0;

        if (pConfig->stSensorInfo.Gain2Reg.GainRange_len <= 0) {
            pgainrange = gainRange;
            size = sizeof(gainRange) / sizeof(float);
        } else {
            pgainrange = pConfig->stSensorInfo.Gain2Reg.GainRange;
            size = pConfig->stSensorInfo.Gain2Reg.GainRange_len;
        }

        int *revert_gain_array = (int *)malloc((size / 7 * 2) * sizeof(int));
        if(revert_gain_array == NULL) {
            LOGE_AEC("%s: malloc fail", __func__);
            return  XCAM_RETURN_ERROR_MEM;
        }

        for(uint32_t i = 0; i < (size / 7); i++) {
            revert_gain_array[i * 2 + 0] = (int)(pgainrange[i * 7 + 2] * pow(pgainrange[i * 7 + 0], pgainrange[i * 7 + 4]) - pgainrange[i * 7 + 3] + 0.5f);
            revert_gain_array[i * 2 + 1] = (int)(pgainrange[i * 7 + 2] * pow(pgainrange[i * 7 + 1], pgainrange[i * 7 + 4]) - pgainrange[i * 7 + 3] + 0.5f);
        }

        // AG = (C1 * (analog gain^M0) - C0) + 0.5f
        float C1 = 0.0f, C0 = 0.0f, M0 = 0.0f, minReg = 0.0f, maxReg = 0.0f, minrealGain = 0.0f, maxrealGain = 0.0f;
        float ag = sensorGain;
        uint32_t i = 0;
        for(i = 0; i < (size / 7); i++) {
            if (ag >= revert_gain_array[i * 2 + 0] && ag <= revert_gain_array[i * 2 + 1]) {
                C1 = pgainrange[i * 7 + 2];
                C0 = pgainrange[i * 7 + 3];
                M0 = pgainrange[i * 7 + 4];
                minReg = pgainrange[i * 7 + 5];
                maxReg = pgainrange[i * 7 + 6];
                break;
            }
        }

        if(i > (size / 7)) {
            LOGE_AEC_SUBM(0xff, "GAIN OUT OF RANGE: lasttime-gain: %d-%d", sensorInttime, sensorGain);
            C1 = 16;
            C0 = 0;
            M0 = 1;
            minReg = 16;
            maxReg = 255;
        }

        realGain = pow(10, log10(((float)sensorGain + C0) / C1) / M0);
        minrealGain = pow(10, log10(((float)minReg + C0) / C1) / M0);
        maxrealGain = pow(10, log10(((float)maxReg + C0) / C1) / M0);

        if (realGain < minrealGain)
            realGain = minrealGain;
        if (realGain > maxrealGain)
            realGain = maxrealGain;

        if(revert_gain_array != NULL) {
            free(revert_gain_array);
            revert_gain_array = NULL;
        }
    } else if(pConfig->stSensorInfo.Gain2Reg.GainMode == EXPGAIN_MODE_NONLINEAR_DB) {
        realGain = pow(10, (float)sensorGain * 3 / (10.0f * 20.0f));
    }

    float dcg_ratio = (sensorDcgmode >= 1 ? pConfig->stSensorInfo.CISDcgSet.Linear.dcg_ratio : 1.0f);

    realGain *= dcg_ratio;

    //time
    float timeC0 = pConfig->stSensorInfo.Time2Reg.fCoeff[0];
    float timeC1 = pConfig->stSensorInfo.Time2Reg.fCoeff[1];
    float timeC2 = pConfig->stSensorInfo.Time2Reg.fCoeff[2];
    float timeC3 = pConfig->stSensorInfo.Time2Reg.fCoeff[3];

    realInttime = ((sensorInttime - timeC0 * pConfig->LinePeriodsPerField - timeC1) / timeC2 /*- timeC3*/) *
                  pConfig->PixelPeriodsPerLine / (pConfig->PixelClockFreqMHZ * 1000000);

    return (ret);
}

/******************************************************************************
 * AeReal2RegConv()
 *****************************************************************************/
static XCamReturn AeReal2RegConv
(
    rk_aiq_rkAe_config_t* pConfig,
    float SplitIntegrationTime,
    float SplitGain,
    unsigned int *regIntegrationTime,
    unsigned int *regGain,
    int *pDcgMode
) {
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    float dcg_ratio = 0.0f;
    float CISTimeRegOdevity[2] = {0};
    unsigned int CISTimeRegMin = 0;

    if(pConfig->IsHdr) {
        dcg_ratio = pConfig->stSensorInfo.CISDcgSet.Hdr.dcg_ratio;
        CISTimeRegMin = pConfig->stSensorInfo.CISTimeSet.Hdr[pConfig->HdrFrmNum - 2].CISTimeRegMin;
        CISTimeRegOdevity[0] = pConfig->stSensorInfo.CISTimeSet.Hdr[pConfig->HdrFrmNum - 2].CISTimeRegOdevity.fCoeff[0];
        CISTimeRegOdevity[1] = pConfig->stSensorInfo.CISTimeSet.Hdr[pConfig->HdrFrmNum - 2].CISTimeRegOdevity.fCoeff[1];
    } else {
        dcg_ratio = pConfig->stSensorInfo.CISDcgSet.Linear.dcg_ratio;
        CISTimeRegMin = pConfig->stSensorInfo.CISTimeSet.Linear.CISTimeRegMin;
        CISTimeRegOdevity[0] = pConfig->stSensorInfo.CISTimeSet.Linear.CISTimeRegOdevity.fCoeff[0];
        CISTimeRegOdevity[1] = pConfig->stSensorInfo.CISTimeSet.Linear.CISTimeRegOdevity.fCoeff[1];
    }


    //gain convertion
    float ag = SplitGain / (pDcgMode[AEC_NORMAL_FRAME] >= 1 ? dcg_ratio : 1.0f);

    if(pConfig->stSensorInfo.Gain2Reg.GainMode == EXPGAIN_MODE_LINEAR) {

        float C1 = 0.0f, C0 = 0.0f, M0 = 0.0f, minReg = 0.0f, maxReg = 0.0f, ag = 0.0f;

        for (int i = 0; i < pConfig->stSensorInfo.Gain2Reg.GainRange_len; i += 7) {
            if (ag >= pConfig->stSensorInfo.Gain2Reg.GainRange[i] && ag <= pConfig->stSensorInfo.Gain2Reg.GainRange[i + 1]) {
                C1 = pConfig->stSensorInfo.Gain2Reg.GainRange[i + 2];
                C0 = pConfig->stSensorInfo.Gain2Reg.GainRange[i + 3];
                M0 = pConfig->stSensorInfo.Gain2Reg.GainRange[i + 4];
                minReg = pConfig->stSensorInfo.Gain2Reg.GainRange[i + 5];
                maxReg = pConfig->stSensorInfo.Gain2Reg.GainRange[i + 6];
                break;
            }
        }

        if (C1 == 0.0f) {
            LOGE_AEC_SUBM(0xff, "GAIN OUT OF RANGE: lasttime-gain: %f-%f", SplitIntegrationTime, SplitGain);
            C1 = 16;
            C0 = 0;
            M0 = 1;
            minReg = 16;
            maxReg = 255;
        }


        LOGV_AEC_SUBM(0xff, "ag: %2.2f, C1: %2.2f  C0: %2.2f M0: %2.2f, minReg: %2.2f maxReg: %2.2f",
                      ag, C1, C0, M0, minReg, maxReg);

        *regGain = (int)(C1 * pow(ag, M0) - C0 + 0.5f);
        if (*regGain < minReg)
            *regGain = minReg;
        if (*regGain > maxReg)
            *regGain = maxReg;

    } else if(pConfig->stSensorInfo.Gain2Reg.GainMode == EXPGAIN_MODE_NONLINEAR_DB) {
        *regGain = (int)(20.0f * log10(ag) * 10.0f / 3.0f + 0.5f);
    }

    //time convertion
    float timeC0 = pConfig->stSensorInfo.Time2Reg.fCoeff[0];
    float timeC1 = pConfig->stSensorInfo.Time2Reg.fCoeff[1];
    float timeC2 = pConfig->stSensorInfo.Time2Reg.fCoeff[2];
    float timeC3 = pConfig->stSensorInfo.Time2Reg.fCoeff[3];
    LOGV_AEC_SUBM(0xff, "time coefficient: %f-%f-%f-%f", timeC0, timeC1, timeC2, timeC3);

    float pclk = pConfig->PixelClockFreqMHZ;
    float hts = pConfig->PixelPeriodsPerLine;
    float vts = pConfig->LinePeriodsPerField;

    *regIntegrationTime = (int)(timeC0 * vts + timeC1 + timeC2 * ((SplitIntegrationTime * pclk * 1000000 / hts) + timeC3));

    int Index = (*regIntegrationTime - CISTimeRegOdevity[1]) / (CISTimeRegOdevity[0]);
    *regIntegrationTime = CISTimeRegOdevity[0] * Index + CISTimeRegOdevity[1];
    *regIntegrationTime = MAX(*regIntegrationTime, CISTimeRegMin);
    return (ret);
}

/******************************************************************************
 * AeDcgConv
 *****************************************************************************/
static XCamReturn AeDcgConv
(
    rk_aiq_rkAe_config_t*  pConfig,
    float                  Gain,
    int*                   pDcgMode
) {
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    LOG1_AEC_SUBM(0xff, "%s:(enter)\n", __FUNCTION__);

    //pointer check
    if (pConfig == NULL) {
        LOGE_AEC_SUBM(0xff, "%s: pConfig NULL pointer! \n", __FUNCTION__);
        return (XCAM_RETURN_ERROR_FAILED);
    }

    if(!pConfig->stSensorInfo.CISDcgSet.Linear.support_en) {
        *pDcgMode = -1;
        return XCAM_RETURN_NO_ERROR;
    }

    if(pConfig->stSensorInfo.CISDcgSet.Linear.dcg_optype <= RK_AIQ_OP_MODE_AUTO) {

        if(Gain >= pConfig->stSensorInfo.CISDcgSet.Linear.lcg2hcg_gain_th) {
            *pDcgMode = 1;
        } else if(Gain < pConfig->stSensorInfo.CISDcgSet.Linear.hcg2lcg_gain_th) {
            *pDcgMode = 0;
        }

        LOG1_AEC_SUBM(0xff, "gain=%f,dcg_mode=[%d]", Gain, *pDcgMode);
    } else {
        *pDcgMode = pConfig->stSensorInfo.CISDcgSet.Linear.dcg_mode.Coeff[0];
    }

    LOG1_AEC_SUBM(0xff, "%s: (exit)\n", __FUNCTION__);
    return (ret);
}

/******************************************************************************
 * AeHdrDcgConv
 *****************************************************************************/
static XCamReturn AeHdrDcgConv
(
    rk_aiq_rkAe_config_t*  pConfig,
    RkAiqExpParamComb_t*   pHdrExp
) {
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    LOG1_AEC_SUBM(0xff, "%s:(enter)\n", __FUNCTION__);

    //pointer check
    if (pConfig == NULL) {
        LOGE_AEC_SUBM(0xff, "%s: pConfig NULL pointer! \n", __FUNCTION__);
        return (XCAM_RETURN_ERROR_FAILED);
    }

    if(!pConfig->stSensorInfo.CISDcgSet.Linear.support_en) {
        pHdrExp[0].exp_real_params.dcg_mode = -1;
        pHdrExp[1].exp_real_params.dcg_mode = -1;
        pHdrExp[2].exp_real_params.dcg_mode = -1;
        return XCAM_RETURN_NO_ERROR;
    }

    if(pConfig->stSensorInfo.CISDcgSet.Hdr.dcg_optype <= RK_AIQ_OP_MODE_AUTO) {

        if(pHdrExp[pConfig->HdrFrmNum - 1].exp_real_params.analog_gain >= pConfig->stSensorInfo.CISDcgSet.Hdr.lcg2hcg_gain_th)
            pHdrExp[pConfig->HdrFrmNum - 1].exp_real_params.dcg_mode = 1;
        else if(pHdrExp[pConfig->HdrFrmNum - 1].exp_real_params.analog_gain < pConfig->stSensorInfo.CISDcgSet.Hdr.hcg2lcg_gain_th)
            pHdrExp[pConfig->HdrFrmNum - 1].exp_real_params.dcg_mode = 0;

        if(pConfig->stSensorInfo.CISDcgSet.Hdr.sync_switch) {
            if(pHdrExp[pConfig->HdrFrmNum - 1].exp_real_params.dcg_mode == 1 && \
                    pHdrExp[0].exp_real_params.analog_gain < pConfig->stSensorInfo.CISGainSet.CISExtraAgainRange.Min) {

                if(pHdrExp[0].exp_real_params.analog_gain >= pConfig->stSensorInfo.CISDcgSet.Hdr.lcg2hcg_gain_th)
                    pHdrExp[0].exp_real_params.dcg_mode = 1;
                else if(pHdrExp[0].exp_real_params.analog_gain < pConfig->stSensorInfo.CISDcgSet.Hdr.hcg2lcg_gain_th)
                    pHdrExp[0].exp_real_params.dcg_mode = 0;

                pHdrExp[1].exp_real_params.dcg_mode = pHdrExp[0].exp_real_params.dcg_mode;
                pHdrExp[2].exp_real_params.dcg_mode = pHdrExp[0].exp_real_params.dcg_mode;

            } else {
                for(int i = 0; i < pConfig->HdrFrmNum - 1; i++)
                    pHdrExp[i].exp_real_params.dcg_mode = pHdrExp[pConfig->HdrFrmNum - 1].exp_real_params.dcg_mode;

            }
        } else {
            for(int i = 0; i < pConfig->HdrFrmNum - 1; i++) {
                if(pHdrExp[i].exp_real_params.analog_gain >= pConfig->stSensorInfo.CISDcgSet.Hdr.lcg2hcg_gain_th)
                    pHdrExp[i].exp_real_params.dcg_mode = 1;
                else if(pHdrExp[i].exp_real_params.analog_gain < pConfig->stSensorInfo.CISDcgSet.Hdr.hcg2lcg_gain_th)
                    pHdrExp[i].exp_real_params.dcg_mode = 0;
            }
        }

    } else {
        pHdrExp[0].exp_real_params.dcg_mode = pConfig->stSensorInfo.CISDcgSet.Hdr.dcg_mode.Coeff[0];
        pHdrExp[1].exp_real_params.dcg_mode = pConfig->stSensorInfo.CISDcgSet.Hdr.dcg_mode.Coeff[1];
        pHdrExp[2].exp_real_params.dcg_mode = pConfig->stSensorInfo.CISDcgSet.Hdr.dcg_mode.Coeff[2];
    }
    LOG1_AEC_SUBM(0xff, "%s: (exit)\n", __FUNCTION__);
    return (ret);
}

/******************************************************************************
* AeGridWeight15x15to5x5()
*****************************************************************************/
static void AeGridWeight15x15to5x5
(
    unsigned char*  inWeights,
    unsigned char*  outWeights
)
{

    uint8_t line_5x5, col_5x5;
    uint8_t line_15x15, col_15x15;
    int i, j, k;

    int SumWeight[RAWAELITE_WIN_NUM] = {0};

    for(int i = 0; i < 225; i++) {
        line_15x15 = i / 15;
        col_15x15 = i % 15;

        line_5x5 = line_15x15 / 3;
        col_5x5 = col_15x15 / 3;

        SumWeight[line_5x5 * 5 + col_5x5] += inWeights[line_15x15 * 15 + col_15x15];
    }

    for(int i = 0; i < 25; i++)
        outWeights[i] = SumWeight[i] / 9;

    /*for (int i = 0; i<5; i++){
           printf("%2d %2d %2d %2d %2d\n",
             outWeights[i * 5 + 0], outWeights[i * 5 + 1], outWeights[i * 5 + 2], outWeights[i * 5 + 3], outWeights[i * 5 + 4]);
    }*/

}

static void AeCISFeature
(
    rk_aiq_rkAe_config_t* pConfig,
    RKAiqAecExpInfo_t* rkAeExp
) {
    int dcg_mode;
    float gain;

    if(pConfig->IsHdr) {
        dcg_mode = rkAeExp->HdrExp[pConfig->HdrFrmNum - 1].exp_real_params.dcg_mode;
        gain = rkAeExp->HdrExp[pConfig->HdrFrmNum - 1].exp_real_params.analog_gain;
    } else {
        dcg_mode = rkAeExp->LinearExp.exp_real_params.dcg_mode;
        gain = rkAeExp->LinearExp.exp_real_params.analog_gain;
    }

    if(pConfig->stNRswitch.valid == true) {

        float up_thres = (float)pConfig->stNRswitch.up_thres / (float)pConfig->stNRswitch.div_coeff;
        float down_thres = (float)pConfig->stNRswitch.down_thres / (float)pConfig->stNRswitch.div_coeff;

        if(gain >= up_thres)
            rkAeExp->CISFeature.SNR = (pConfig->stNRswitch.direct == 0) ? 1 : 0;
        if(gain < down_thres)
            rkAeExp->CISFeature.SNR = (pConfig->stNRswitch.direct == 0) ? 0 : 1;

    } else {
        //LCG/HCG => SNR
        rkAeExp->CISFeature.SNR = dcg_mode > 0 ? 1 : 0;
    }
}

static XCamReturn AeDemoCreateCtx(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
{
    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);

    RESULT ret = RK_AIQ_RET_SUCCESS;
    RkAiqAlgoContext *ctx = new RkAiqAlgoContext();
    if (ctx == NULL) {
        printf( "%s: create ae context fail!\n", __FUNCTION__);
        return XCAM_RETURN_ERROR_MEM;
    }
    memset(ctx, 0, sizeof(*ctx));

    ctx->rkCfg.fps_request = -1;
    ctx->rkCfg.update_fps = false;

    CalibDb_Sensor_ParaV2_t* calibv2_sensor_calib =
        (CalibDb_Sensor_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(cfg->calibv2, sensor_calib));

    ctx->rkCfg.stSensorInfo = *calibv2_sensor_calib;

    if (cfg->isGroupMode) {
        AlgoCtxInstanceCfgCamGroup* grpCfg = (AlgoCtxInstanceCfgCamGroup*)cfg;
        memcpy(ctx->camIdArray, grpCfg->camIdArray, sizeof(ctx->camIdArray));
        ctx->camIdArrayLen = grpCfg->camIdArrayLen;
        ctx->isGroupMode = true;
    } else {
        ctx->camIdArrayLen = 0;
        ctx->isGroupMode = false;
    }
    *context = ctx;
    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);

    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn AeDemoDestroyCtx(RkAiqAlgoContext *context)
{
    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);

    if(context == NULL)
        return XCAM_RETURN_NO_ERROR;

    if (context->cbs.pfn_ae_exit) {
        context->cbs.pfn_ae_exit(context->aiq_ctx);
        context->cutomAeInit = false;
    }
    delete context;
    context = NULL;

    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn initAecHwConfig(rk_aiq_rkAe_config_t* pConfig)
{
    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    /**************** set rawae_sel to choose BIG/LITE mode ******************/
    /*      rawae0-2.rawae_sel should be the same, defining BIG/LITE mode of chn[0-2]    */
    /*    rawae3.rawae_sel is different from rawae0-2, defining BIG/LITE mode of debayer  */
    /*****************************************************************/

    if(pConfig->HdrFrmNum < 3) {
        pConfig->aeHwConfig.ae_meas.rawae0.rawae_sel = 2;
        pConfig->aeHwConfig.ae_meas.rawae1.rawae_sel = 2;
        pConfig->aeHwConfig.ae_meas.rawae2.rawae_sel = 2;
        pConfig->aeHwConfig.ae_meas.rawae3.rawae_sel = 3;
    } else {
        pConfig->aeHwConfig.ae_meas.rawae0.rawae_sel = 1;
        pConfig->aeHwConfig.ae_meas.rawae1.rawae_sel = 1;
        pConfig->aeHwConfig.ae_meas.rawae2.rawae_sel = 1;
        pConfig->aeHwConfig.ae_meas.rawae3.rawae_sel = 3;
    }

    pConfig->aeHwConfig.hist_meas.ae_swap = pConfig->aeHwConfig.ae_meas.rawae1.rawae_sel;
    pConfig->aeHwConfig.hist_meas.ae_sel = pConfig->aeHwConfig.ae_meas.rawae3.rawae_sel;

    /*****rawae0, LITE mode****/
    pConfig->aeHwConfig.ae_meas.rawae0.wnd_num = 1;
    pConfig->aeHwConfig.ae_meas.rawae0.win.h_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae0.win.v_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae0.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.ae_meas.rawae0.win.v_size = pConfig->RawHeight;

    /*****rawae1-3, BIG mode****/
    pConfig->aeHwConfig.ae_meas.rawae1.wnd_num = 2;
    pConfig->aeHwConfig.ae_meas.rawae1.win.h_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae1.win.v_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae1.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.ae_meas.rawae1.win.v_size = pConfig->RawHeight;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[0].h_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[0].v_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[0].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[0].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[1].h_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[1].v_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[1].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[1].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[2].h_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[2].v_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[2].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[2].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[3].h_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[3].v_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[3].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin[3].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae1.subwin_en[0] = 1;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin_en[1] = 1;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin_en[2] = 1;
    pConfig->aeHwConfig.ae_meas.rawae1.subwin_en[3] = 1;

    pConfig->aeHwConfig.ae_meas.rawae2.wnd_num = 2;
    pConfig->aeHwConfig.ae_meas.rawae2.win.h_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae2.win.v_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae2.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.ae_meas.rawae2.win.v_size = pConfig->RawHeight;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[0].h_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[0].v_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[0].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[0].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[1].h_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[1].v_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[1].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[1].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[2].h_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[2].v_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[2].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[2].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[3].h_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[3].v_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[3].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin[3].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae2.subwin_en[0] = 1;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin_en[1] = 1;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin_en[2] = 1;
    pConfig->aeHwConfig.ae_meas.rawae2.subwin_en[3] = 1;

    pConfig->aeHwConfig.ae_meas.rawae3.wnd_num = 2;
    pConfig->aeHwConfig.ae_meas.rawae3.win.h_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae3.win.v_offs = 0;
    pConfig->aeHwConfig.ae_meas.rawae3.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.ae_meas.rawae3.win.v_size = pConfig->RawHeight;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[0].h_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[0].v_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[0].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[0].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[1].h_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[1].v_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[1].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[1].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[2].h_offs = 2;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[2].v_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[2].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[2].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[3].h_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[3].v_offs = 150;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[3].h_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin[3].v_size = 100;  // must even number
    pConfig->aeHwConfig.ae_meas.rawae3.subwin_en[0] = 1;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin_en[1] = 1;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin_en[2] = 1;
    pConfig->aeHwConfig.ae_meas.rawae3.subwin_en[3] = 1;

    /****rawhist0, LITE mode****/
    pConfig->aeHwConfig.hist_meas.rawhist0.data_sel = 0;
    pConfig->aeHwConfig.hist_meas.rawhist0.waterline = 0;
    pConfig->aeHwConfig.hist_meas.rawhist0.mode = 5;
    pConfig->aeHwConfig.hist_meas.rawhist0.stepsize = 0;
    pConfig->aeHwConfig.hist_meas.rawhist0.win.h_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist0.win.v_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist0.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.hist_meas.rawhist0.win.v_size = pConfig->RawHeight;
    memset(pConfig->aeHwConfig.hist_meas.rawhist0.weight, 0x20, RAWHISTBIG_WIN_NUM * sizeof(unsigned char));
    pConfig->aeHwConfig.hist_meas.rawhist0.rcc = 0x4d;
    pConfig->aeHwConfig.hist_meas.rawhist0.gcc = 0x4b;
    pConfig->aeHwConfig.hist_meas.rawhist0.bcc = 0x1d;
    pConfig->aeHwConfig.hist_meas.rawhist0.off = 0x00;

    /****rawhist1-3, BIG mode****/
    pConfig->aeHwConfig.hist_meas.rawhist1.data_sel = 0;
    pConfig->aeHwConfig.hist_meas.rawhist1.waterline = 0;
    pConfig->aeHwConfig.hist_meas.rawhist1.mode = 5;
    pConfig->aeHwConfig.hist_meas.rawhist1.wnd_num = 2;
    pConfig->aeHwConfig.hist_meas.rawhist1.stepsize = 0;
    pConfig->aeHwConfig.hist_meas.rawhist1.win.h_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist1.win.v_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist1.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.hist_meas.rawhist1.win.v_size = pConfig->RawHeight;
    memset(pConfig->aeHwConfig.hist_meas.rawhist1.weight, 0x20, RAWHISTBIG_WIN_NUM * sizeof(unsigned char));
    pConfig->aeHwConfig.hist_meas.rawhist1.rcc = 0x4d;
    pConfig->aeHwConfig.hist_meas.rawhist1.gcc = 0x4b;
    pConfig->aeHwConfig.hist_meas.rawhist1.bcc = 0x1d;
    pConfig->aeHwConfig.hist_meas.rawhist1.off = 0x00;

    pConfig->aeHwConfig.hist_meas.rawhist2.data_sel = 0;
    pConfig->aeHwConfig.hist_meas.rawhist2.waterline = 0;
    pConfig->aeHwConfig.hist_meas.rawhist2.mode = 5;
    pConfig->aeHwConfig.hist_meas.rawhist2.wnd_num = 2;
    pConfig->aeHwConfig.hist_meas.rawhist2.stepsize = 0;
    pConfig->aeHwConfig.hist_meas.rawhist2.win.h_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist2.win.v_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist2.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.hist_meas.rawhist2.win.v_size = pConfig->RawHeight;
    memset(pConfig->aeHwConfig.hist_meas.rawhist2.weight, 0x20, RAWHISTBIG_WIN_NUM * sizeof(unsigned char));
    pConfig->aeHwConfig.hist_meas.rawhist2.rcc = 0x4d;
    pConfig->aeHwConfig.hist_meas.rawhist2.gcc = 0x4b;
    pConfig->aeHwConfig.hist_meas.rawhist2.bcc = 0x1d;
    pConfig->aeHwConfig.hist_meas.rawhist2.off = 0x00;

    pConfig->aeHwConfig.hist_meas.rawhist3.data_sel = 0;
    pConfig->aeHwConfig.hist_meas.rawhist3.waterline = 0;
    pConfig->aeHwConfig.hist_meas.rawhist3.mode = 5;
    pConfig->aeHwConfig.hist_meas.rawhist3.wnd_num = 2;
    pConfig->aeHwConfig.hist_meas.rawhist3.stepsize = 0;
    pConfig->aeHwConfig.hist_meas.rawhist3.win.h_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist3.win.v_offs = 0;
    pConfig->aeHwConfig.hist_meas.rawhist3.win.h_size = pConfig->RawWidth;
    pConfig->aeHwConfig.hist_meas.rawhist3.win.v_size = pConfig->RawHeight;
    memset(pConfig->aeHwConfig.hist_meas.rawhist3.weight, 0x20, RAWHISTBIG_WIN_NUM * sizeof(unsigned char));
    pConfig->aeHwConfig.hist_meas.rawhist3.rcc = 0x4d;
    pConfig->aeHwConfig.hist_meas.rawhist3.gcc = 0x4b;
    pConfig->aeHwConfig.hist_meas.rawhist3.bcc = 0x1d;
    pConfig->aeHwConfig.hist_meas.rawhist3.off = 0x00;

    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);
    return ret;
}

static XCamReturn updateAecHwConfig(RkAiqAlgoProcResAe* rkAeProcRes, rk_aiq_rkAe_config_t* rkAe)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    rkAeProcRes->ae_meas = rkAe->aeHwConfig.ae_meas;
    rkAeProcRes->hist_meas = rkAe->aeHwConfig.hist_meas;

    return ret;
}
static XCamReturn updateGrpAecHwConfig(rk_aiq_singlecam_3a_result_t ** rk_aiq_singlecam_3a_result, int camnum, rk_aiq_rkAe_config_t* rkAe)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    for(int i = 0; i < camnum; i++) {
        memcpy(rk_aiq_singlecam_3a_result[i]->aec._aeMeasParams, &rkAe->aeHwConfig.ae_meas, sizeof(rk_aiq_ae_meas_params_t));
        memcpy(rk_aiq_singlecam_3a_result[i]->aec._aeHistMeasParams, &rkAe->aeHwConfig.hist_meas, sizeof(rk_aiq_hist_meas_params_t));
    }

    return ret;
}

// call after initAecHwConfig
static void initCustomAeRes(rk_aiq_customeAe_results_t* customAe, rk_aiq_rkAe_config_t* pConfig)
{
    // 0.) exposure params
    if(pConfig->IsHdr) {
        //hdr_exp 0:sframe 1:mframe 2:lframe, set exp according to hdrframe
        customAe->hdr_exp[0].exp_real_params.integration_time = 0.003f;
        customAe->hdr_exp[0].exp_real_params.analog_gain = 1.0f;
        customAe->hdr_exp[0].exp_real_params.digital_gain = 1.0f;
        customAe->hdr_exp[0].exp_real_params.isp_dgain = 1.0f;
        customAe->hdr_exp[0].exp_real_params.iso = customAe->hdr_exp[0].exp_real_params.analog_gain * 50; //RK: ISO = Gain*50

        customAe->hdr_exp[1].exp_real_params.integration_time = 0.01f;
        customAe->hdr_exp[1].exp_real_params.analog_gain = 1.0f;
        customAe->hdr_exp[1].exp_real_params.digital_gain = 1.0f;
        customAe->hdr_exp[1].exp_real_params.isp_dgain = 1.0f;
        customAe->hdr_exp[1].exp_real_params.iso = customAe->hdr_exp[1].exp_real_params.analog_gain * 50; //RK: ISO = Gain*50

        customAe->hdr_exp[2].exp_real_params.integration_time = 0.02f;
        customAe->hdr_exp[2].exp_real_params.analog_gain = 1.0f;
        customAe->hdr_exp[2].exp_real_params.digital_gain = 1.0f;
        customAe->hdr_exp[2].exp_real_params.isp_dgain = 1.0f;
        customAe->hdr_exp[2].exp_real_params.iso = customAe->hdr_exp[2].exp_real_params.analog_gain * 50; //RK: ISO = Gain*50

        AeHdrDcgConv(pConfig, customAe->hdr_exp);

        for(int i = 0; i < pConfig->HdrFrmNum; i++) {

            AeReal2RegConv(pConfig, customAe->hdr_exp[i].exp_real_params.integration_time,
                           customAe->hdr_exp[i].exp_real_params.analog_gain,
                           &customAe->hdr_exp[i].exp_sensor_params.coarse_integration_time,
                           &customAe->hdr_exp[i].exp_sensor_params.analog_gain_code_global,
                           &customAe->hdr_exp[i].exp_real_params.dcg_mode);

            customAe->exp_i2c_params.bValid = false;
        }
    } else {
        //linear_exp
        customAe->linear_exp.exp_real_params.integration_time = 0.003f;
        customAe->linear_exp.exp_real_params.analog_gain = 1.0f;
        customAe->linear_exp.exp_real_params.digital_gain = 1.0f;
        customAe->linear_exp.exp_real_params.isp_dgain = 1.0f;
        customAe->linear_exp.exp_real_params.iso = customAe->linear_exp.exp_real_params.analog_gain * 50; //RK: ISO = Gain*50

        AeDcgConv(pConfig, customAe->linear_exp.exp_real_params.analog_gain, &customAe->linear_exp.exp_real_params.dcg_mode);

        AeReal2RegConv(pConfig, customAe->linear_exp.exp_real_params.integration_time,
                       customAe->linear_exp.exp_real_params.analog_gain,
                       &customAe->linear_exp.exp_sensor_params.coarse_integration_time,
                       &customAe->linear_exp.exp_sensor_params.analog_gain_code_global,
                       &customAe->linear_exp.exp_real_params.dcg_mode);

        customAe->exp_i2c_params.bValid = false;
    }

    customAe->frame_length_lines = pConfig->PixelPeriodsPerLine;
    customAe->is_longfrm_mode = false;

    //1.) hw params
    customAe->meas_win = pConfig->aeHwConfig.ae_meas.rawae0.win;
    memcpy(&customAe->meas_weight,
           &pConfig->aeHwConfig.hist_meas.rawhist0.weight, sizeof(customAe->meas_weight));

}

static XCamReturn AeDemoPrepare(RkAiqAlgoCom* params)
{
    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoContext* algo_ctx = params->ctx;

    if (!algo_ctx->cutomAeInit) {
        algo_ctx->cbs.pfn_ae_init(algo_ctx->aiq_ctx);
        algo_ctx->cutomAeInit = true;
    }

    // 0.) working mode (normal / hdr 2 / hdr 3)
    algo_ctx->rkCfg.Working_mode = params->u.prepare.working_mode;

    if(algo_ctx->rkCfg.Working_mode <= RK_AIQ_WORKING_MODE_NORMAL) {
        algo_ctx->rkCfg.IsHdr = false;
    } else {
        algo_ctx->rkCfg.IsHdr = true;
        if(algo_ctx->rkCfg.Working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3)
            algo_ctx->rkCfg.HdrFrmNum = 2;
        else
            algo_ctx->rkCfg.HdrFrmNum = 3;
    }

    // 1.) resolution
    algo_ctx->rkCfg.RawWidth = params->u.prepare.sns_op_width;
    algo_ctx->rkCfg.RawHeight = params->u.prepare.sns_op_height;

    if(algo_ctx->isGroupMode) {

        RkAiqAlgoCamGroupPrepare* AeCfgParam = (RkAiqAlgoCamGroupPrepare*)params;

        //read info from sensor (hts vts pclk)
        algo_ctx->rkCfg.LinePeriodsPerField = AeCfgParam->aec.LinePeriodsPerField;
        algo_ctx->rkCfg.PixelClockFreqMHZ = AeCfgParam->aec.PixelClockFreqMHZ;
        algo_ctx->rkCfg.PixelPeriodsPerLine = AeCfgParam->aec.PixelPeriodsPerLine;
        algo_ctx->rkCfg.stNRswitch = AeCfgParam->aec.nr_switch;

    } else {

        RkAiqAlgoConfigAe* AeCfgParam = (RkAiqAlgoConfigAe*)params;

        //read info from sensor (hts vts pclk)
        algo_ctx->rkCfg.LinePeriodsPerField = AeCfgParam->LinePeriodsPerField;
        algo_ctx->rkCfg.PixelClockFreqMHZ = AeCfgParam->PixelClockFreqMHZ;
        algo_ctx->rkCfg.PixelPeriodsPerLine = AeCfgParam->PixelPeriodsPerLine;
        algo_ctx->rkCfg.stNRswitch = AeCfgParam->nr_switch;

    }

    algo_ctx->rkCfg.init_fps = algo_ctx->rkCfg.PixelClockFreqMHZ * 1000000
                               / (algo_ctx->rkCfg.LinePeriodsPerField * algo_ctx->rkCfg.PixelPeriodsPerLine);
    algo_ctx->rkCfg.last_fps = algo_ctx->rkCfg.init_fps;

    if (algo_ctx->rkCfg.fps_request == -1) {
        algo_ctx->rkCfg.last_vts = algo_ctx->rkCfg.LinePeriodsPerField;
        algo_ctx->rkCfg.vts_request = algo_ctx->rkCfg.last_vts;
    }

    // 3.) set initial hw config & initial ae result, initial value can be modified by user in processing

    if(!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB)) {
        //initial hw
        initAecHwConfig(&algo_ctx->rkCfg); //for group ae, initial value can be the same

        //initial ae result (exposure, hw res)
        initCustomAeRes(&algo_ctx->customRes, &algo_ctx->rkCfg); //for group, only init full customRes

        algo_ctx->updateCalib = false;
    } else {
        //update calib
        algo_ctx->updateCalib = true;
    }

    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);

    return ret;
}

static
void _rkAeStats2CustomAeStats(rk_aiq_rkAe_config_t * pConfig,
                              rk_aiq_customAe_stats_t* customAe,
                              RKAiqAecStats_t* rkAe)
{
    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);

    // 1.0) ae hw stats
    customAe->rawae_stat[0] = rkAe->ae_data.chn[0];
    customAe->rawae_stat[1] = rkAe->ae_data.chn[1];
    customAe->rawae_stat[2] = rkAe->ae_data.chn[2];

    customAe->extra.rawae_big = rkAe->ae_data.extra.rawae_big;
    customAe->extra.rawhist_big = rkAe->ae_data.extra.rawhist_big;

    // 2.0) ae exposure stats

    if(pConfig->IsHdr) {
        customAe->hdr_exp[0] = rkAe->ae_exp.HdrExp[0];
        customAe->hdr_exp[1] = rkAe->ae_exp.HdrExp[1];
        customAe->hdr_exp[2] = rkAe->ae_exp.HdrExp[2];
    } else {
        customAe->linear_exp = rkAe->ae_exp.LinearExp;
    }


    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);
}

static
XCamReturn _rkGrpAeStats2CustomGrpAeStats(rk_aiq_rkAe_config_t * pConfig,
        int camnum,
        rk_aiq_customAe_stats_t* customAe,
        rk_aiq_singlecam_3a_result_t ** rk_aiq_singlecam_3a_result)
{
    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    XCamVideoBuffer* aecStatsBuf = nullptr;
    RkAiqAecStats* xAecStats = nullptr;

    rk_aiq_customAe_stats_t* customAeStats = customAe;
    rk_aiq_customAe_stats_t* next_customAeStats = nullptr;

    for(int i = 0; i < camnum; i++) {

        aecStatsBuf = rk_aiq_singlecam_3a_result[i]->aec._aecStats;
        if (aecStatsBuf) {
            xAecStats = (RkAiqAecStats*)aecStatsBuf->map(aecStatsBuf);
            if (!xAecStats) {
                LOGE_GAEC("aec stats is null for %dth camera", i);
                return(XCAM_RETURN_ERROR_FAILED);
            }
        } else {
            LOGE_GAEC("aec stats is null for %dth camera", i);
            return(XCAM_RETURN_ERROR_FAILED);
        }

        if(i > 0) {
            if(customAeStats->next == nullptr)
                customAeStats->next = (rk_aiq_customAe_stats_t*)calloc(1, sizeof(rk_aiq_customAe_stats_t));

            next_customAeStats = customAeStats->next;
            customAeStats = next_customAeStats;
        }

        _rkAeStats2CustomAeStats(pConfig, customAeStats, &xAecStats->aec_stats);

    }

    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);

    return (ret);
}

static void _customGrpAeStatsRelease(rk_aiq_customAe_stats_t *customAe)
{
    LOG1_AEC_SUBM(0xff, "%s ENTER", __func__);
    rk_aiq_customAe_stats_t* customAeStats = customAe->next;
    rk_aiq_customAe_stats_t* next_customAeStats = nullptr;

    while(customAeStats != nullptr) {

        next_customAeStats = customAeStats->next;
        free(customAeStats);
        customAeStats = next_customAeStats;
    }

    LOG1_AEC_SUBM(0xff, "%s EXIT", __func__);
}

static
void _customAeRes2rkAeRes(rk_aiq_rkAe_config_t* pConfig, RkAiqAlgoProcResAe* rkAeProcRes,
                          rk_aiq_customeAe_results_t* customAeProcRes)
{

    //AE new sensor exposure
    if(pConfig->IsHdr) {
        //Hdr
        if(!(customAeProcRes->exp_i2c_params.bValid))
            AeHdrDcgConv(pConfig, customAeProcRes->hdr_exp);

        for(int i = 0; i < pConfig->HdrFrmNum; i++) {

            if(!(customAeProcRes->exp_i2c_params.bValid)) {
                AeReal2RegConv(pConfig, customAeProcRes->hdr_exp[i].exp_real_params.integration_time,
                               customAeProcRes->hdr_exp[i].exp_real_params.analog_gain,
                               &customAeProcRes->hdr_exp[i].exp_sensor_params.coarse_integration_time,
                               &customAeProcRes->hdr_exp[i].exp_sensor_params.analog_gain_code_global,
                               &customAeProcRes->hdr_exp[i].exp_real_params.dcg_mode);
            }
            rkAeProcRes->new_ae_exp.HdrExp[i] = customAeProcRes->hdr_exp[i];
        }

    } else {
        //Linear
        if(!customAeProcRes->exp_i2c_params.bValid) {
            AeDcgConv(pConfig, customAeProcRes->linear_exp.exp_real_params.analog_gain, &customAeProcRes->linear_exp.exp_real_params.dcg_mode);
            AeReal2RegConv(pConfig, customAeProcRes->linear_exp.exp_real_params.integration_time,
                           customAeProcRes->linear_exp.exp_real_params.analog_gain,
                           &customAeProcRes->linear_exp.exp_sensor_params.coarse_integration_time,
                           &customAeProcRes->linear_exp.exp_sensor_params.analog_gain_code_global,
                           &customAeProcRes->linear_exp.exp_real_params.dcg_mode);

        }

        rkAeProcRes->new_ae_exp.LinearExp = customAeProcRes->linear_exp;
    }

    rkAeProcRes->new_ae_exp.exp_i2c_params.bValid = customAeProcRes->exp_i2c_params.bValid;
    rkAeProcRes->new_ae_exp.exp_i2c_params.nNumRegs = customAeProcRes->exp_i2c_params.nNumRegs;

    if(customAeProcRes->exp_i2c_params.bValid) {
        if(customAeProcRes->exp_i2c_params.nNumRegs <= MAX_I2CDATA_LEN) {
            for(uint32_t i = 0; i < customAeProcRes->exp_i2c_params.nNumRegs; i++) {
                rkAeProcRes->new_ae_exp.exp_i2c_params.DelayFrames[i] = customAeProcRes->exp_i2c_params.pDelayFrames[i];
                rkAeProcRes->new_ae_exp.exp_i2c_params.RegAddr[i] = customAeProcRes->exp_i2c_params.pRegAddr[i];
                rkAeProcRes->new_ae_exp.exp_i2c_params.AddrByteNum[i] = customAeProcRes->exp_i2c_params.pAddrByteNum[i];
                rkAeProcRes->new_ae_exp.exp_i2c_params.RegValue[i] = customAeProcRes->exp_i2c_params.pRegValue[i];
                rkAeProcRes->new_ae_exp.exp_i2c_params.ValueByteNum[i] = customAeProcRes->exp_i2c_params.pValueByteNum[i];
            }
        } else {
            LOGE("too many i2c data to set!!");
        }
    }

    rkAeProcRes->new_ae_exp.frame_length_lines = customAeProcRes->frame_length_lines;
    rkAeProcRes->new_ae_exp.Iris = customAeProcRes->Iris;

    rkAeProcRes->ae_proc_res_rk.exp_set_cnt = 1;
    rkAeProcRes->ae_proc_res_rk.exp_set_tbl[0] = rkAeProcRes->new_ae_exp;
    rkAeProcRes->ae_proc_res_rk.LongFrmMode = customAeProcRes->is_longfrm_mode;

    //RK: CIS feature for NR
    AeCISFeature(pConfig, &rkAeProcRes->ae_proc_res_rk.exp_set_tbl[0]);

    //AE new HW config
    if (customAeProcRes->meas_win.h_size > 0 &&
            customAeProcRes->meas_win.v_size > 0) {
        rkAeProcRes->ae_meas.rawae0.win = customAeProcRes->meas_win;
        rkAeProcRes->ae_meas.rawae1.win = customAeProcRes->meas_win;
        rkAeProcRes->ae_meas.rawae2.win = customAeProcRes->meas_win;
        rkAeProcRes->ae_meas.rawae3.win = customAeProcRes->meas_win;
        rkAeProcRes->hist_meas.rawhist0.win = customAeProcRes->meas_win;
        rkAeProcRes->hist_meas.rawhist1.win = customAeProcRes->meas_win;
        rkAeProcRes->hist_meas.rawhist2.win = customAeProcRes->meas_win;
        rkAeProcRes->hist_meas.rawhist3.win = customAeProcRes->meas_win;
    }

    AeGridWeight15x15to5x5(customAeProcRes->meas_weight, rkAeProcRes->hist_meas.rawhist0.weight);
    memcpy(rkAeProcRes->hist_meas.rawhist1.weight, customAeProcRes->meas_weight, 15 * 15 * sizeof(unsigned char));
    memcpy(rkAeProcRes->hist_meas.rawhist2.weight, customAeProcRes->meas_weight, 15 * 15 * sizeof(unsigned char));
    memcpy(rkAeProcRes->hist_meas.rawhist3.weight, customAeProcRes->meas_weight, 15 * 15 * sizeof(unsigned char));

}

static
void _customGrpAeSingleResSet(rk_aiq_rkAe_config_t* pConfig, rk_aiq_singlecam_3a_result_t* rk_aiq_singlecam_3a_result,
                              rk_aiq_customeAe_results_single_t customAeRes)
{
    // 0.) copy exposure params
    *rk_aiq_singlecam_3a_result->aec.exp_tbl_size = 1;

    if(pConfig->IsHdr) {
        //Hdr

        if(!customAeRes.exp_i2c_params.bValid)
            AeHdrDcgConv(pConfig, customAeRes.hdr_exp);

        for(int i = 0; i < pConfig->HdrFrmNum; i++) {

            if(!customAeRes.exp_i2c_params.bValid) {
                AeReal2RegConv(pConfig, customAeRes.hdr_exp[i].exp_real_params.integration_time,
                               customAeRes.hdr_exp[i].exp_real_params.analog_gain,
                               &customAeRes.hdr_exp[i].exp_sensor_params.coarse_integration_time,
                               &customAeRes.hdr_exp[i].exp_sensor_params.analog_gain_code_global,
                               &customAeRes.hdr_exp[i].exp_real_params.dcg_mode);
            }

            rk_aiq_singlecam_3a_result->aec.exp_tbl[0].HdrExp[i] = customAeRes.hdr_exp[i];
        }

    } else {
        //Linear

        if(!customAeRes.exp_i2c_params.bValid) {
            AeDcgConv(pConfig, customAeRes.linear_exp.exp_real_params.analog_gain, &customAeRes.linear_exp.exp_real_params.dcg_mode);
            AeReal2RegConv(pConfig, customAeRes.linear_exp.exp_real_params.integration_time,
                           customAeRes.linear_exp.exp_real_params.analog_gain,
                           &customAeRes.linear_exp.exp_sensor_params.coarse_integration_time,
                           &customAeRes.linear_exp.exp_sensor_params.analog_gain_code_global,
                           &customAeRes.linear_exp.exp_real_params.dcg_mode);
        }

        rk_aiq_singlecam_3a_result->aec.exp_tbl[0].LinearExp = customAeRes.linear_exp;
    }

    rk_aiq_singlecam_3a_result->aec.exp_tbl[0].exp_i2c_params.bValid = customAeRes.exp_i2c_params.bValid;
    rk_aiq_singlecam_3a_result->aec.exp_tbl[0].exp_i2c_params.nNumRegs = customAeRes.exp_i2c_params.nNumRegs;

    if(customAeRes.exp_i2c_params.bValid) {
        if(customAeRes.exp_i2c_params.nNumRegs <= MAX_I2CDATA_LEN) {

            for(uint32_t i = 0; i < customAeRes.exp_i2c_params.nNumRegs; i++) {
                rk_aiq_singlecam_3a_result->aec.exp_tbl[0].exp_i2c_params.DelayFrames[i] = customAeRes.exp_i2c_params.pDelayFrames[i];
                rk_aiq_singlecam_3a_result->aec.exp_tbl[0].exp_i2c_params.RegAddr[i] = customAeRes.exp_i2c_params.pRegAddr[i];
                rk_aiq_singlecam_3a_result->aec.exp_tbl[0].exp_i2c_params.AddrByteNum[i] = customAeRes.exp_i2c_params.pAddrByteNum[i];
                rk_aiq_singlecam_3a_result->aec.exp_tbl[0].exp_i2c_params.RegValue[i] = customAeRes.exp_i2c_params.pRegValue[i];
                rk_aiq_singlecam_3a_result->aec.exp_tbl[0].exp_i2c_params.ValueByteNum[i] = customAeRes.exp_i2c_params.pValueByteNum[i];
            }
        } else {
            LOGE("too many i2c data to set!!");
        }
    }

    // 1.) copy hw params

    //RK: CIS feature for NR
    AeCISFeature(pConfig, &rk_aiq_singlecam_3a_result->aec.exp_tbl[0]);

    //AE new HW config
    if (customAeRes.meas_win.h_size > 0 &&
            customAeRes.meas_win.v_size > 0) {
        rk_aiq_singlecam_3a_result->aec._aeMeasParams->rawae0.win = customAeRes.meas_win;
        rk_aiq_singlecam_3a_result->aec._aeMeasParams->rawae1.win = customAeRes.meas_win;
        rk_aiq_singlecam_3a_result->aec._aeMeasParams->rawae2.win = customAeRes.meas_win;
        rk_aiq_singlecam_3a_result->aec._aeMeasParams->rawae3.win = customAeRes.meas_win;
        rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist0.win = customAeRes.meas_win;
        rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist1.win = customAeRes.meas_win;
        rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist2.win = customAeRes.meas_win;
        rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist3.win = customAeRes.meas_win;
    }

    AeGridWeight15x15to5x5(customAeRes.meas_weight, rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist0.weight);
    memcpy(rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist1.weight, customAeRes.meas_weight, 15 * 15 * sizeof(unsigned char));
    memcpy(rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist2.weight, customAeRes.meas_weight, 15 * 15 * sizeof(unsigned char));
    memcpy(rk_aiq_singlecam_3a_result->aec._aeHistMeasParams->rawhist3.weight, customAeRes.meas_weight, 15 * 15 * sizeof(unsigned char));

}

static
void _customGrpAeRes2rkGrpAeRes(rk_aiq_rkAe_config_t* pConfig, rk_aiq_singlecam_3a_result_t ** rk_aiq_singlecam_3a_result, int camnum,
                                rk_aiq_customeAe_results_t* customAeProcRes)
{
    rk_aiq_customeAe_results_single_t* customAeRes = customAeProcRes->next;
    rk_aiq_customeAe_results_single_t tmp_customAeRes;

    for(int i = 0; i < camnum; i++) {

        //copy exposure & hw params
        if(i > 0 && customAeRes != nullptr) {
            tmp_customAeRes.hdr_exp[0] = customAeRes->hdr_exp[0];
            tmp_customAeRes.hdr_exp[1] = customAeRes->hdr_exp[1];
            tmp_customAeRes.hdr_exp[2] = customAeRes->hdr_exp[2];
            tmp_customAeRes.linear_exp = customAeRes->linear_exp;
            tmp_customAeRes.exp_i2c_params = customAeRes->exp_i2c_params;
            tmp_customAeRes.meas_win = customAeRes->meas_win;
            memcpy(tmp_customAeRes.meas_weight, customAeRes->meas_weight, 15 * 15 * sizeof(unsigned char));

            customAeRes = customAeRes->next;
        } else {
            tmp_customAeRes.hdr_exp[0] = customAeProcRes->hdr_exp[0];
            tmp_customAeRes.hdr_exp[1] = customAeProcRes->hdr_exp[1];
            tmp_customAeRes.hdr_exp[2] = customAeProcRes->hdr_exp[2];
            tmp_customAeRes.linear_exp = customAeProcRes->linear_exp;
            tmp_customAeRes.exp_i2c_params = customAeProcRes->exp_i2c_params;
            tmp_customAeRes.meas_win = customAeProcRes->meas_win;
            memcpy(tmp_customAeRes.meas_weight, customAeProcRes->meas_weight, 15 * 15 * sizeof(unsigned char));
        }

        _customGrpAeSingleResSet(pConfig, rk_aiq_singlecam_3a_result[i], tmp_customAeRes);

        //copy common result
        rk_aiq_singlecam_3a_result[i]->aec.exp_tbl[0].frame_length_lines =  customAeProcRes->frame_length_lines;
        rk_aiq_singlecam_3a_result[i]->aec.exp_tbl[0].Iris =  customAeProcRes->Iris;

        //copy common RK result
        XCamVideoBuffer* XaeProcRes = rk_aiq_singlecam_3a_result[i]->aec._aeProcRes;
        RkAiqAlgoProcResAe* aeProcRes = nullptr;
        if(XaeProcRes) {
            aeProcRes = (RkAiqAlgoProcResAe*)XaeProcRes->map(XaeProcRes);
            if(aeProcRes)
                aeProcRes->ae_proc_res_rk.LongFrmMode = customAeProcRes->is_longfrm_mode;
            else
                LOGW_GAEC("aeProcRes[%d] = nullptr", i);
        } else {
            LOGW_GAEC("XCamVideoBuffer of aeProcRes[%d] = nullptr", i);
        }
    }

}

static XCamReturn AeDemoPreProcess(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
#if 0
    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);
    RkAiqAlgoPreAe* AePreParams = (RkAiqAlgoPreAe*)inparams;
    RkAiqAlgoPreResAe* AePreResParams = (RkAiqAlgoPreResAe*)outparams;
    RkAiqAlgoContext* algo_ctx = inparams->ctx;
    AecPreResult_t* AePreResult = &AePreResParams->ae_pre_res_rk;

    if(!inparams->u.proc.init) {
        // get current used ae exp
        RkAiqAecStats *xAecStats = (RkAiqAecStats*)AePreParams->aecStatsBuf->map(AePreParams->aecStatsBuf);
        if (!xAecStats) {
            LOGE_AEC("aec stats is null");
            return(XCAM_RETURN_ERROR_FAILED);
        }

        if(algo_ctx->rkCfg.IsHdr) {

            for(int i = 0; i < algo_ctx->rkCfg.HdrFrmNum; i++) {
                AePreResult->HdrExp[i] = xAecStats->aec_stats.ae_exp.HdrExp[i];
                ret = AeReg2RealConv(&algo_ctx->rkCfg, AePreResult->HdrExp[i].exp_sensor_params.analog_gain_code_global,
                                     AePreResult->HdrExp[i].exp_sensor_params.coarse_integration_time,
                                     AePreResult->HdrExp[i].exp_real_params.dcg_mode,
                                     AePreResult->HdrExp[i].exp_real_params.analog_gain,
                                     AePreResult->HdrExp[i].exp_real_params.integration_time);
            }

        } else {
            AePreResult->LinearExp = xAecStats->aec_stats.ae_exp.LinearExp;
            ret = AeReg2RealConv(&algo_ctx->rkCfg, AePreResult->LinearExp.exp_sensor_params.analog_gain_code_global,
                                 AePreResult->LinearExp.exp_sensor_params.coarse_integration_time,
                                 AePreResult->LinearExp.exp_real_params.dcg_mode,
                                 AePreResult->LinearExp.exp_real_params.analog_gain,
                                 AePreResult->LinearExp.exp_real_params.integration_time);
        }

    } else {
        if (algo_ctx->updateCalib) {
            LOGD_AEC_SUBM(0xff, "updateCalib, no need re-init");
            return ret;
        }

        // use init ae exp
        if(algo_ctx->rkCfg.IsHdr) {
            AePreResult->HdrExp[0].exp_real_params = algo_ctx->customRes.hdr_exp[0];
            AePreResult->HdrExp[1].exp_real_params = algo_ctx->customRes.hdr_exp[1];
            AePreResult->HdrExp[2].exp_real_params = algo_ctx->customRes.hdr_exp[2];
        } else {
            AePreResult->LinearExp.exp_real_params = algo_ctx->customRes.linear_exp;
        }
    }

    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);
#endif
    return ret;
}

static XCamReturn AeDemoProcessing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{

    LOG1_AEC_SUBM(0xff, "%s ENTER", __func__);
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoProcAe* AeProcParams = (RkAiqAlgoProcAe*)inparams;
    RkAiqAlgoProcResAe* AeProcResParams = (RkAiqAlgoProcResAe*)outparams;
    RkAiqAlgoContext* algo_ctx = inparams->ctx;

    if (algo_ctx->isGroupMode) {
        LOGE_AEC("wrong aec mode");
        return ret;
    }

    if(!inparams->u.proc.init) { // init=ture, stats=null
        rk_aiq_customAe_stats_t customStats;
        memset(&customStats, 0, sizeof(rk_aiq_customAe_stats_t));

        RkAiqAecStats *xAecStats = (RkAiqAecStats*)AeProcParams->aecStatsBuf->map(AeProcParams->aecStatsBuf);
        if (!xAecStats) {
            LOGE_AEC("aec stats is null");
            return(XCAM_RETURN_ERROR_FAILED);
        }

        _rkAeStats2CustomAeStats(&algo_ctx->rkCfg, &customStats, &xAecStats->aec_stats);

        if (algo_ctx->cbs.pfn_ae_run)
            algo_ctx->cbs.pfn_ae_run(algo_ctx->aiq_ctx,
                                     &customStats,
                                     &algo_ctx->customRes
                                    );
    } else {
        if (algo_ctx->updateCalib) {
            LOGD_AEC_SUBM(0xff, "updateCalib, no need re-init");
            return ret;
        }

        if (algo_ctx->cbs.pfn_ae_run)
            algo_ctx->cbs.pfn_ae_run(algo_ctx->aiq_ctx,
                                     NULL,
                                     &algo_ctx->customRes
                                    );
    }

    // gen patrt of hw results from initAecHwConfig
    updateAecHwConfig(AeProcResParams, &algo_ctx->rkCfg);

    // copy custom result to rk result
    _customAeRes2rkAeRes(&algo_ctx->rkCfg, AeProcResParams, &algo_ctx->customRes);


    if (algo_ctx->updateCalib) {
        algo_ctx->updateCalib = false;
    }

    LOG1_AEC_SUBM(0xff, "%s EXIT", __func__);
    return XCAM_RETURN_NO_ERROR;
}

static XCamReturn AeDemoGroupProcessing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    LOG1_AEC_SUBM(0xff, "%s ENTER", __func__);
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoCamGroupProcIn* AeProcParams = (RkAiqAlgoCamGroupProcIn*)inparams;
    RkAiqAlgoCamGroupProcOut* AeProcResParams = (RkAiqAlgoCamGroupProcOut*)outparams;
    RkAiqAlgoContext* algo_ctx = inparams->ctx;

    if (!algo_ctx->isGroupMode) {
        LOGD_AEC("wrong aec mode for group");
        return ret;
    }

    if(!inparams->u.proc.init) { // init=ture, stats=null
        rk_aiq_customAe_stats_t customStats;
        memset(&customStats, 0, sizeof(customStats));
        _rkGrpAeStats2CustomGrpAeStats(&algo_ctx->rkCfg, algo_ctx->camIdArrayLen, &customStats, AeProcParams->camgroupParmasArray);

        if (algo_ctx->cbs.pfn_ae_run)
            algo_ctx->cbs.pfn_ae_run(algo_ctx->group_ctx,
                                     &customStats,
                                     &algo_ctx->customRes
                                    );
        _customGrpAeStatsRelease(&customStats);

    } else {
        if (algo_ctx->updateCalib) {
            LOGD_AEC_SUBM(0xff, "updateCalib, no need re-init");
            return ret;
        }

        if (algo_ctx->cbs.pfn_ae_run)
            algo_ctx->cbs.pfn_ae_run(algo_ctx->group_ctx,
                                     NULL,
                                     &algo_ctx->customRes
                                    );
    }

    // gen patrt of hw results from initAecHwConfig
    updateGrpAecHwConfig(AeProcResParams->camgroupParmasArray, AeProcResParams->arraySize, &algo_ctx->rkCfg);
    // copy custom result to rk result
    _customGrpAeRes2rkGrpAeRes(&algo_ctx->rkCfg, AeProcResParams->camgroupParmasArray, AeProcResParams->arraySize, &algo_ctx->customRes);

    LOG1_AEC_SUBM(0xff, "%s EXIT", __func__);
    return XCAM_RETURN_NO_ERROR;

}

static XCamReturn AeDemoPostProcess(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
{
    RESULT ret = RK_AIQ_RET_SUCCESS;

    return XCAM_RETURN_NO_ERROR;
}

static std::map<rk_aiq_sys_ctx_t*, RkAiqAlgoDescription*> g_customAe_desc_map;

XCamReturn
rk_aiq_uapi2_customAE_register(const rk_aiq_sys_ctx_t* ctx, rk_aiq_customeAe_cbs_t* cbs)
{

    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    if (!cbs)
        return XCAM_RETURN_ERROR_PARAM;

    const rk_aiq_camgroup_ctx_t* group_ctx = NULL;

    if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
        LOGI_AEC_SUBM(0xff, "group ae");
        group_ctx = (const rk_aiq_camgroup_ctx_t*)ctx;

    } else {
        LOGI_AEC_SUBM(0xff, "single ae");
    }

    RkAiqAlgoDescription* desc = NULL;
    rk_aiq_sys_ctx_t* cast_ctx = const_cast<rk_aiq_sys_ctx_t*>(ctx);

    std::map<rk_aiq_sys_ctx_t*, RkAiqAlgoDescription*>::iterator it =
        g_customAe_desc_map.find(cast_ctx);

    if (it == g_customAe_desc_map.end()) {
        desc = new RkAiqAlgoDescription();
        g_customAe_desc_map[cast_ctx] = desc;
    } else {
        desc = it->second;
    }

    desc->common.version = RKISP_ALGO_AE_DEMO_VERSION;
    desc->common.vendor  = RKISP_ALGO_AE_DEMO_VENDOR;
    desc->common.description = RKISP_ALGO_AE_DEMO_DESCRIPTION;
    desc->common.type    = RK_AIQ_ALGO_TYPE_AE;
    desc->common.id      = 0;
    desc->common.create_context  = AeDemoCreateCtx;
    desc->common.destroy_context = AeDemoDestroyCtx;
    desc->prepare = AeDemoPrepare;
    desc->pre_process = AeDemoPreProcess;
    if (!group_ctx)
        desc->processing = AeDemoProcessing;
    else
        desc->processing = AeDemoGroupProcessing;
    desc->post_process = AeDemoPostProcess;

    ret = rk_aiq_uapi_sysctl_regLib(ctx, &desc->common);
    if (ret != XCAM_RETURN_NO_ERROR) {
        LOGE_AEC_SUBM(0xff, "register %d failed !", desc->common.id);
        return ret;
    }

    RkAiqAlgoContext* algoCtx =
        rk_aiq_uapi_sysctl_getAxlibCtx(ctx,
                                       desc->common.type,
                                       desc->common.id);
    if (algoCtx == NULL) {
        LOGE_AEC_SUBM(0xff, "can't get custom ae algo %d ctx!", desc->common.id);
        return XCAM_RETURN_ERROR_FAILED;
    }

    algoCtx->cbs = *cbs;
    algoCtx->aiq_ctx = const_cast<rk_aiq_sys_ctx_t*>(ctx);

    LOGD_AEC_SUBM(0xff, "register custom ae algo sucess for sys_ctx %p, lib_id %d !",
                  ctx,
                  desc->common.id);
    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);

    return ret;
}

XCamReturn
rk_aiq_uapi2_customAE_enable(const rk_aiq_sys_ctx_t* ctx, bool enable)
{

    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    RkAiqAlgoDescription* desc = NULL;
    rk_aiq_sys_ctx_t* cast_ctx = const_cast<rk_aiq_sys_ctx_t*>(ctx);

    std::map<rk_aiq_sys_ctx_t*, RkAiqAlgoDescription*>::iterator it =
        g_customAe_desc_map.find(cast_ctx);

    if (it == g_customAe_desc_map.end()) {
        LOGE_AEC_SUBM(0xff, "can't find custom ae algo for sys_ctx %p !", ctx);
        return XCAM_RETURN_ERROR_FAILED;
    } else {
        desc = it->second;
    }

    ret = rk_aiq_uapi_sysctl_enableAxlib(ctx,
                                         desc->common.type,
                                         desc->common.id,
                                         enable);
    if (ret != XCAM_RETURN_NO_ERROR) {
        LOGE_AEC_SUBM(0xff, "enable custom ae lib id %d failed !");
        return ret;
    }

#if 0
    // now rk and custom ae are running concurrently,
    // because other algos will depend on results of rk ae
    if (enable)
        ret = rk_aiq_uapi_sysctl_enableAxlib(ctx,
                                             desc->common.type,
                                             0,
                                             !enable);
#endif

    LOGD_AEC_SUBM(0xff, "enable custom ae algo sucess for sys_ctx %p, lib_id %d !",
                  ctx,
                  desc->common.id);
    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn
rk_aiq_uapi2_customAE_unRegister(const rk_aiq_sys_ctx_t* ctx)
{

    LOGD_AEC_SUBM(0xff, "%s ENTER", __func__);
    RkAiqAlgoDescription* desc = NULL;
    rk_aiq_sys_ctx_t* cast_ctx = const_cast<rk_aiq_sys_ctx_t*>(ctx);

    std::map<rk_aiq_sys_ctx_t*, RkAiqAlgoDescription*>::iterator it =
        g_customAe_desc_map.find(cast_ctx);

    if (it == g_customAe_desc_map.end()) {
        LOGE_AEC_SUBM(0xff, "can't find custom ae algo for sys_ctx %p !", ctx);
        return XCAM_RETURN_ERROR_FAILED;
    } else {
        desc = it->second;
    }

    rk_aiq_uapi_sysctl_unRegLib(ctx,
                                desc->common.type,
                                desc->common.id);

    LOGD_AEC_SUBM(0xff, "unregister custom ae algo sucess for sys_ctx %p, lib_id %d !",
                  ctx,
                  desc->common.id);

    delete it->second;
    g_customAe_desc_map.erase(it);

    LOGD_AEC_SUBM(0xff, "%s EXIT", __func__);
    return XCAM_RETURN_NO_ERROR;
}

extern "C" {

    void rk_aiq_uapi2_customAE_setFrameRate(RkAiqAlgoContext* context, float fps)
    {
        if (fps > 0) {
            context->rkCfg.fps_request = fps;
            context->rkCfg.update_fps = true;
        } else {
            LOGE("%s: wrong set fps value: %f\n", __func__, fps);
        }

    }

    float rk_aiq_uapi2_customAE_getFrameRate(RkAiqAlgoContext* context)
    {
        return context->rkCfg.last_fps;
    }

}


RKAIQ_END_DECLARE