/*
 *  Copyright (c) 2019 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 "RkAiqCalibApi.h"
#include "aec_xml2json.h"
#include "RkAiqCalibDbV2.h"
#include <string>

/******************************************************************************
* AecGridWeight5x5to15x15()
*****************************************************************************/
void AecGridWeight5x5to15x15
(
    const unsigned char* inWeights,
    unsigned char*  outWeights
)
{

    //initial check
    if (NULL == inWeights) {
        printf("Error: inWeight == NULL!");
    }

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

    for (i = 0; i < 25; i++) {
        line_5x5 = i / 5;
        col_5x5 = i % 5;

        line_15x15 = line_5x5 * 3;
        col_15x15 = col_5x5 * 3;

        //line_5x5 operation
        switch (line_5x5) {
        case 0:
        case 1:
            switch (col_5x5) {
            case 0:
            case 1:
                for (j = 0; j < 3 + line_5x5; j++)
                    outWeights[(line_15x15 + j) * 15 + col_15x15] = inWeights[i] + (float)(inWeights[i + 5] - inWeights[i]) / (3.0f + line_5x5) * j;
                for (j = 0; j < 3 + col_5x5; j++)
                    outWeights[line_15x15 * 15 + col_15x15 + j] = inWeights[i] + (float)(inWeights[i + 1] - inWeights[i]) / (3.0f + col_5x5) * j;
                break;

            case 2:
                for (j = 0; j < 3 + line_5x5; j++)
                    outWeights[(line_15x15 + j) * 15 + col_15x15 + 1] = inWeights[i] + (float)(inWeights[i + 5] - inWeights[i]) / (3.0f + line_5x5) * j;
                break;

            case 3:
            case 4:
                for (j = 0; j < 3 + line_5x5; j++)
                    outWeights[(line_15x15 + j) * 15 + col_15x15 + 2] = inWeights[line_5x5 * 5 + col_5x5] + (float)(inWeights[(line_5x5 + 1) * 5 + col_5x5] - inWeights[line_5x5 * 5 + col_5x5]) / (3.0f + line_5x5) * j;
                for (j = 0; j < 7 - col_5x5; j++)
                    outWeights[line_15x15 * 15 + col_15x15 + 2 - j] = inWeights[i] + (float)(inWeights[i - 1] - inWeights[i]) / (7 - col_5x5) * j;
                break;

            default:
                break;
            }
            break;

        case 2:
            switch (col_5x5) {
            case 0:
            case 1:
                for (j = 0; j < 3 + col_5x5; j++)
                    outWeights[(line_15x15 + 1) * 15 + col_15x15 + j] = inWeights[i] + (float)(inWeights[i + 1] - inWeights[i]) / (3.0f + col_5x5) * j;
                break;

            case 2:
                outWeights[(line_15x15 + 1) * 15 + col_15x15 + 1] = inWeights[i];
                break;

            case 3:
            case 4:
                for (j = 0; j < 7 - col_5x5; j++) {
                    outWeights[(line_15x15 + 1) * 15 + col_15x15 + 2 - j] = inWeights[i] + (float)(inWeights[i - 1] - inWeights[i]) / (7.0f - col_5x5) * j;
                }
                break;

            default:
                break;
            }
            break;

        case 3:
        case 4:
            switch (col_5x5) {
            case 0:
            case 1:
                for (j = 0; j < 7 - line_5x5; j++)
                    outWeights[(line_15x15 + 2 - j) * 15 + col_15x15] = inWeights[i] + (float)(inWeights[i - 5] - inWeights[i]) / (7.0f - line_5x5) * j;
                for (j = 0; j < 3 + col_5x5; j++)
                    outWeights[(line_15x15 + 2) * 15 + col_15x15 + j] = inWeights[i] + (float)(inWeights[i + 1] - inWeights[i]) / (3.0f + col_5x5) * j;
                break;

            case 2:
                for (j = 0; j < 7 - line_5x5; j++)
                    outWeights[(line_15x15 + 2 - j) * 15 + col_15x15 + 1] = inWeights[i] + (float)(inWeights[i - 5] - inWeights[i]) / (7.0f - line_5x5) * j;
                break;

            case 3:
            case 4:
                for (j = 0; j < 7 - line_5x5; j++)
                    outWeights[(line_15x15 + 2 - j) * 15 + col_15x15 + 2] = inWeights[i] + (float)(inWeights[i - 5] - inWeights[i]) / (7.0f - line_5x5) * j;
                for (j = 0; j < 7 - col_5x5; j++)
                    outWeights[(line_15x15 + 2) * 15 + col_15x15 + 2 - j] = inWeights[i] + (float)(inWeights[i - 1] - inWeights[i]) / (7.0f - col_5x5) * j;
                break;

            default:
                break;
            }
            break;
        default:
            break;
        }

    }

    //diagonal operation
    for (k = 0; k < 225; k++) {
        line_15x15 = k / 15;
        col_15x15 = k % 15;
        if ((0 < line_15x15 && line_15x15 < 3) || (3 < line_15x15 && line_15x15 < 7) ||
                (7 < line_15x15 && line_15x15 < 11) || (11 < line_15x15 && line_15x15 < 14)) {
            if (0 < col_15x15 &&  col_15x15 < 3)
                outWeights[k] = outWeights[line_15x15 * 15 + 0] + (float)(outWeights[line_15x15 * 15 + 3] - outWeights[line_15x15 * 15 + 0]) / 3.0f * (float)(col_15x15 - 0);
            else if (3 < col_15x15 &&  col_15x15 < 7)
                outWeights[k] = outWeights[line_15x15 * 15 + 3] + (float)(outWeights[line_15x15 * 15 + 7] - outWeights[line_15x15 * 15 + 3]) / 4.0f * (float)(col_15x15 - 3);
            else if (7 < col_15x15 &&  col_15x15 < 11)
                outWeights[k] = outWeights[line_15x15 * 15 + 7] + (float)(outWeights[line_15x15 * 15 + 11] - outWeights[line_15x15 * 15 + 7]) / 4.0f * (float)(col_15x15 - 7);
            else if (11 < col_15x15 &&  col_15x15 < 14)
                outWeights[k] = outWeights[line_15x15 * 15 + 11] + (float)(outWeights[line_15x15 * 15 + 14] - outWeights[line_15x15 * 15 + 11]) / 3.0f * (float)(col_15x15 - 11);
        }
    }
    /*for (int i = 0; i<15; i++){

            printf("%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d %2d \n",
              outWeights[i * 15 + 0], outWeights[i * 15 + 1], outWeights[i * 15 + 2], outWeights[i * 15 + 3], outWeights[i * 15 + 4],
              outWeights[i * 15 + 5], outWeights[i * 15 + 6], outWeights[i * 15 + 7], outWeights[i * 15 + 8], outWeights[i * 15 + 9],
              outWeights[i * 15 + 10], outWeights[i * 15 + 11], outWeights[i * 15 + 12], outWeights[i * 15 + 13], outWeights[i * 15 + 14]);
    }*/


}

void CalibV2AecFree(CamCalibDbV2Context_t *calibV2) {
    CalibDb_Aec_ParaV2_t* aec_json =
        (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, ae_calib));
    if(aec_json == NULL)
        return;

    //LinCtrl
    free(aec_json->LinearAeCtrl.Route.TimeDot);
    free(aec_json->LinearAeCtrl.Route.GainDot);
    free(aec_json->LinearAeCtrl.Route.IspDGainDot);
    free(aec_json->LinearAeCtrl.Route.PIrisDot);
    free(aec_json->LinearAeCtrl.DySetpoint.ExpLevel);
    free(aec_json->LinearAeCtrl.DySetpoint.DySetpoint);
    free(aec_json->LinearAeCtrl.BackLightCtrl.BacklitSetPoint.ExpLevel);
    free(aec_json->LinearAeCtrl.BackLightCtrl.BacklitSetPoint.TargetLLLuma);
    free(aec_json->LinearAeCtrl.BackLightCtrl.BacklitSetPoint.NonOEPdfTh);
    free(aec_json->LinearAeCtrl.BackLightCtrl.BacklitSetPoint.LowLightPdfTh);
    free(aec_json->LinearAeCtrl.OverExpCtrl.OverExpSetPoint.OEpdf);
    free(aec_json->LinearAeCtrl.OverExpCtrl.OverExpSetPoint.HighLightWeight);
    free(aec_json->LinearAeCtrl.OverExpCtrl.OverExpSetPoint.LowLightWeight);

    //HdrCtrl
    free(aec_json->HdrAeCtrl.Route.Frm0TimeDot);
    free(aec_json->HdrAeCtrl.Route.Frm0GainDot);
    free(aec_json->HdrAeCtrl.Route.Frm0IspDGainDot);
    free(aec_json->HdrAeCtrl.Route.Frm1TimeDot);
    free(aec_json->HdrAeCtrl.Route.Frm1GainDot);
    free(aec_json->HdrAeCtrl.Route.Frm1IspDGainDot);
    free(aec_json->HdrAeCtrl.Route.Frm2TimeDot);
    free(aec_json->HdrAeCtrl.Route.Frm2GainDot);
    free(aec_json->HdrAeCtrl.Route.Frm2IspDGainDot);
    free(aec_json->HdrAeCtrl.Route.PIrisDot);
    free(aec_json->HdrAeCtrl.ExpRatioCtrl.ExpRatio.RatioExpDot);
    free(aec_json->HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioFix);
    free(aec_json->HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioFix);
    free(aec_json->HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioMax);
    free(aec_json->HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioMax);

    free(aec_json->HdrAeCtrl.LframeCtrl.LfrmSetPoint.LExpLevel);
    free(aec_json->HdrAeCtrl.LframeCtrl.LfrmSetPoint.LSetPoint);
    free(aec_json->HdrAeCtrl.LframeCtrl.LfrmSetPoint.LowLightPdfTh);
    free(aec_json->HdrAeCtrl.LframeCtrl.LfrmSetPoint.NonOEPdfTh);
    free(aec_json->HdrAeCtrl.LframeCtrl.LfrmSetPoint.TargetLLLuma);

    free(aec_json->HdrAeCtrl.MframeCtrl.MExpLevel);
    free(aec_json->HdrAeCtrl.MframeCtrl.MSetPoint);

    free(aec_json->HdrAeCtrl.SframeCtrl.SfrmSetPoint.SExpLevel);
    free(aec_json->HdrAeCtrl.SframeCtrl.SfrmSetPoint.SSetPoint);
    free(aec_json->HdrAeCtrl.SframeCtrl.SfrmSetPoint.TargetHLLuma);

    //SyncTest
    free(aec_json->SyncTest.AlterExp.LinearAE);
    free(aec_json->SyncTest.AlterExp.HdrAE);

    //free(aec_json);

}

void convertModuleinfoCalibV1ToCalibV2(const CamCalibDbContext_t *calib, CalibDb_Module_ParaV2_t* module_info) {

    //1.1) module
    if(CHECK_ISP_HW_V20()) {

        CalibDb_Module_Info_t module_xml =
            *(CalibDb_Module_Info_t*)CALIBDB_GET_MODULE_PTR((void*)calib, module);

        module_info->sensor_module.EFL = module_xml.EFL;
        module_info->sensor_module.LensT = module_xml.LensT;
        module_info->sensor_module.FNumber = module_xml.FNumber;
        module_info->sensor_module.IRCutT = module_xml.IRCutT;
    }
    if(CHECK_ISP_HW_V21()) {

        CalibDb_Module_Info_t moduleinfo_xml =
            *(CalibDb_Module_Info_t*)CALIBDB_GET_MODULE_PTR((void*)calib, module);

        module_info->sensor_module.EFL = moduleinfo_xml.EFL;
        module_info->sensor_module.LensT = moduleinfo_xml.LensT;
        module_info->sensor_module.FNumber = moduleinfo_xml.FNumber;
        module_info->sensor_module.IRCutT = moduleinfo_xml.IRCutT;
    }
}


void convertSensorinfoCalibV1ToCalibV2(const CamCalibDbContext_t *calib, CalibDb_Sensor_ParaV2_t* sensor_info) {
    //1. convert xml params 2 json params

    //1.0) sensorinfo

    if(CHECK_ISP_HW_V20()) {

        CalibDb_Sensor_Para_t sensor_xml =
            *(CalibDb_Sensor_Para_t*)CALIBDB_GET_MODULE_PTR((void*)calib, sensor);

        CalibDb_System_t system_xml =
            *(CalibDb_System_t*)CALIBDB_GET_MODULE_PTR((void*)calib, sysContrl);

        CalibDb_Lsc_t* lsc_xml =
            (CalibDb_Lsc_t*)CALIBDB_GET_MODULE_PTR((void*)calib, lsc);

        std::string resname(lsc_xml->aLscCof.lscResName[0]);
        std::string::size_type pos;
        std::string w, h;

        pos = resname.find("x");
        w = resname.substr(0, pos);
        h = resname.substr(pos + 1, resname.length() - pos);

        sensor_info->resolution.width = atoi(w.c_str());
        sensor_info->resolution.height = atoi(h.c_str());

        if(sensor_xml.GainRange.IsLinear)
            sensor_info->Gain2Reg.GainMode = EXPGAIN_MODE_LINEAR;
        else
            sensor_info->Gain2Reg.GainMode = EXPGAIN_MODE_NONLINEAR_DB;

        sensor_info->Gain2Reg.GainRange_len = sensor_xml.GainRange.array_size;
        sensor_info->Gain2Reg.GainRange = (float*)malloc(sensor_info->Gain2Reg.GainRange_len * sizeof(float));
        memcpy(sensor_info->Gain2Reg.GainRange, sensor_xml.GainRange.pGainRange, sensor_info->Gain2Reg.GainRange_len * sizeof(float));

        sensor_info->Time2Reg.fCoeff[0] = sensor_xml.TimeFactor[0];
        sensor_info->Time2Reg.fCoeff[1] = sensor_xml.TimeFactor[1];
        sensor_info->Time2Reg.fCoeff[2] = sensor_xml.TimeFactor[2];
        sensor_info->Time2Reg.fCoeff[3] = sensor_xml.TimeFactor[3];

        sensor_info->CISGainSet.CISAgainRange.Max = sensor_xml.CISAgainRange.Max;
        sensor_info->CISGainSet.CISAgainRange.Min = sensor_xml.CISAgainRange.Min;
        sensor_info->CISGainSet.CISExtraAgainRange.Max = sensor_xml.CISExtraAgainRange.Max;
        sensor_info->CISGainSet.CISExtraAgainRange.Min = sensor_xml.CISExtraAgainRange.Min;
        sensor_info->CISGainSet.CISDgainRange.Max = sensor_xml.CISDgainRange.Max;
        sensor_info->CISGainSet.CISDgainRange.Min = sensor_xml.CISDgainRange.Min;
        sensor_info->CISGainSet.CISIspDgainRange.Max = sensor_xml.CISIspDgainRange.Max;
        sensor_info->CISGainSet.CISIspDgainRange.Min = sensor_xml.CISIspDgainRange.Min;
        sensor_info->CISGainSet.CISHdrGainIndSetEn = (sensor_xml.CISHdrGainIndSetEn == 0) ? false : true;

        sensor_info->CISTimeSet.Linear.CISLinTimeRegMaxFac = sensor_xml.CISLinTimeRegMaxFac;
        sensor_info->CISTimeSet.Linear.CISTimeRegMin = sensor_xml.CISTimeRegMin;
        sensor_info->CISTimeSet.Linear.CISTimeRegOdevity = sensor_xml.CISTimeRegOdevity;
        sensor_info->CISTimeSet.Hdr[0].name = HDR_TWO_FRAME;
        sensor_info->CISTimeSet.Hdr[0].CISHdrTimeRegSumFac = sensor_xml.CISHdrTimeRegSumFac;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegMin = sensor_xml.CISHdrTimeRegMin;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegMax = sensor_xml.CISHdrTimeRegMax;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegOdevity = sensor_xml.CISHdrTimeRegOdevity;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegUnEqualEn = (sensor_xml.CISTimeRegUnEqualEn == 0) ? false : true;
        sensor_info->CISTimeSet.Hdr[1].name = HDR_THREE_FRAME;
        sensor_info->CISTimeSet.Hdr[1].CISHdrTimeRegSumFac = sensor_xml.CISHdrTimeRegSumFac;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegMin = sensor_xml.CISHdrTimeRegMin;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegMax = sensor_xml.CISHdrTimeRegMax;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegOdevity = sensor_xml.CISHdrTimeRegOdevity;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegUnEqualEn = (sensor_xml.CISTimeRegUnEqualEn == 0) ? false : true;

        sensor_info->CISExpUpdate.Linear.time_update = system_xml.exp_delay.Normal.time_delay;
        sensor_info->CISExpUpdate.Linear.gain_update = system_xml.exp_delay.Normal.gain_delay;
        sensor_info->CISExpUpdate.Linear.dcg_update = system_xml.exp_delay.Normal.dcg_delay;
        sensor_info->CISExpUpdate.Hdr.time_update = system_xml.exp_delay.Hdr.time_delay;
        sensor_info->CISExpUpdate.Hdr.gain_update = system_xml.exp_delay.Hdr.gain_delay;
        sensor_info->CISExpUpdate.Hdr.dcg_update = system_xml.exp_delay.Hdr.dcg_delay;

        sensor_info->CISDcgSet.Linear.support_en = system_xml.dcg.Normal.support_en;
        sensor_info->CISDcgSet.Linear.dcg_mode = system_xml.dcg.Normal.dcg_mode;
        sensor_info->CISDcgSet.Linear.dcg_optype = system_xml.dcg.Normal.dcg_optype;
        sensor_info->CISDcgSet.Linear.dcg_ratio = system_xml.dcg.Normal.dcg_ratio;
        sensor_info->CISDcgSet.Linear.sync_switch = system_xml.dcg.Normal.sync_switch;
        sensor_info->CISDcgSet.Linear.lcg2hcg_gain_th = system_xml.dcg.Normal.lcg2hcg_gain_th;
        sensor_info->CISDcgSet.Linear.hcg2lcg_gain_th = system_xml.dcg.Normal.hcg2lcg_gain_th;

        sensor_info->CISDcgSet.Hdr.support_en = system_xml.dcg.Hdr.support_en;
        sensor_info->CISDcgSet.Hdr.dcg_mode = system_xml.dcg.Hdr.dcg_mode;
        sensor_info->CISDcgSet.Hdr.dcg_optype = system_xml.dcg.Hdr.dcg_optype;
        sensor_info->CISDcgSet.Hdr.dcg_ratio = system_xml.dcg.Hdr.dcg_ratio;
        sensor_info->CISDcgSet.Hdr.sync_switch = system_xml.dcg.Hdr.sync_switch;
        sensor_info->CISDcgSet.Hdr.lcg2hcg_gain_th = system_xml.dcg.Hdr.lcg2hcg_gain_th;
        sensor_info->CISDcgSet.Hdr.hcg2lcg_gain_th = system_xml.dcg.Hdr.hcg2lcg_gain_th;

        sensor_info->CISHdrSet.hdr_en = (system_xml.hdr_en == 0) ? false : true;
        sensor_info->CISHdrSet.hdr_mode = system_xml.hdr_mode;
        sensor_info->CISHdrSet.line_mode = system_xml.line_mode;

        sensor_info->CISFlip = sensor_xml.flip;
        sensor_info->CISMinFps = sensor_xml.CISMinFps;
    }

    if(CHECK_ISP_HW_V21()) {

        CalibDb_ExpSet_para_t sensorinfo_xml =
            *(CalibDb_ExpSet_para_t*)CALIBDB_GET_MODULE_PTR((void*)calib, expset);

        CalibDb_Lsc_t* lsc_xml =
            (CalibDb_Lsc_t*)CALIBDB_GET_MODULE_PTR((void*)calib, lsc);

        std::string resname(lsc_xml->aLscCof.lscResName[0]);
        std::string::size_type pos;
        std::string w, h;

        pos = resname.find("x");
        w = resname.substr(0, pos);
        h = resname.substr(pos + 1, resname.length() - pos);

        sensor_info->resolution.width = atoi(w.c_str());
        sensor_info->resolution.height = atoi(h.c_str());

        if(sensorinfo_xml.Gain2Reg.IsLinear)
            sensor_info->Gain2Reg.GainMode = EXPGAIN_MODE_LINEAR;
        else
            sensor_info->Gain2Reg.GainMode = EXPGAIN_MODE_NONLINEAR_DB;

        sensor_info->Gain2Reg.GainRange_len = sensorinfo_xml.Gain2Reg.array_size;
        sensor_info->Gain2Reg.GainRange = (float*)malloc(sensor_info->Gain2Reg.GainRange_len * sizeof(float));
        memcpy(sensor_info->Gain2Reg.GainRange, sensorinfo_xml.Gain2Reg.pGainRange, sensor_info->Gain2Reg.GainRange_len * sizeof(float));

        sensor_info->Time2Reg.fCoeff[0] = sensorinfo_xml.Time2Reg[0];
        sensor_info->Time2Reg.fCoeff[1] = sensorinfo_xml.Time2Reg[1];
        sensor_info->Time2Reg.fCoeff[2] = sensorinfo_xml.Time2Reg[2];
        sensor_info->Time2Reg.fCoeff[3] = sensorinfo_xml.Time2Reg[3];

        sensor_info->CISGainSet.CISAgainRange.Max = sensorinfo_xml.CISGainSet.CISAgainRange.Max;
        sensor_info->CISGainSet.CISAgainRange.Min = sensorinfo_xml.CISGainSet.CISAgainRange.Min;
        sensor_info->CISGainSet.CISExtraAgainRange.Max = sensorinfo_xml.CISGainSet.CISExtraAgainRange.Max;
        sensor_info->CISGainSet.CISExtraAgainRange.Min = sensorinfo_xml.CISGainSet.CISExtraAgainRange.Min;
        sensor_info->CISGainSet.CISDgainRange.Max = sensorinfo_xml.CISGainSet.CISDgainRange.Max;
        sensor_info->CISGainSet.CISDgainRange.Min = sensorinfo_xml.CISGainSet.CISDgainRange.Min;
        sensor_info->CISGainSet.CISIspDgainRange.Max = sensorinfo_xml.CISGainSet.CISIspDgainRange.Max;
        sensor_info->CISGainSet.CISIspDgainRange.Min = sensorinfo_xml.CISGainSet.CISIspDgainRange.Min;
        sensor_info->CISGainSet.CISHdrGainIndSetEn = (sensorinfo_xml.CISGainSet.CISHdrGainIndSetEn == 0) ? false : true;

        sensor_info->CISTimeSet.Linear.CISLinTimeRegMaxFac = sensorinfo_xml.CISTimeSet.Normal.CISLinTimeRegMaxFac;
        sensor_info->CISTimeSet.Linear.CISTimeRegMin = sensorinfo_xml.CISTimeSet.Normal.CISTimeRegMin;
        sensor_info->CISTimeSet.Linear.CISTimeRegOdevity = sensorinfo_xml.CISTimeSet.Normal.CISTimeRegOdevity;
        sensor_info->CISTimeSet.Hdr[0].name = HDR_TWO_FRAME;
        sensor_info->CISTimeSet.Hdr[0].CISHdrTimeRegSumFac = sensorinfo_xml.CISTimeSet.Hdr[0].CISHdrTimeRegSumFac;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegMin = sensorinfo_xml.CISTimeSet.Hdr[0].CISTimeRegMin;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegMax = sensorinfo_xml.CISTimeSet.Hdr[0].CISTimeRegMax;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegOdevity = sensorinfo_xml.CISTimeSet.Hdr[0].CISTimeRegOdevity;
        sensor_info->CISTimeSet.Hdr[0].CISTimeRegUnEqualEn = (sensorinfo_xml.CISTimeSet.Hdr[0].CISTimeRegUnEqualEn == 0) ? false : true;
        sensor_info->CISTimeSet.Hdr[1].name = HDR_THREE_FRAME;
        sensor_info->CISTimeSet.Hdr[1].CISHdrTimeRegSumFac = sensorinfo_xml.CISTimeSet.Hdr[1].CISHdrTimeRegSumFac;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegMin = sensorinfo_xml.CISTimeSet.Hdr[1].CISTimeRegMin;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegMax = sensorinfo_xml.CISTimeSet.Hdr[1].CISTimeRegMax;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegOdevity = sensorinfo_xml.CISTimeSet.Hdr[1].CISTimeRegOdevity;
        sensor_info->CISTimeSet.Hdr[1].CISTimeRegUnEqualEn = (sensorinfo_xml.CISTimeSet.Hdr[1].CISTimeRegUnEqualEn == 0) ? false : true;

        sensor_info->CISExpUpdate.Linear.time_update = sensorinfo_xml.CISExpUpdate.Normal.time_update;
        sensor_info->CISExpUpdate.Linear.gain_update = sensorinfo_xml.CISExpUpdate.Normal.gain_update;
        sensor_info->CISExpUpdate.Linear.dcg_update = sensorinfo_xml.CISExpUpdate.Normal.dcg_update;
        sensor_info->CISExpUpdate.Hdr.time_update = sensorinfo_xml.CISExpUpdate.Hdr.time_update;
        sensor_info->CISExpUpdate.Hdr.gain_update = sensorinfo_xml.CISExpUpdate.Hdr.gain_update;
        sensor_info->CISExpUpdate.Hdr.dcg_update = sensorinfo_xml.CISExpUpdate.Hdr.dcg_update;

        sensor_info->CISDcgSet.Linear.support_en = sensorinfo_xml.CISDcgSet.Normal.support_en;
        sensor_info->CISDcgSet.Linear.dcg_mode = sensorinfo_xml.CISDcgSet.Normal.dcg_mode;
        sensor_info->CISDcgSet.Linear.dcg_optype = sensorinfo_xml.CISDcgSet.Normal.dcg_optype;
        sensor_info->CISDcgSet.Linear.dcg_ratio = sensorinfo_xml.CISDcgSet.Normal.dcg_ratio;
        sensor_info->CISDcgSet.Linear.sync_switch = sensorinfo_xml.CISDcgSet.Normal.sync_switch;
        sensor_info->CISDcgSet.Linear.lcg2hcg_gain_th = sensorinfo_xml.CISDcgSet.Normal.lcg2hcg_gain_th;
        sensor_info->CISDcgSet.Linear.hcg2lcg_gain_th = sensorinfo_xml.CISDcgSet.Normal.hcg2lcg_gain_th;

        sensor_info->CISDcgSet.Hdr.support_en = sensorinfo_xml.CISDcgSet.Hdr.support_en;
        sensor_info->CISDcgSet.Hdr.dcg_mode = sensorinfo_xml.CISDcgSet.Hdr.dcg_mode;
        sensor_info->CISDcgSet.Hdr.dcg_optype = sensorinfo_xml.CISDcgSet.Hdr.dcg_optype;
        sensor_info->CISDcgSet.Hdr.dcg_ratio = sensorinfo_xml.CISDcgSet.Hdr.dcg_ratio;
        sensor_info->CISDcgSet.Hdr.sync_switch = sensorinfo_xml.CISDcgSet.Hdr.sync_switch;
        sensor_info->CISDcgSet.Hdr.lcg2hcg_gain_th = sensorinfo_xml.CISDcgSet.Hdr.lcg2hcg_gain_th;
        sensor_info->CISDcgSet.Hdr.hcg2lcg_gain_th = sensorinfo_xml.CISDcgSet.Hdr.hcg2lcg_gain_th;

        sensor_info->CISHdrSet.hdr_en = (sensorinfo_xml.CISHdrSet.hdr_en == 0) ? false : true;
        sensor_info->CISHdrSet.hdr_mode = sensorinfo_xml.CISHdrSet.hdr_mode;
        sensor_info->CISHdrSet.line_mode = sensorinfo_xml.CISHdrSet.line_mode;

        sensor_info->CISFlip = sensorinfo_xml.CISFlip;
        sensor_info->CISMinFps = sensorinfo_xml.CISMinFps;
    }
}


void convertAecCalibV1ToCalibV2(const CamCalibDbContext_t *calib, CamCalibDbV2Context_t *calibV2) {

    //1. convert xml params 2 json params

    CalibDb_Aec_ParaV2_t aec_json;
    memset(&aec_json, 0x00, sizeof(CalibDb_Aec_ParaV2_t));

    if(CHECK_ISP_HW_V20()) {

        CalibDb_Aec_Para_t aec_xml =
            *(CalibDb_Aec_Para_t*)CALIBDB_GET_MODULE_PTR((void*)calib, aec);

        //1.2.0 CommCtrl
        aec_json.CommCtrl.Enable = (aec_xml.CommCtrl.enable == 0) ? false : true;
        aec_json.CommCtrl.AecRunInterval = aec_xml.CommCtrl.AecRunInterval;
        aec_json.CommCtrl.AecOpType = aec_xml.CommCtrl.AecOpType;
        aec_json.CommCtrl.HistStatsMode = (CalibDb_CamHistStatsModeV2_t)aec_xml.CommCtrl.HistStatsMode;
        switch(aec_xml.CommCtrl.RawStatsMode) {
        case CAM_RAWSTATS_MODE_R:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_R;
            break;
        case CAM_RAWSTATS_MODE_G:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_G;
            break;
        case CAM_RAWSTATS_MODE_B:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_B;
            break;
        case CAM_RAWSTATS_MODE_Y:
        default:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_Y;
            break;
        }

        if(aec_xml.CommCtrl.YRangeMode <= CAM_YRANGE_MODE_FULL)
            aec_json.CommCtrl.YRangeMode = CAM_YRANGEV2_MODE_FULL;
        else
            aec_json.CommCtrl.YRangeMode = CAM_YRANGEV2_MODE_LIMITED;

        if(aec_xml.CommCtrl.DayWeightNum == AECV2_MAX_GRIDWEIGHT_NUM) {
            for(int i = 0; i < AECV2_MAX_GRIDWEIGHT_NUM; i++)
                aec_json.CommCtrl.AecGridWeight[i] = aec_xml.CommCtrl.DayGridWeights.uCoeff[i];
        } else {
            AecGridWeight5x5to15x15(aec_xml.CommCtrl.DayGridWeights.uCoeff, aec_json.CommCtrl.AecGridWeight);
        }

        aec_json.CommCtrl.AecSpeed.SmoothEn = aec_xml.CommCtrl.stAuto.stAeSpeed.SmoothEn;
        aec_json.CommCtrl.AecSpeed.DyDampEn = aec_xml.CommCtrl.stAuto.stAeSpeed.DyDampEn;
        aec_json.CommCtrl.AecSpeed.DampOver = aec_xml.CommCtrl.stAuto.stAeSpeed.DampOver;
        aec_json.CommCtrl.AecSpeed.DampUnder = aec_xml.CommCtrl.stAuto.stAeSpeed.DampUnder;
        aec_json.CommCtrl.AecSpeed.DampBright2Dark = aec_xml.CommCtrl.stAuto.stAeSpeed.DampBright2Dark;
        aec_json.CommCtrl.AecSpeed.DampDark2Bright = aec_xml.CommCtrl.stAuto.stAeSpeed.DampDark2Bright;

        aec_json.CommCtrl.AecDelayFrmNum.BlackDelay = aec_xml.CommCtrl.stAuto.BlackDelayFrame;
        aec_json.CommCtrl.AecDelayFrmNum.WhiteDelay = aec_xml.CommCtrl.stAuto.WhiteDelayFrame;

        aec_json.CommCtrl.AecAntiFlicker.enable = aec_xml.CommCtrl.stAntiFlicker.enable;
        aec_json.CommCtrl.AecAntiFlicker.Frequency = (CalibDb_FlickerFreqV2_t)aec_xml.CommCtrl.stAntiFlicker.Frequency;
        if(aec_xml.CommCtrl.stAntiFlicker.Mode == AEC_ANTIFLICKER_AUTO_MODE)
            aec_json.CommCtrl.AecAntiFlicker.Mode = AECV2_ANTIFLICKER_AUTO_MODE;
        else
            aec_json.CommCtrl.AecAntiFlicker.Mode = AECV2_ANTIFLICKER_NORMAL_MODE;

        aec_json.CommCtrl.AecFrameRateMode.isFpsFix = aec_xml.CommCtrl.stAuto.stFrmRate.isFpsFix;
        aec_json.CommCtrl.AecFrameRateMode.FpsValue = aec_xml.CommCtrl.stAuto.stFrmRate.FpsValue;

        aec_json.CommCtrl.AecEnvLvCalib.CalibFNumber = aec_xml.CommCtrl.stEnvLvCalib.CalibFN;
        aec_json.CommCtrl.AecEnvLvCalib.CurveCoeff[0] = aec_xml.CommCtrl.stEnvLvCalib.Curve.fCoeff[0];
        aec_json.CommCtrl.AecEnvLvCalib.CurveCoeff[1] = aec_xml.CommCtrl.stEnvLvCalib.Curve.fCoeff[1];

        aec_json.CommCtrl.AecWinScale.InRawWinScale.h_offs = 0;
        aec_json.CommCtrl.AecWinScale.InRawWinScale.v_offs = 0;
        aec_json.CommCtrl.AecWinScale.InRawWinScale.h_size = 1;
        aec_json.CommCtrl.AecWinScale.InRawWinScale.v_size = 1;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.h_offs = 0;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.v_offs = 0;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.h_size = 1;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.v_size = 1;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.h_offs = 0.1;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.v_offs = 0.1;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.h_size = 0.8;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.v_size = 0.8;

        aec_json.CommCtrl.AecManualCtrl.LinearAE.ManualTimeEn = aec_xml.CommCtrl.stManual.stLinMe.ManualTimeEn;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.ManualGainEn = aec_xml.CommCtrl.stManual.stLinMe.ManualGainEn;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.ManualIspDgainEn = aec_xml.CommCtrl.stManual.stLinMe.ManualIspDgainEn;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.TimeValue = aec_xml.CommCtrl.stManual.stLinMe.TimeValue;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.GainValue = aec_xml.CommCtrl.stManual.stLinMe.GainValue;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.IspDGainValue = aec_xml.CommCtrl.stManual.stLinMe.IspDGainValue;

        aec_json.CommCtrl.AecManualCtrl.HdrAE.ManualTimeEn = aec_xml.CommCtrl.stManual.stHdrMe.ManualTimeEn;
        aec_json.CommCtrl.AecManualCtrl.HdrAE.ManualGainEn = aec_xml.CommCtrl.stManual.stHdrMe.ManualGainEn;
        aec_json.CommCtrl.AecManualCtrl.HdrAE.ManualIspDgainEn = aec_xml.CommCtrl.stManual.stHdrMe.ManualIspDgainEn;
        memcpy(aec_json.CommCtrl.AecManualCtrl.HdrAE.TimeValue, aec_xml.CommCtrl.stManual.stHdrMe.TimeValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.CommCtrl.AecManualCtrl.HdrAE.GainValue, aec_xml.CommCtrl.stManual.stHdrMe.GainValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.CommCtrl.AecManualCtrl.HdrAE.IspDGainValue, aec_xml.CommCtrl.stManual.stHdrMe.IspDGainValue.fCoeff, 3 * sizeof(float));

        //1.2.1 LinearAeCtrl
        aec_json.LinearAeCtrl.RawStatsEn = (aec_xml.LinearAeCtrl.RawStatsEn == 0) ? false : true;
        aec_json.LinearAeCtrl.Evbias = aec_xml.LinearAeCtrl.Evbias;
        aec_json.LinearAeCtrl.ToleranceIn = aec_xml.LinearAeCtrl.ToleranceIn;
        aec_json.LinearAeCtrl.ToleranceOut = aec_xml.LinearAeCtrl.ToleranceOut;
        if(aec_xml.LinearAeCtrl.StrategyMode <= RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR)
            aec_json.LinearAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_LOWLIGHT;
        else
            aec_json.LinearAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_HIGHLIGHT;

        aec_json.LinearAeCtrl.InitExp.InitTimeValue = aec_xml.CommCtrl.stInitExp.stLinExpInitExp.InitTimeValue;
        aec_json.LinearAeCtrl.InitExp.InitGainValue = aec_xml.CommCtrl.stInitExp.stLinExpInitExp.InitGainValue;
        aec_json.LinearAeCtrl.InitExp.InitIspDGainValue = aec_xml.CommCtrl.stInitExp.stLinExpInitExp.InitIspDGainValue;
        aec_json.LinearAeCtrl.InitExp.InitPIrisGainValue = aec_xml.CommCtrl.stInitExp.stLinExpInitExp.InitPIrisGainValue;
        aec_json.LinearAeCtrl.InitExp.InitDCIrisDutyValue = aec_xml.CommCtrl.stInitExp.stLinExpInitExp.InitDCIrisDutyValue;

        aec_json.LinearAeCtrl.Route.TimeDot_len = aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.LinearAeCtrl.Route.GainDot_len = aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.LinearAeCtrl.Route.IspDGainDot_len = aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.LinearAeCtrl.Route.PIrisDot_len = aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].array_size;

        aec_json.LinearAeCtrl.Route.TimeDot = (float*)malloc(aec_json.LinearAeCtrl.Route.TimeDot_len * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.Route.TimeDot, aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].TimeDot, aec_json.LinearAeCtrl.Route.TimeDot_len * sizeof(float));
        aec_json.LinearAeCtrl.Route.GainDot = (float*)malloc(aec_json.LinearAeCtrl.Route.GainDot_len * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.Route.GainDot, aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].GainDot, aec_json.LinearAeCtrl.Route.GainDot_len * sizeof(float));
        aec_json.LinearAeCtrl.Route.IspDGainDot = (float*)malloc(aec_json.LinearAeCtrl.Route.IspDGainDot_len * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.Route.IspDGainDot, aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].IspgainDot, aec_json.LinearAeCtrl.Route.IspDGainDot_len * sizeof(float));
        aec_json.LinearAeCtrl.Route.PIrisDot = (int*)malloc(aec_json.LinearAeCtrl.Route.PIrisDot_len * sizeof(int));
        memcpy(aec_json.LinearAeCtrl.Route.PIrisDot, aec_xml.CommCtrl.stAeRoute.LinAeSeperate[AEC_DNMODE_DAY].PIrisGainDot, aec_json.LinearAeCtrl.Route.PIrisDot_len * sizeof(float));


        aec_json.LinearAeCtrl.DySetpoint.ExpLevel_len = aec_xml.LinearAeCtrl.DySetpoint[AEC_DNMODE_DAY].array_size;
        aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len = aec_xml.LinearAeCtrl.DySetpoint[AEC_DNMODE_DAY].array_size;

        aec_json.LinearAeCtrl.DySetpoint.ExpLevel = (float*)malloc(aec_json.LinearAeCtrl.DySetpoint.ExpLevel_len * sizeof(float));
        aec_json.LinearAeCtrl.DySetpoint.DySetpoint = (float*)malloc(aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        float maxexp = aec_json.LinearAeCtrl.Route.TimeDot[aec_json.LinearAeCtrl.Route.TimeDot_len - 1] *
                       aec_json.LinearAeCtrl.Route.GainDot[aec_json.LinearAeCtrl.Route.GainDot_len - 1];
        for(int i = 0; i < aec_json.LinearAeCtrl.DySetpoint.ExpLevel_len; i++)
            aec_json.LinearAeCtrl.DySetpoint.ExpLevel[i] = maxexp * aec_xml.LinearAeCtrl.DySetpoint[AEC_DNMODE_DAY].ExpValue[i];

        if(aec_xml.LinearAeCtrl.DySetPointEn == false) {
            for(int i = 0; i < aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len; i++)
                aec_json.LinearAeCtrl.DySetpoint.DySetpoint[i] = aec_xml.LinearAeCtrl.SetPoint;
        } else {
            memcpy(aec_json.LinearAeCtrl.DySetpoint.DySetpoint, aec_xml.LinearAeCtrl.DySetpoint[AEC_DNMODE_DAY].DySetpoint, aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len * sizeof(float));
        }

        aec_json.LinearAeCtrl.BackLightCtrl.Enable = (aec_xml.LinearAeCtrl.BackLightConf.enable == 0) ? false : true;
        aec_json.LinearAeCtrl.BackLightCtrl.StrBias = aec_xml.LinearAeCtrl.BackLightConf.StrBias;
        aec_json.LinearAeCtrl.BackLightCtrl.MeasArea = (CalibDb_AecMeasAreaModeV2_t)aec_xml.LinearAeCtrl.BackLightConf.MeasArea;
        aec_json.LinearAeCtrl.BackLightCtrl.OEROILowTh = aec_xml.LinearAeCtrl.BackLightConf.OEROILowTh;
        aec_json.LinearAeCtrl.BackLightCtrl.LumaDistTh = aec_xml.LinearAeCtrl.BackLightConf.LumaDistTh;
        aec_json.LinearAeCtrl.BackLightCtrl.LvHighTh = aec_xml.LinearAeCtrl.BackLightConf.LvHightTh;
        aec_json.LinearAeCtrl.BackLightCtrl.LvLowTh = aec_xml.LinearAeCtrl.BackLightConf.LvLowTh;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.ExpLevel_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.TargetLLLuma_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.NonOEPdfTh_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.LowLightPdfTh_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.ExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++)
            aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.ExpLevel[i] = maxexp * aec_xml.LinearAeCtrl.BackLightConf.ExpLevel.fCoeff[i];
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.TargetLLLuma = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.TargetLLLuma, aec_xml.LinearAeCtrl.BackLightConf.TargetLLLuma.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.NonOEPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.NonOEPdfTh, aec_xml.LinearAeCtrl.BackLightConf.NonOEPdfTh.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.LowLightPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.LowLightPdfTh, aec_xml.LinearAeCtrl.BackLightConf.LowLightPdfTh.fCoeff, 6 * sizeof(float));

        aec_json.LinearAeCtrl.OverExpCtrl.Enable = (aec_xml.LinearAeCtrl.OverExpCtrl.enable == 0) ? false : true;
        aec_json.LinearAeCtrl.OverExpCtrl.StrBias = aec_xml.LinearAeCtrl.OverExpCtrl.StrBias;
        aec_json.LinearAeCtrl.OverExpCtrl.MaxWeight = aec_xml.LinearAeCtrl.OverExpCtrl.MaxWeight;
        aec_json.LinearAeCtrl.OverExpCtrl.HighLightTh = aec_xml.LinearAeCtrl.OverExpCtrl.HighLightTh;
        aec_json.LinearAeCtrl.OverExpCtrl.LowLightTh = aec_xml.LinearAeCtrl.OverExpCtrl.LowLightTh;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.HighLightWeight_len = 6;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.LowLightWeight_len = 6;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.OEpdf_len = 6;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.HighLightWeight = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.HighLightWeight, aec_xml.LinearAeCtrl.OverExpCtrl.HighLightWeight.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.LowLightWeight = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.LowLightWeight, aec_xml.LinearAeCtrl.OverExpCtrl.LowLightWeight.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.OEpdf = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.OEpdf, aec_xml.LinearAeCtrl.OverExpCtrl.OEpdf.fCoeff, 6 * sizeof(float));

        //1.2.2 HdrAeCtrl
        aec_json.HdrAeCtrl.ToleranceIn = aec_xml.HdrAeCtrl.ToleranceIn;
        aec_json.HdrAeCtrl.ToleranceOut = aec_xml.HdrAeCtrl.ToleranceOut;
        aec_json.HdrAeCtrl.Evbias = aec_xml.HdrAeCtrl.Evbias;
        aec_json.HdrAeCtrl.LumaDistTh = aec_xml.HdrAeCtrl.LumaDistTh;
        if(aec_xml.HdrAeCtrl.StrategyMode <= RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR)
            aec_json.HdrAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_LOWLIGHT;
        else
            aec_json.HdrAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_HIGHLIGHT;


        memcpy(aec_json.HdrAeCtrl.InitExp.InitTimeValue, aec_xml.CommCtrl.stInitExp.stHdrExpInitExp.InitTimeValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.InitExp.InitGainValue, aec_xml.CommCtrl.stInitExp.stHdrExpInitExp.InitGainValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.InitExp.InitIspDGainValue, aec_xml.CommCtrl.stInitExp.stHdrExpInitExp.InitIspDGainValue.fCoeff, 3 * sizeof(float));

        aec_json.HdrAeCtrl.InitExp.InitPIrisGainValue = aec_xml.CommCtrl.stInitExp.stHdrExpInitExp.InitPIrisGainValue;
        aec_json.HdrAeCtrl.InitExp.InitDCIrisDutyValue = aec_xml.CommCtrl.stInitExp.stHdrExpInitExp.InitDCIrisDutyValue;

        aec_json.HdrAeCtrl.Route.Frm0TimeDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm0GainDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm0IspDGainDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm1TimeDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm1GainDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm1IspDGainDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm2TimeDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm2GainDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.Frm2IspDGainDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;
        aec_json.HdrAeCtrl.Route.PIrisDot_len = aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].array_size;

        aec_json.HdrAeCtrl.Route.Frm0TimeDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm0TimeDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm0TimeDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrTimeDot[0], aec_json.HdrAeCtrl.Route.Frm0TimeDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm0GainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm0GainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm0GainDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrGainDot[0], aec_json.HdrAeCtrl.Route.Frm0GainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm0IspDGainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm0IspDGainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm0IspDGainDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrIspDGainDot[0], aec_json.HdrAeCtrl.Route.Frm0IspDGainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm1TimeDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm1TimeDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm1TimeDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrTimeDot[1], aec_json.HdrAeCtrl.Route.Frm1TimeDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm1GainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm1GainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm1GainDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrGainDot[1], aec_json.HdrAeCtrl.Route.Frm1GainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm1IspDGainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm1IspDGainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm1IspDGainDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrIspDGainDot[1], aec_json.HdrAeCtrl.Route.Frm1IspDGainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm2TimeDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm2TimeDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm2TimeDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrTimeDot[2], aec_json.HdrAeCtrl.Route.Frm2TimeDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm2GainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm2GainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm2GainDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrGainDot[2], aec_json.HdrAeCtrl.Route.Frm2GainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm2IspDGainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm2IspDGainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm2IspDGainDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].HdrIspDGainDot[2], aec_json.HdrAeCtrl.Route.Frm2IspDGainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.PIrisDot = (int*)malloc(aec_json.HdrAeCtrl.Route.PIrisDot_len * sizeof(int));
        memcpy(aec_json.HdrAeCtrl.Route.PIrisDot, aec_xml.CommCtrl.stAeRoute.HdrAeSeperate[AEC_DNMODE_DAY].PIrisGainDot, aec_json.HdrAeCtrl.Route.PIrisDot_len * sizeof(float));

        aec_json.HdrAeCtrl.LongFrmMode.mode = (CalibDb_AeHdrLongFrmModeV2_t)aec_xml.HdrAeCtrl.LongfrmMode;
        aec_json.HdrAeCtrl.LongFrmMode.SfrmMinLine = aec_xml.HdrAeCtrl.SfrmMinLine;
        aec_json.HdrAeCtrl.LongFrmMode.LfrmModeExpTh = aec_xml.HdrAeCtrl.LfrmModeExpTh;

        if(aec_xml.HdrAeCtrl.ExpRatioType <= RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO)
            aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatioType = AECV2_HDR_RATIOTYPE_MODE_AUTO;
        else
            aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatioType = AECV2_HDR_RATIOTYPE_MODE_FIX;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.RatioExpDot_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioFix_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioFix_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioMax_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioMax_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.RatioExpDot = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.RatioExpDot, aec_xml.HdrAeCtrl.RatioExpDot.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioFix = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioFix, aec_xml.HdrAeCtrl.M2SRatioFix.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioFix = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioFix, aec_xml.HdrAeCtrl.L2MRatioFix.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioMax = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioMax, aec_xml.HdrAeCtrl.M2SRatioMax.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioMax = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioMax, aec_xml.HdrAeCtrl.L2MRatioMax.fCoeff, 6 * sizeof(float));

        aec_json.HdrAeCtrl.LframeCtrl.LvHighTh = aec_xml.HdrAeCtrl.LframeCtrl.LvHighTh;
        aec_json.HdrAeCtrl.LframeCtrl.LvLowTh = aec_xml.HdrAeCtrl.LframeCtrl.LvLowTh;
        aec_json.HdrAeCtrl.LframeCtrl.OEROILowTh = aec_xml.HdrAeCtrl.LframeCtrl.OEROILowTh;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LExpLevel_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.NonOEPdfTh_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LowLightPdfTh_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LSetPoint_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.TargetLLLuma_len = 6;
        float lmaxexp = aec_json.HdrAeCtrl.Route.Frm1TimeDot[aec_json.HdrAeCtrl.Route.Frm1TimeDot_len - 1] *
                        aec_json.HdrAeCtrl.Route.Frm1GainDot[aec_json.HdrAeCtrl.Route.Frm1GainDot_len - 1];
        float mmaxexp = aec_json.HdrAeCtrl.Route.Frm1TimeDot[aec_json.HdrAeCtrl.Route.Frm1TimeDot_len - 1] *
                        aec_json.HdrAeCtrl.Route.Frm1GainDot[aec_json.HdrAeCtrl.Route.Frm1GainDot_len - 1];
        float smaxexp = aec_json.HdrAeCtrl.Route.Frm0TimeDot[aec_json.HdrAeCtrl.Route.Frm0TimeDot_len - 1] *
                        aec_json.HdrAeCtrl.Route.Frm0GainDot[aec_json.HdrAeCtrl.Route.Frm0GainDot_len - 1];
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++) {
            aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LExpLevel[i] = lmaxexp * aec_xml.HdrAeCtrl.LframeCtrl.LExpLevel.fCoeff[i];
        }
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.NonOEPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.NonOEPdfTh, aec_xml.HdrAeCtrl.LframeCtrl.NonOEPdfTh.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LowLightPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LowLightPdfTh, aec_xml.HdrAeCtrl.LframeCtrl.LowLightPdfTh.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LSetPoint = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LSetPoint, aec_xml.HdrAeCtrl.LframeCtrl.LSetPoint.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.TargetLLLuma = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.TargetLLLuma, aec_xml.HdrAeCtrl.LframeCtrl.TargetLLLuma.fCoeff, 6 * sizeof(float));

        aec_json.HdrAeCtrl.MframeCtrl.MExpLevel_len = 6;
        aec_json.HdrAeCtrl.MframeCtrl.MSetPoint_len = 6;
        aec_json.HdrAeCtrl.MframeCtrl.MExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++) {
            aec_json.HdrAeCtrl.MframeCtrl.MExpLevel[i] = mmaxexp * aec_xml.HdrAeCtrl.MframeCtrl.MExpLevel.fCoeff[i];
        }
        aec_json.HdrAeCtrl.MframeCtrl.MSetPoint = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.MframeCtrl.MSetPoint, aec_xml.HdrAeCtrl.MframeCtrl.MSetPoint.fCoeff, 6 * sizeof(float));


        aec_json.HdrAeCtrl.SframeCtrl.HLROIExpandEn = aec_xml.HdrAeCtrl.SframeCtrl.HLROIExpandEn;
        aec_json.HdrAeCtrl.SframeCtrl.HLLumaTolerance = aec_xml.HdrAeCtrl.SframeCtrl.HLLumaTolerance;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SExpLevel_len = 6;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SSetPoint_len = 6;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.TargetHLLuma_len = 6;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++) {
            aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SExpLevel[i] = smaxexp * aec_xml.HdrAeCtrl.SframeCtrl.SExpLevel.fCoeff[i];
        }
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SSetPoint = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SSetPoint, aec_xml.HdrAeCtrl.SframeCtrl.SSetPoint.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.TargetHLLuma = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.TargetHLLuma, aec_xml.HdrAeCtrl.SframeCtrl.TargetHLLuma.fCoeff, 6 * sizeof(float));

        //1.2.3 IrisCtrl
        aec_json.IrisCtrl.Enable = (aec_xml.CommCtrl.stIris.enable == 0) ? false : true;
        aec_json.IrisCtrl.IrisType = (CalibDb_IrisTypeV2_t)aec_xml.CommCtrl.stIris.IrisType;
        if(aec_xml.CommCtrl.AecOpType == RK_AIQ_OP_MODE_AUTO)
            aec_json.IrisCtrl.ManualEn = false;
        else
            aec_json.IrisCtrl.ManualEn = aec_xml.CommCtrl.stManual.stLinMe.ManualIrisEn;
        aec_json.IrisCtrl.ManualAttr.DCIrisHoldValue = aec_xml.CommCtrl.stManual.stLinMe.DCIrisValue;
        aec_json.IrisCtrl.ManualAttr.PIrisGainValue = aec_xml.CommCtrl.stManual.stLinMe.PIrisGainValue;
        aec_json.IrisCtrl.InitAttr.PIrisGainValue = aec_xml.CommCtrl.stInitExp.stLinExpInitExp.InitPIrisGainValue;
        aec_json.IrisCtrl.InitAttr.DCIrisHoldValue = aec_xml.CommCtrl.stInitExp.stLinExpInitExp.InitDCIrisDutyValue;
        aec_json.IrisCtrl.PIrisAttr.EffcStep = aec_xml.CommCtrl.stIris.PIrisAttr.EffcStep;
        aec_json.IrisCtrl.PIrisAttr.TotalStep = aec_xml.CommCtrl.stIris.PIrisAttr.TotalStep;
        aec_json.IrisCtrl.PIrisAttr.ZeroIsMax = aec_xml.CommCtrl.stIris.PIrisAttr.ZeroIsMax;
        memcpy(aec_json.IrisCtrl.PIrisAttr.StepTable, aec_xml.CommCtrl.stIris.PIrisAttr.StepTable, AECV2_PIRIS_STEP_TABLE_MAX * sizeof(uint16_t));
        aec_json.IrisCtrl.DCIrisAttr.Kp = aec_xml.CommCtrl.stIris.DCIrisAttr.Kp;
        aec_json.IrisCtrl.DCIrisAttr.Ki = aec_xml.CommCtrl.stIris.DCIrisAttr.Ki;
        aec_json.IrisCtrl.DCIrisAttr.Kd = aec_xml.CommCtrl.stIris.DCIrisAttr.Kd;
        aec_json.IrisCtrl.DCIrisAttr.MinPwmDuty = aec_xml.CommCtrl.stIris.DCIrisAttr.MinPwmDuty;
        aec_json.IrisCtrl.DCIrisAttr.MaxPwmDuty = aec_xml.CommCtrl.stIris.DCIrisAttr.MaxPwmDuty;
        aec_json.IrisCtrl.DCIrisAttr.OpenPwmDuty = aec_xml.CommCtrl.stIris.DCIrisAttr.OpenPwmDuty;
        aec_json.IrisCtrl.DCIrisAttr.ClosePwmDuty = aec_xml.CommCtrl.stIris.DCIrisAttr.ClosePwmDuty;

        //1.2.4 SyncTest
        aec_json.SyncTest.Enable = (aec_xml.CommCtrl.stSyncTest.enable == 0) ? false : true;
        aec_json.SyncTest.IntervalFrm = aec_xml.CommCtrl.stSyncTest.IntervalFrm;
        aec_json.SyncTest.AlterExp.HdrAE_len = aec_xml.CommCtrl.stSyncTest.HdrAlterExp.array_size;
        aec_json.SyncTest.AlterExp.HdrAE = (CalibDb_HdrAlterExpV2_t*)malloc(aec_xml.CommCtrl.stSyncTest.HdrAlterExp.array_size * sizeof(CalibDb_HdrAlterExpV2_t));
        for(int i = 0; i < aec_json.SyncTest.AlterExp.HdrAE_len; i++) {
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].TimeValue, aec_xml.CommCtrl.stSyncTest.HdrAlterExp.TimeValue[i], 3 * sizeof(float));
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].GainValue, aec_xml.CommCtrl.stSyncTest.HdrAlterExp.GainValue[i], 3 * sizeof(float));
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].IspDGainValue, aec_xml.CommCtrl.stSyncTest.HdrAlterExp.IspDGainValue[i], 3 * sizeof(float));
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].DcgMode, aec_xml.CommCtrl.stSyncTest.HdrAlterExp.DcgMode[i], 3 * sizeof(float));
            aec_json.SyncTest.AlterExp.HdrAE[i].PIrisGainValue = aec_xml.CommCtrl.stSyncTest.HdrAlterExp.PIrisGainValue[i];
        }
        aec_json.SyncTest.AlterExp.LinearAE_len = aec_xml.CommCtrl.stSyncTest.LinAlterExp.array_size;
        aec_json.SyncTest.AlterExp.LinearAE = (CalibDb_LinAlterExpV2_t*)malloc(aec_xml.CommCtrl.stSyncTest.LinAlterExp.array_size * sizeof(CalibDb_LinAlterExpV2_t));
        for(int i = 0; i < aec_json.SyncTest.AlterExp.LinearAE_len; i++) {
            aec_json.SyncTest.AlterExp.LinearAE[i].TimeValue = aec_xml.CommCtrl.stSyncTest.LinAlterExp.TimeValue[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].GainValue = aec_xml.CommCtrl.stSyncTest.LinAlterExp.GainValue[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].IspDGainValue = aec_xml.CommCtrl.stSyncTest.LinAlterExp.IspgainValue[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].DcgMode = aec_xml.CommCtrl.stSyncTest.LinAlterExp.DcgMode[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].PIrisGainValue = aec_xml.CommCtrl.stSyncTest.LinAlterExp.PIrisGainValue[i];
        }

    }


    if(CHECK_ISP_HW_V21()) {

        const CalibDb_Aec_CalibPara_t *aec_calib_xml = NULL;

        list_head *aec_calib_para_list =
            (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, ae_calib_para);

        if (aec_calib_para_list)
            GetAecProfileFromAecCalibListByIdx(aec_calib_para_list, 0, &aec_calib_xml);
        else
            return;

        const CalibDb_Aec_TunePara_t*aec_tune_xml = NULL;

        list_head *aec_tune_para_list =
            (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, ae_tuning_para);

        if (aec_tune_para_list)
            GetAecProfileFromAecTuneListByIdx(aec_tune_para_list, 0, &aec_tune_xml);
        else
            return;


        //1.2.0 CommCtrl
        aec_json.CommCtrl.Enable = (aec_tune_xml->CommCtrl.enable == 0) ? false : true;
        aec_json.CommCtrl.AecRunInterval = aec_tune_xml->CommCtrl.AecRunInterval;
        aec_json.CommCtrl.AecOpType = aec_tune_xml->CommCtrl.AecOpType;
        aec_json.CommCtrl.HistStatsMode = (CalibDb_CamHistStatsModeV2_t)aec_tune_xml->CommCtrl.HistStatsMode;
        switch(aec_tune_xml->CommCtrl.RawStatsMode) {
        case CAM_RAWSTATS_MODE_R:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_R;
            break;
        case CAM_RAWSTATS_MODE_G:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_G;
            break;
        case CAM_RAWSTATS_MODE_B:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_B;
            break;
        case CAM_RAWSTATS_MODE_Y:
        default:
            aec_json.CommCtrl.RawStatsMode = CAM_RAWSTATSV2_MODE_Y;
            break;
        }

        if(aec_tune_xml->CommCtrl.YRangeMode <= CAM_YRANGE_MODE_FULL)
            aec_json.CommCtrl.YRangeMode = CAM_YRANGEV2_MODE_FULL;
        else
            aec_json.CommCtrl.YRangeMode = CAM_YRANGEV2_MODE_LIMITED;

        for(int i = 0; i < AECV2_MAX_GRIDWEIGHT_NUM; i++)
            aec_json.CommCtrl.AecGridWeight[i] = aec_tune_xml->CommCtrl.GridWeights[i];

        aec_json.CommCtrl.AecSpeed.SmoothEn = aec_tune_xml->CommCtrl.stAuto.stAeSpeed.SmoothEn;
        aec_json.CommCtrl.AecSpeed.DyDampEn = aec_tune_xml->CommCtrl.stAuto.stAeSpeed.DyDampEn;
        aec_json.CommCtrl.AecSpeed.DampOver = aec_tune_xml->CommCtrl.stAuto.stAeSpeed.DampOver;
        aec_json.CommCtrl.AecSpeed.DampUnder = aec_tune_xml->CommCtrl.stAuto.stAeSpeed.DampUnder;
        aec_json.CommCtrl.AecSpeed.DampBright2Dark = aec_tune_xml->CommCtrl.stAuto.stAeSpeed.DampBright2Dark;
        aec_json.CommCtrl.AecSpeed.DampDark2Bright = aec_tune_xml->CommCtrl.stAuto.stAeSpeed.DampDark2Bright;

        aec_json.CommCtrl.AecDelayFrmNum.BlackDelay = aec_tune_xml->CommCtrl.stAuto.BlackDelayFrame;
        aec_json.CommCtrl.AecDelayFrmNum.WhiteDelay = aec_tune_xml->CommCtrl.stAuto.WhiteDelayFrame;

        aec_json.CommCtrl.AecAntiFlicker.enable = aec_tune_xml->CommCtrl.stAntiFlicker.enable;
        aec_json.CommCtrl.AecAntiFlicker.Frequency = (CalibDb_FlickerFreqV2_t)aec_tune_xml->CommCtrl.stAntiFlicker.Frequency;
        if(aec_tune_xml->CommCtrl.stAntiFlicker.Mode == AEC_ANTIFLICKER_AUTO_MODE)
            aec_json.CommCtrl.AecAntiFlicker.Mode = AECV2_ANTIFLICKER_AUTO_MODE;
        else
            aec_json.CommCtrl.AecAntiFlicker.Mode = AECV2_ANTIFLICKER_NORMAL_MODE;

        aec_json.CommCtrl.AecFrameRateMode.isFpsFix = aec_tune_xml->CommCtrl.stAuto.stFrmRate.isFpsFix;
        aec_json.CommCtrl.AecFrameRateMode.FpsValue = aec_tune_xml->CommCtrl.stAuto.stFrmRate.FpsValue;

        aec_json.CommCtrl.AecEnvLvCalib.CalibFNumber = aec_calib_xml->stEnvLvCalib.CalibFN;
        aec_json.CommCtrl.AecEnvLvCalib.CurveCoeff[0] = aec_calib_xml->stEnvLvCalib.Curve.fCoeff[0];
        aec_json.CommCtrl.AecEnvLvCalib.CurveCoeff[1] = aec_calib_xml->stEnvLvCalib.Curve.fCoeff[1];

        aec_json.CommCtrl.AecWinScale.InRawWinScale.h_offs = aec_calib_xml->InRawWinScale.h_offs;
        aec_json.CommCtrl.AecWinScale.InRawWinScale.v_offs = aec_calib_xml->InRawWinScale.v_offs;
        aec_json.CommCtrl.AecWinScale.InRawWinScale.h_size = aec_calib_xml->InRawWinScale.h_size;
        aec_json.CommCtrl.AecWinScale.InRawWinScale.v_size = aec_calib_xml->InRawWinScale.v_size;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.h_offs = aec_calib_xml->YuvWinScale.h_offs;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.v_offs = aec_calib_xml->YuvWinScale.v_offs;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.h_size = aec_calib_xml->YuvWinScale.h_size;
        aec_json.CommCtrl.AecWinScale.YuvWinScale.v_size = aec_calib_xml->YuvWinScale.v_size;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.h_offs = aec_calib_xml->TmoRawWinScale.h_offs;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.v_offs = aec_calib_xml->TmoRawWinScale.v_offs;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.h_size = aec_calib_xml->TmoRawWinScale.h_size;
        aec_json.CommCtrl.AecWinScale.TmoRawWinScale.v_size = aec_calib_xml->TmoRawWinScale.v_size;

        aec_json.CommCtrl.AecManualCtrl.LinearAE.ManualTimeEn = aec_tune_xml->CommCtrl.stManual.stLinMe.ManualTimeEn;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.ManualGainEn = aec_tune_xml->CommCtrl.stManual.stLinMe.ManualGainEn;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.ManualIspDgainEn = aec_tune_xml->CommCtrl.stManual.stLinMe.ManualIspDgainEn;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.TimeValue = aec_tune_xml->CommCtrl.stManual.stLinMe.TimeValue;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.GainValue = aec_tune_xml->CommCtrl.stManual.stLinMe.GainValue;
        aec_json.CommCtrl.AecManualCtrl.LinearAE.IspDGainValue = aec_tune_xml->CommCtrl.stManual.stLinMe.IspDGainValue;

        aec_json.CommCtrl.AecManualCtrl.HdrAE.ManualTimeEn = aec_tune_xml->CommCtrl.stManual.stHdrMe.ManualTimeEn;
        aec_json.CommCtrl.AecManualCtrl.HdrAE.ManualGainEn = aec_tune_xml->CommCtrl.stManual.stHdrMe.ManualGainEn;
        aec_json.CommCtrl.AecManualCtrl.HdrAE.ManualIspDgainEn = aec_tune_xml->CommCtrl.stManual.stHdrMe.ManualIspDgainEn;
        memcpy(aec_json.CommCtrl.AecManualCtrl.HdrAE.TimeValue, aec_tune_xml->CommCtrl.stManual.stHdrMe.TimeValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.CommCtrl.AecManualCtrl.HdrAE.GainValue, aec_tune_xml->CommCtrl.stManual.stHdrMe.GainValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.CommCtrl.AecManualCtrl.HdrAE.IspDGainValue, aec_tune_xml->CommCtrl.stManual.stHdrMe.IspDGainValue.fCoeff, 3 * sizeof(float));

        //1.2.1 LinearAeCtrl
        aec_json.LinearAeCtrl.RawStatsEn = (aec_tune_xml->LinearAeCtrl.RawStatsEn == 0) ? false : true;
        aec_json.LinearAeCtrl.Evbias = aec_tune_xml->LinearAeCtrl.Evbias;
        aec_json.LinearAeCtrl.ToleranceIn = aec_tune_xml->LinearAeCtrl.ToleranceIn;
        aec_json.LinearAeCtrl.ToleranceOut = aec_tune_xml->LinearAeCtrl.ToleranceOut;
        if(aec_tune_xml->LinearAeCtrl.StrategyMode <= RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR)
            aec_json.LinearAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_LOWLIGHT;
        else
            aec_json.LinearAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_HIGHLIGHT;

        aec_json.LinearAeCtrl.InitExp.InitTimeValue = aec_tune_xml->CommCtrl.stInitExp.stLinExpInitExp.InitTimeValue;
        aec_json.LinearAeCtrl.InitExp.InitGainValue = aec_tune_xml->CommCtrl.stInitExp.stLinExpInitExp.InitGainValue;
        aec_json.LinearAeCtrl.InitExp.InitIspDGainValue = aec_tune_xml->CommCtrl.stInitExp.stLinExpInitExp.InitIspDGainValue;
        aec_json.LinearAeCtrl.InitExp.InitPIrisGainValue = aec_tune_xml->CommCtrl.stInitExp.stLinExpInitExp.InitPIrisGainValue;
        aec_json.LinearAeCtrl.InitExp.InitDCIrisDutyValue = aec_tune_xml->CommCtrl.stInitExp.stLinExpInitExp.InitDCIrisDutyValue;

        aec_json.LinearAeCtrl.Route.TimeDot_len = aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.array_size;
        aec_json.LinearAeCtrl.Route.GainDot_len = aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.array_size;
        aec_json.LinearAeCtrl.Route.IspDGainDot_len = aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.array_size;
        aec_json.LinearAeCtrl.Route.PIrisDot_len = aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.array_size;

        aec_json.LinearAeCtrl.Route.TimeDot = (float*)malloc(aec_json.LinearAeCtrl.Route.TimeDot_len * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.Route.TimeDot, aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.TimeDot, aec_json.LinearAeCtrl.Route.TimeDot_len * sizeof(float));
        aec_json.LinearAeCtrl.Route.GainDot = (float*)malloc(aec_json.LinearAeCtrl.Route.GainDot_len * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.Route.GainDot, aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.GainDot, aec_json.LinearAeCtrl.Route.GainDot_len * sizeof(float));
        aec_json.LinearAeCtrl.Route.IspDGainDot = (float*)malloc(aec_json.LinearAeCtrl.Route.IspDGainDot_len * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.Route.IspDGainDot, aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.IspgainDot, aec_json.LinearAeCtrl.Route.IspDGainDot_len * sizeof(float));
        aec_json.LinearAeCtrl.Route.PIrisDot = (int*)malloc(aec_json.LinearAeCtrl.Route.PIrisDot_len * sizeof(int));
        memcpy(aec_json.LinearAeCtrl.Route.PIrisDot, aec_tune_xml->CommCtrl.stAeRoute.LinAeSeperate.PIrisGainDot, aec_json.LinearAeCtrl.Route.PIrisDot_len * sizeof(float));


        aec_json.LinearAeCtrl.DySetpoint.ExpLevel_len = aec_tune_xml->LinearAeCtrl.DySetpoint.array_size;
        aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len = aec_tune_xml->LinearAeCtrl.DySetpoint.array_size;

        aec_json.LinearAeCtrl.DySetpoint.ExpLevel = (float*)malloc(aec_json.LinearAeCtrl.DySetpoint.ExpLevel_len * sizeof(float));
        aec_json.LinearAeCtrl.DySetpoint.DySetpoint = (float*)malloc(aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        float maxexp = aec_json.LinearAeCtrl.Route.TimeDot[aec_json.LinearAeCtrl.Route.TimeDot_len - 1] *
                       aec_json.LinearAeCtrl.Route.GainDot[aec_json.LinearAeCtrl.Route.GainDot_len - 1];
        for(int i = 0; i < aec_json.LinearAeCtrl.DySetpoint.ExpLevel_len; i++)
            aec_json.LinearAeCtrl.DySetpoint.ExpLevel[i] = maxexp * aec_tune_xml->LinearAeCtrl.DySetpoint.ExpValue[i];

        if(aec_tune_xml->LinearAeCtrl.DySetPointEn == false) {
            for(int i = 0; i < aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len; i++)
                aec_json.LinearAeCtrl.DySetpoint.DySetpoint[i] = aec_tune_xml->LinearAeCtrl.SetPoint;
        } else {
            memcpy(aec_json.LinearAeCtrl.DySetpoint.DySetpoint, aec_tune_xml->LinearAeCtrl.DySetpoint.DySetpoint, aec_json.LinearAeCtrl.DySetpoint.DySetpoint_len * sizeof(float));
        }

        aec_json.LinearAeCtrl.BackLightCtrl.Enable = (aec_tune_xml->LinearAeCtrl.BackLightConf.enable == 0) ? false : true;
        aec_json.LinearAeCtrl.BackLightCtrl.StrBias = aec_tune_xml->LinearAeCtrl.BackLightConf.StrBias;
        aec_json.LinearAeCtrl.BackLightCtrl.MeasArea = (CalibDb_AecMeasAreaModeV2_t)aec_tune_xml->LinearAeCtrl.BackLightConf.MeasArea;
        aec_json.LinearAeCtrl.BackLightCtrl.OEROILowTh = aec_tune_xml->LinearAeCtrl.BackLightConf.OEROILowTh;
        aec_json.LinearAeCtrl.BackLightCtrl.LumaDistTh = aec_tune_xml->LinearAeCtrl.BackLightConf.LumaDistTh;
        aec_json.LinearAeCtrl.BackLightCtrl.LvHighTh = aec_tune_xml->LinearAeCtrl.BackLightConf.LvHightTh;
        aec_json.LinearAeCtrl.BackLightCtrl.LvLowTh = aec_tune_xml->LinearAeCtrl.BackLightConf.LvLowTh;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.ExpLevel_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.TargetLLLuma_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.NonOEPdfTh_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.LowLightPdfTh_len = 6;
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.ExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++)
            aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.ExpLevel[i] = maxexp * aec_tune_xml->LinearAeCtrl.BackLightConf.ExpLevel.fCoeff[i];
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.TargetLLLuma = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.TargetLLLuma, aec_tune_xml->LinearAeCtrl.BackLightConf.TargetLLLuma.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.NonOEPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.NonOEPdfTh, aec_tune_xml->LinearAeCtrl.BackLightConf.NonOEPdfTh.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.LowLightPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.BackLightCtrl.BacklitSetPoint.LowLightPdfTh, aec_tune_xml->LinearAeCtrl.BackLightConf.LowLightPdfTh.fCoeff, 6 * sizeof(float));

        aec_json.LinearAeCtrl.OverExpCtrl.Enable = (aec_tune_xml->LinearAeCtrl.OverExpCtrl.enable == 0) ? false : true;
        aec_json.LinearAeCtrl.OverExpCtrl.StrBias = aec_tune_xml->LinearAeCtrl.OverExpCtrl.StrBias;
        aec_json.LinearAeCtrl.OverExpCtrl.MaxWeight = aec_tune_xml->LinearAeCtrl.OverExpCtrl.MaxWeight;
        aec_json.LinearAeCtrl.OverExpCtrl.HighLightTh = aec_tune_xml->LinearAeCtrl.OverExpCtrl.HighLightTh;
        aec_json.LinearAeCtrl.OverExpCtrl.LowLightTh = aec_tune_xml->LinearAeCtrl.OverExpCtrl.LowLightTh;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.HighLightWeight_len = 6;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.LowLightWeight_len = 6;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.OEpdf_len = 6;
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.HighLightWeight = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.HighLightWeight, aec_tune_xml->LinearAeCtrl.OverExpCtrl.HighLightWeight.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.LowLightWeight = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.LowLightWeight, aec_tune_xml->LinearAeCtrl.OverExpCtrl.LowLightWeight.fCoeff, 6 * sizeof(float));
        aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.OEpdf = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.LinearAeCtrl.OverExpCtrl.OverExpSetPoint.OEpdf, aec_tune_xml->LinearAeCtrl.OverExpCtrl.OEpdf.fCoeff, 6 * sizeof(float));

        //1.2.2 HdrAeCtrl
        aec_json.HdrAeCtrl.ToleranceIn = aec_tune_xml->HdrAeCtrl.ToleranceIn;
        aec_json.HdrAeCtrl.ToleranceOut = aec_tune_xml->HdrAeCtrl.ToleranceOut;
        aec_json.HdrAeCtrl.Evbias = aec_tune_xml->HdrAeCtrl.Evbias;
        aec_json.HdrAeCtrl.LumaDistTh = aec_tune_xml->HdrAeCtrl.LumaDistTh;
        if(aec_tune_xml->HdrAeCtrl.StrategyMode <= RKAIQ_AEC_STRATEGY_MODE_LOWLIGHT_PRIOR)
            aec_json.HdrAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_LOWLIGHT;
        else
            aec_json.HdrAeCtrl.StrategyMode = AECV2_STRATEGY_MODE_HIGHLIGHT;


        memcpy(aec_json.HdrAeCtrl.InitExp.InitTimeValue, aec_tune_xml->CommCtrl.stInitExp.stHdrExpInitExp.InitTimeValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.InitExp.InitGainValue, aec_tune_xml->CommCtrl.stInitExp.stHdrExpInitExp.InitGainValue.fCoeff, 3 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.InitExp.InitIspDGainValue, aec_tune_xml->CommCtrl.stInitExp.stHdrExpInitExp.InitIspDGainValue.fCoeff, 3 * sizeof(float));

        aec_json.HdrAeCtrl.InitExp.InitPIrisGainValue = aec_tune_xml->CommCtrl.stInitExp.stHdrExpInitExp.InitPIrisGainValue;
        aec_json.HdrAeCtrl.InitExp.InitDCIrisDutyValue = aec_tune_xml->CommCtrl.stInitExp.stHdrExpInitExp.InitDCIrisDutyValue;

        aec_json.HdrAeCtrl.Route.Frm0TimeDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm0GainDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm0IspDGainDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm1TimeDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm1GainDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm1IspDGainDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm2TimeDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm2GainDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.Frm2IspDGainDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;
        aec_json.HdrAeCtrl.Route.PIrisDot_len = aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.array_size;

        aec_json.HdrAeCtrl.Route.Frm0TimeDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm0TimeDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm0TimeDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrTimeDot[0], aec_json.HdrAeCtrl.Route.Frm0TimeDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm0GainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm0GainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm0GainDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrGainDot[0], aec_json.HdrAeCtrl.Route.Frm0GainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm0IspDGainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm0IspDGainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm0IspDGainDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrIspDGainDot[0], aec_json.HdrAeCtrl.Route.Frm0IspDGainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm1TimeDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm1TimeDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm1TimeDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrTimeDot[1], aec_json.HdrAeCtrl.Route.Frm1TimeDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm1GainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm1GainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm1GainDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrGainDot[1], aec_json.HdrAeCtrl.Route.Frm1GainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm1IspDGainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm1IspDGainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm1IspDGainDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrIspDGainDot[1], aec_json.HdrAeCtrl.Route.Frm1IspDGainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm2TimeDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm2TimeDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm2TimeDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrTimeDot[2], aec_json.HdrAeCtrl.Route.Frm2TimeDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm2GainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm2GainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm2GainDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrGainDot[2], aec_json.HdrAeCtrl.Route.Frm2GainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.Frm2IspDGainDot = (float*)malloc(aec_json.HdrAeCtrl.Route.Frm2IspDGainDot_len * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.Route.Frm2IspDGainDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.HdrIspDGainDot[2], aec_json.HdrAeCtrl.Route.Frm2IspDGainDot_len * sizeof(float));
        aec_json.HdrAeCtrl.Route.PIrisDot = (int*)malloc(aec_json.HdrAeCtrl.Route.PIrisDot_len * sizeof(int));
        memcpy(aec_json.HdrAeCtrl.Route.PIrisDot, aec_tune_xml->CommCtrl.stAeRoute.HdrAeSeperate.PIrisGainDot, aec_json.HdrAeCtrl.Route.PIrisDot_len * sizeof(float));

        aec_json.HdrAeCtrl.LongFrmMode.mode = (CalibDb_AeHdrLongFrmModeV2_t)aec_tune_xml->HdrAeCtrl.LongfrmMode;
        aec_json.HdrAeCtrl.LongFrmMode.SfrmMinLine = aec_tune_xml->HdrAeCtrl.SfrmMinLine;
        aec_json.HdrAeCtrl.LongFrmMode.LfrmModeExpTh = aec_tune_xml->HdrAeCtrl.LfrmModeExpTh;

        if(aec_tune_xml->HdrAeCtrl.ExpRatioType <= RKAIQ_HDRAE_RATIOTYPE_MODE_AUTO)
            aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatioType = AECV2_HDR_RATIOTYPE_MODE_AUTO;
        else
            aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatioType = AECV2_HDR_RATIOTYPE_MODE_FIX;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.RatioExpDot_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioFix_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioFix_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioMax_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioMax_len = 6;
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.RatioExpDot = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.RatioExpDot, aec_tune_xml->HdrAeCtrl.RatioExpDot.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioFix = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioFix, aec_tune_xml->HdrAeCtrl.M2SRatioFix.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioFix = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioFix, aec_tune_xml->HdrAeCtrl.L2MRatioFix.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioMax = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.M2SRatioMax, aec_tune_xml->HdrAeCtrl.M2SRatioMax.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioMax = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.ExpRatioCtrl.ExpRatio.L2MRatioMax, aec_tune_xml->HdrAeCtrl.L2MRatioMax.fCoeff, 6 * sizeof(float));

        aec_json.HdrAeCtrl.LframeCtrl.LvHighTh = aec_tune_xml->HdrAeCtrl.LframeCtrl.LvHighTh;
        aec_json.HdrAeCtrl.LframeCtrl.LvLowTh = aec_tune_xml->HdrAeCtrl.LframeCtrl.LvLowTh;
        aec_json.HdrAeCtrl.LframeCtrl.OEROILowTh = aec_tune_xml->HdrAeCtrl.LframeCtrl.OEROILowTh;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LExpLevel_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.NonOEPdfTh_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LowLightPdfTh_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LSetPoint_len = 6;
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.TargetLLLuma_len = 6;
        float lmaxexp = aec_json.HdrAeCtrl.Route.Frm1TimeDot[aec_json.HdrAeCtrl.Route.Frm1TimeDot_len - 1] *
                        aec_json.HdrAeCtrl.Route.Frm1GainDot[aec_json.HdrAeCtrl.Route.Frm1GainDot_len - 1];
        float mmaxexp = aec_json.HdrAeCtrl.Route.Frm1TimeDot[aec_json.HdrAeCtrl.Route.Frm1TimeDot_len - 1] *
                        aec_json.HdrAeCtrl.Route.Frm1GainDot[aec_json.HdrAeCtrl.Route.Frm1GainDot_len - 1];
        float smaxexp = aec_json.HdrAeCtrl.Route.Frm0TimeDot[aec_json.HdrAeCtrl.Route.Frm0TimeDot_len - 1] *
                        aec_json.HdrAeCtrl.Route.Frm0GainDot[aec_json.HdrAeCtrl.Route.Frm0GainDot_len - 1];
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++) {
            aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LExpLevel[i] = lmaxexp * aec_tune_xml->HdrAeCtrl.LframeCtrl.LExpLevel.fCoeff[i];
        }
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.NonOEPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.NonOEPdfTh, aec_tune_xml->HdrAeCtrl.LframeCtrl.NonOEPdfTh.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LowLightPdfTh = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LowLightPdfTh, aec_tune_xml->HdrAeCtrl.LframeCtrl.LowLightPdfTh.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LSetPoint = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.LSetPoint, aec_tune_xml->HdrAeCtrl.LframeCtrl.LSetPoint.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.TargetLLLuma = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.LframeCtrl.LfrmSetPoint.TargetLLLuma, aec_tune_xml->HdrAeCtrl.LframeCtrl.TargetLLLuma.fCoeff, 6 * sizeof(float));

        aec_json.HdrAeCtrl.MframeCtrl.MExpLevel_len = 6;
        aec_json.HdrAeCtrl.MframeCtrl.MSetPoint_len = 6;
        aec_json.HdrAeCtrl.MframeCtrl.MExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++) {
            aec_json.HdrAeCtrl.MframeCtrl.MExpLevel[i] = mmaxexp * aec_tune_xml->HdrAeCtrl.MframeCtrl.MExpLevel.fCoeff[i];
        }
        aec_json.HdrAeCtrl.MframeCtrl.MSetPoint = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.MframeCtrl.MSetPoint, aec_tune_xml->HdrAeCtrl.MframeCtrl.MSetPoint.fCoeff, 6 * sizeof(float));


        aec_json.HdrAeCtrl.SframeCtrl.HLROIExpandEn = aec_tune_xml->HdrAeCtrl.SframeCtrl.HLROIExpandEn;
        aec_json.HdrAeCtrl.SframeCtrl.HLLumaTolerance = aec_tune_xml->HdrAeCtrl.SframeCtrl.HLLumaTolerance;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SExpLevel_len = 6;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SSetPoint_len = 6;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.TargetHLLuma_len = 6;
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SExpLevel = (float*)malloc(6 * sizeof(float));
        /*NOTE: use exp value here, not curexp/maxexp*/
        for(int i = 0; i < 6; i++) {
            aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SExpLevel[i] = smaxexp * aec_tune_xml->HdrAeCtrl.SframeCtrl.SExpLevel.fCoeff[i];
        }
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SSetPoint = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.SSetPoint, aec_tune_xml->HdrAeCtrl.SframeCtrl.SSetPoint.fCoeff, 6 * sizeof(float));
        aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.TargetHLLuma = (float*)malloc(6 * sizeof(float));
        memcpy(aec_json.HdrAeCtrl.SframeCtrl.SfrmSetPoint.TargetHLLuma, aec_tune_xml->HdrAeCtrl.SframeCtrl.TargetHLLuma.fCoeff, 6 * sizeof(float));

        //1.2.3 IrisCtrl
        aec_json.IrisCtrl.Enable = (aec_tune_xml->CommCtrl.stIris.enable == 0) ? false : true;
        aec_json.IrisCtrl.IrisType = (CalibDb_IrisTypeV2_t)aec_tune_xml->CommCtrl.stIris.IrisType;
        if(aec_tune_xml->CommCtrl.AecOpType == RK_AIQ_OP_MODE_AUTO)
            aec_json.IrisCtrl.ManualEn = false;
        else
            aec_json.IrisCtrl.ManualEn = aec_tune_xml->CommCtrl.stManual.stLinMe.ManualIrisEn;
        aec_json.IrisCtrl.ManualAttr.DCIrisHoldValue = aec_tune_xml->CommCtrl.stManual.stLinMe.DCIrisValue;
        aec_json.IrisCtrl.ManualAttr.PIrisGainValue = aec_tune_xml->CommCtrl.stManual.stLinMe.PIrisGainValue;
        aec_json.IrisCtrl.InitAttr.PIrisGainValue = aec_tune_xml->CommCtrl.stInitExp.stLinExpInitExp.InitPIrisGainValue;
        aec_json.IrisCtrl.InitAttr.DCIrisHoldValue = aec_tune_xml->CommCtrl.stInitExp.stLinExpInitExp.InitDCIrisDutyValue;
        aec_json.IrisCtrl.PIrisAttr.EffcStep = aec_tune_xml->CommCtrl.stIris.PIrisAttr.EffcStep;
        aec_json.IrisCtrl.PIrisAttr.TotalStep = aec_tune_xml->CommCtrl.stIris.PIrisAttr.TotalStep;
        aec_json.IrisCtrl.PIrisAttr.ZeroIsMax = aec_tune_xml->CommCtrl.stIris.PIrisAttr.ZeroIsMax;
        memcpy(aec_json.IrisCtrl.PIrisAttr.StepTable, aec_tune_xml->CommCtrl.stIris.PIrisAttr.StepTable, AECV2_PIRIS_STEP_TABLE_MAX * sizeof(uint16_t));
        aec_json.IrisCtrl.DCIrisAttr.Kp = aec_tune_xml->CommCtrl.stIris.DCIrisAttr.Kp;
        aec_json.IrisCtrl.DCIrisAttr.Ki = aec_tune_xml->CommCtrl.stIris.DCIrisAttr.Ki;
        aec_json.IrisCtrl.DCIrisAttr.Kd = aec_tune_xml->CommCtrl.stIris.DCIrisAttr.Kd;
        aec_json.IrisCtrl.DCIrisAttr.MinPwmDuty = aec_tune_xml->CommCtrl.stIris.DCIrisAttr.MinPwmDuty;
        aec_json.IrisCtrl.DCIrisAttr.MaxPwmDuty = aec_tune_xml->CommCtrl.stIris.DCIrisAttr.MaxPwmDuty;
        aec_json.IrisCtrl.DCIrisAttr.OpenPwmDuty = aec_tune_xml->CommCtrl.stIris.DCIrisAttr.OpenPwmDuty;
        aec_json.IrisCtrl.DCIrisAttr.ClosePwmDuty = aec_tune_xml->CommCtrl.stIris.DCIrisAttr.ClosePwmDuty;

        //1.2.4 SyncTest
        aec_json.SyncTest.Enable = (aec_tune_xml->CommCtrl.stSyncTest.enable == 0) ? false : true;
        aec_json.SyncTest.IntervalFrm = aec_tune_xml->CommCtrl.stSyncTest.IntervalFrm;
        aec_json.SyncTest.AlterExp.HdrAE_len = aec_tune_xml->CommCtrl.stSyncTest.HdrAlterExp.array_size;
        aec_json.SyncTest.AlterExp.HdrAE = (CalibDb_HdrAlterExpV2_t*)malloc(aec_tune_xml->CommCtrl.stSyncTest.HdrAlterExp.array_size * sizeof(CalibDb_HdrAlterExpV2_t));
        for(int i = 0; i < aec_json.SyncTest.AlterExp.HdrAE_len; i++) {
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].TimeValue, aec_tune_xml->CommCtrl.stSyncTest.HdrAlterExp.TimeValue[i], 3 * sizeof(float));
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].GainValue, aec_tune_xml->CommCtrl.stSyncTest.HdrAlterExp.GainValue[i], 3 * sizeof(float));
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].IspDGainValue, aec_tune_xml->CommCtrl.stSyncTest.HdrAlterExp.IspDGainValue[i], 3 * sizeof(float));
            memcpy(aec_json.SyncTest.AlterExp.HdrAE[i].DcgMode, aec_tune_xml->CommCtrl.stSyncTest.HdrAlterExp.DcgMode[i], 3 * sizeof(float));
            aec_json.SyncTest.AlterExp.HdrAE[i].PIrisGainValue = aec_tune_xml->CommCtrl.stSyncTest.HdrAlterExp.PIrisGainValue[i];
        }
        aec_json.SyncTest.AlterExp.LinearAE_len = aec_tune_xml->CommCtrl.stSyncTest.LinAlterExp.array_size;
        aec_json.SyncTest.AlterExp.LinearAE = (CalibDb_LinAlterExpV2_t*)malloc(aec_tune_xml->CommCtrl.stSyncTest.LinAlterExp.array_size * sizeof(CalibDb_LinAlterExpV2_t));
        for(int i = 0; i < aec_json.SyncTest.AlterExp.LinearAE_len; i++) {
            aec_json.SyncTest.AlterExp.LinearAE[i].TimeValue = aec_tune_xml->CommCtrl.stSyncTest.LinAlterExp.TimeValue[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].GainValue = aec_tune_xml->CommCtrl.stSyncTest.LinAlterExp.GainValue[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].IspDGainValue = aec_tune_xml->CommCtrl.stSyncTest.LinAlterExp.IspgainValue[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].DcgMode = aec_tune_xml->CommCtrl.stSyncTest.LinAlterExp.DcgMode[i];
            aec_json.SyncTest.AlterExp.LinearAE[i].PIrisGainValue = aec_tune_xml->CommCtrl.stSyncTest.LinAlterExp.PIrisGainValue[i];
        }

    }

    CalibDb_Aec_ParaV2_t* calibv2_ae_calib =
        (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, ae_calib));
    *calibv2_ae_calib = aec_json;

}