#include "awb_xml2json.h"
#include "RkAiqCalibApi.h"

void CalibV2AwbV21Free(CamCalibDbV2Context_t *calibV2)
{
    CalibDbV2_Wb_Para_V21_t* wb_v21 =
            (CalibDbV2_Wb_Para_V21_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v21));
    if(wb_v21 == NULL){
          return;
    }
    CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV21 = &wb_v21->autoExtPara;
    CalibDbV2_Wb_Awb_Para_V21_t* autoParaV21 =  &wb_v21->autoPara;
    free(commV21->lightSourceForFirstFrame);
    free(commV21->wbGainClip.cct);
    free(commV21->wbGainClip.cri_bound_up);
    free(commV21->wbGainClip.cri_bound_low);
    free(commV21->singleColorProces.colorBlock);
    for(int i=0;i<commV21->singleColorProces.lsUsedForEstimation_len;i++){
           free(commV21->singleColorProces.lsUsedForEstimation[i].name);
    }
    free(commV21->singleColorProces.lsUsedForEstimation);
    free(commV21->tolerance.toleranceValue);
    free(commV21->tolerance.lumaValue);
    free(commV21->runInterval.intervalValue);
    free(commV21->runInterval.lumaValue);
    for(int i=0;i<commV21->wbGainAdjust.lutAll_len;i++){
        free(commV21->wbGainAdjust.lutAll[i].ct_lut_out);
        free(commV21->wbGainAdjust.lutAll[i].cri_lut_out);
    }
    free(commV21->wbGainAdjust.lutAll);
    free(commV21->weightForNightGainCalc);
    free(commV21->division.wpNumTh.high);
    free(commV21->division.wpNumTh.low);
    free(commV21->division.wpNumTh.lumaValue);
    free(commV21->xyRegionStableSelection.wpNumTh.lumaValue);
    free(commV21->xyRegionStableSelection.wpNumTh.forBigType);
    free(commV21->xyRegionStableSelection.wpNumTh.forExtraType);
    for(int i=0;i<autoParaV21->lsUsedForYuvDet_len;i++){
        free(autoParaV21->lsUsedForYuvDet[i]);
    }
    free(autoParaV21->lsUsedForYuvDet);
    for(int i=0;i<autoParaV21->lightSources_len;i++){
        free(autoParaV21->lightSources[i].name);
    }
    free(autoParaV21->lightSources);
    free(autoParaV21->limitRange.lumaValue);
    free(autoParaV21->limitRange.maxB);
    free(autoParaV21->limitRange.maxR);
    free(autoParaV21->limitRange.maxG);
    free(autoParaV21->limitRange.maxY);
    free(autoParaV21->limitRange.minB);
    free(autoParaV21->limitRange.minR);
    free(autoParaV21->limitRange.minG);
    free(autoParaV21->limitRange.minY);
}
void convertCalib2calibV21(const CamCalibDbContext_t *calib,CamCalibDbV2Context_t *calibV2)
{
    const CalibDb_Awb_Calib_Para_V201_t *awb_calib_v21 = NULL;

    list_head *awb_calib_para_list =
        (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_calib_para_v201);

    if (awb_calib_para_list)
        GetAwbProfileFromAwbCalibV201ListByIdx(awb_calib_para_list, 0, &awb_calib_v21);
    else
        return;

    const CalibDb_Awb_Adjust_Para_t *awb_adjust = NULL;

    list_head *awb_adjust_list =
        (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_adjust_para);

    if (awb_adjust_list)
        GetAwbProfileFromAwbAdjustListByIdx(awb_adjust_list, 0, &awb_adjust);
    else
        return;

    CalibDbV2_Wb_Para_V21_t* wb_v21 =
            (CalibDbV2_Wb_Para_V21_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v21));
    memset(wb_v21, 0, sizeof(CalibDbV2_Wb_Para_V21_t));
    CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV21 = &wb_v21->autoExtPara;
    CalibDbV2_Wb_Awb_Para_V21_t* autoParaV21 =  &wb_v21->autoPara;
    commV21->lightSourceForFirstFrame= (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    commV21->wbGainClip.cct_len = awb_calib_v21->cct_clip_cfg.grid_num;
    commV21->wbGainClip.cri_bound_up_len = awb_calib_v21->cct_clip_cfg.grid_num;
    commV21->wbGainClip.cri_bound_low_len = awb_calib_v21->cct_clip_cfg.grid_num;
    commV21->wbGainClip.cct = (float*)malloc(sizeof(float) * commV21->wbGainClip.cct_len);
    commV21->wbGainClip.cri_bound_up = (float*)malloc(sizeof(float) * commV21->wbGainClip.cct_len);
    commV21->wbGainClip.cri_bound_low = (float*)malloc(sizeof(float) * commV21->wbGainClip.cct_len);
    commV21->singleColorProces.colorBlock_len = awb_calib_v21->sSelColorNUM;
    commV21->singleColorProces.lsUsedForEstimation_len = awb_calib_v21->sIllEstNum;
    commV21->singleColorProces.colorBlock = (CalibDbV2_Awb_Sgc_Cblk_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Cblk_t)*commV21->singleColorProces.colorBlock_len);
    commV21->singleColorProces.lsUsedForEstimation = (CalibDbV2_Awb_Sgc_Ls_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Ls_t)*commV21->singleColorProces.lsUsedForEstimation_len);
    for(int i=0;i<commV21->singleColorProces.lsUsedForEstimation_len;i++){
           commV21->singleColorProces.lsUsedForEstimation[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    }
    commV21->tolerance.lumaValue_len = awb_adjust->tolerance.num;
    commV21->tolerance.toleranceValue_len = awb_adjust->tolerance.num;
    commV21->tolerance.toleranceValue = (float*)malloc(sizeof(float)*commV21->tolerance.toleranceValue_len);
    commV21->tolerance.lumaValue= (float*)malloc(sizeof(float)*commV21->tolerance.lumaValue_len);
    commV21->runInterval.lumaValue_len = awb_adjust->runInterval.num;
    commV21->runInterval.intervalValue_len= awb_adjust->runInterval.num;
    commV21->runInterval.intervalValue = (float*)malloc(sizeof(float)*commV21->runInterval.intervalValue_len);
    commV21->runInterval.lumaValue= (float*)malloc(sizeof(float)*commV21->runInterval.lumaValue_len);
    commV21->wbGainAdjust.lutAll_len = awb_adjust->cct_lut_cfg_num;
    commV21->wbGainAdjust.lutAll = (CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t*)malloc(sizeof(CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t)*commV21->wbGainAdjust.lutAll_len);
    for(int i=0;i<commV21->wbGainAdjust.lutAll_len;i++){
        commV21->wbGainAdjust.lutAll[i].ct_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num *  awb_adjust->cct_lut_cfg[0].cri_grid_num;
        commV21->wbGainAdjust.lutAll[i].ct_lut_out = (float*)malloc(sizeof(float)*commV21->wbGainAdjust.lutAll[i].ct_lut_out_len);
        commV21->wbGainAdjust.lutAll[i].cri_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num *  awb_adjust->cct_lut_cfg[0].cri_grid_num;
        commV21->wbGainAdjust.lutAll[i].cri_lut_out = (float*)malloc(sizeof(float)*commV21->wbGainAdjust.lutAll[i].cri_lut_out_len);
    }
    commV21->weightForNightGainCalc_len = 4;
    commV21->weightForNightGainCalc = (unsigned char*)malloc(sizeof(unsigned char)*commV21->weightForNightGainCalc_len);
    autoParaV21->lsUsedForYuvDet_len = 7;
    autoParaV21->lsUsedForYuvDet = (char**)malloc(sizeof(char*)*autoParaV21->lsUsedForYuvDet_len);
    for(int i=0;i<autoParaV21->lsUsedForYuvDet_len;i++){
        autoParaV21->lsUsedForYuvDet[i] = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    }
    autoParaV21->lightSources_len = 7;
    autoParaV21->lightSources = (CalibDbV2_Awb_Light_V21_t*)malloc(sizeof(CalibDbV2_Awb_Light_V21_t)*autoParaV21->lightSources_len);
    for(int i=0;i<autoParaV21->lightSources_len;i++){
        autoParaV21->lightSources[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    }
    autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len = 2;
    autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet =
        (CalibDbV2_Awb_Luma_Weight_Lv_t*)malloc(sizeof(CalibDbV2_Awb_Luma_Weight_Lv_t)*autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len);
    for(int i=0;i<autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len;i++){
        autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet_len = 3;
        autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet =
            (CalibDbV2_Awb_Lum_Wgt_Lv_Rto_t*)malloc(sizeof(CalibDbV2_Awb_Lum_Wgt_Lv_Rto_t)*autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet_len);
    }
    autoParaV21->limitRange.lumaValue = (float*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(float));
    autoParaV21->limitRange.maxB= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV21->limitRange.maxR= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV21->limitRange.maxG= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV21->limitRange.maxY= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV21->limitRange.minB= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV21->limitRange.minR= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV21->limitRange.minG= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV21->limitRange.minY= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
    commV21->division.wpNumTh.high = (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
    commV21->division.wpNumTh.low= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
    commV21->division.wpNumTh.lumaValue= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
    commV21->xyRegionStableSelection.wpNumTh.lumaValue = (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
    commV21->xyRegionStableSelection.wpNumTh.forBigType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
    commV21->xyRegionStableSelection.wpNumTh.forExtraType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
    //coppy value
    CalibDbV2_Wb_Para_t *control = &wb_v21->control;
    control->byPass = 0;
    control->mode = CALIB_WB_MODE_AUTO;
    CalibDbV2_Wb_Mwb_Para_t *manualPara =  &wb_v21->manualPara;
    manualPara->mode = CALIB_MWB_MODE_SCENE;
    manualPara->cfg.scene = CALIB_WB_SCENE_CLOUDY_DAYLIGHT;
    manualPara->cfg.cct.CCT = 5000;
    manualPara->cfg.cct.CCRI = 0;
    memcpy(manualPara->cfg.mwbGain, awb_calib_v21->standardGainValue[0],sizeof(manualPara->cfg.mwbGain));
    autoParaV21->hdrPara.frameChoose = awb_calib_v21->hdrFrameChoose;
    autoParaV21->hdrPara.frameChooseMode= (CalibDbV2_Awb_Hdr_Fr_Ch_Mode_t)awb_calib_v21->hdrFrameChooseMode;
    autoParaV21->lscBypassEnable = awb_calib_v21->lscBypEnable;
    autoParaV21->uvDetectionEnable = awb_calib_v21->uvDetectionEnable;
    autoParaV21->xyDetectionEnable= awb_calib_v21->xyDetectionEnable;
    autoParaV21->yuvDetectionEnable = awb_calib_v21->yuvDetectionEnable;
    for(int i=0;i<autoParaV21->lsUsedForYuvDet_len;i++){
       strcpy(autoParaV21->lsUsedForYuvDet[i],awb_calib_v21->lsUsedForYuvDet[i]);
    }
    autoParaV21->blkStatisticsEnable = awb_calib_v21->blkStatisticsEnable;
    autoParaV21->downScaleMode = (CalibDbV2_Awb_Down_Scale_Mode_t)awb_calib_v21->dsMode;
    autoParaV21->blkMeasureMode = (CalibDbV2_Awb_Blk_Stat_V21_t)awb_calib_v21->blkMeasureMode;
    autoParaV21->mainWindow.mode = (CalibDb_Window_Mode_t)awb_calib_v21->measeureWindow.mode;
    float window[4] ={0,0,1,1};
    bool flag = false;
    if(autoParaV21->mainWindow.mode != CALIB_AWB_WINDOW_CFG_AUTO){
         char resName[CALD_AWB_RES_NAME];
        for(int i=0;i<awb_calib_v21->measeureWindow.resNum;i++){
            char* p;
            float width = 0;
            float height =0;
            strcpy(resName,awb_calib_v21->measeureWindow.resName[i]);
            p = strtok(resName, "x");
            if(p==NULL){
                printf("parse resName %s error0,\n",awb_calib_v21->measeureWindow.resName[i]);
                continue;
            }
            width = atoi(p);
            p = strtok(NULL, " ");
            if(p==NULL){
                printf("parse resName %s error1,\n",awb_calib_v21->measeureWindow.resName[i]);
                continue;
            }
            height = atoi(p);
            if (height*width>0.001){
                if((float)awb_calib_v21->measeureWindow.window[i][0]/width > window[0]){
                    window[0] = awb_calib_v21->measeureWindow.window[i][0]/width;
                    flag = true;
                }
                if((float)awb_calib_v21->measeureWindow.window[i][1]/height > window[1]){
                    window[1] = awb_calib_v21->measeureWindow.window[i][1]/height;
                    flag = true;
                }
                if((float)awb_calib_v21->measeureWindow.window[i][2]/width < window[2]){
                    window[2] = awb_calib_v21->measeureWindow.window[i][2]/width;
                    flag = true;
                }
                if((float)awb_calib_v21->measeureWindow.window[i][3]/height < window[3]){
                    window[3] = awb_calib_v21->measeureWindow.window[i][3]/height;
                    flag = true;
                }
            }else{
                printf("parse resName %s error2,\n",awb_calib_v21->measeureWindow.resName[i]);
            }
        }
    }
    if (flag){
        printf("please check parse mainWindow.window (ratio) is %f,%f,%f,%f\n",window[0],window[1],window[2],window[3]);

    }
    memcpy(autoParaV21->mainWindow.window, window,sizeof(window));

    autoParaV21->limitRange.lumaValue_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.lumaValue,awb_calib_v21->limitRange.lumaValue,autoParaV21->limitRange.lumaValue_len*sizeof(float));
    autoParaV21->limitRange.maxB_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.maxB,awb_calib_v21->limitRange.maxB,autoParaV21->limitRange.maxB_len*sizeof(unsigned short));
    autoParaV21->limitRange.maxR_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.maxR,awb_calib_v21->limitRange.maxR,autoParaV21->limitRange.maxR_len*sizeof(unsigned short));
    autoParaV21->limitRange.maxG_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.maxG,awb_calib_v21->limitRange.maxG,autoParaV21->limitRange.maxG_len*sizeof(unsigned short));
    autoParaV21->limitRange.maxY_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.maxY,awb_calib_v21->limitRange.maxY,autoParaV21->limitRange.maxY_len*sizeof(unsigned short));
    autoParaV21->limitRange.minB_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.minB,awb_calib_v21->limitRange.minB,autoParaV21->limitRange.minB_len*sizeof(unsigned short));
    autoParaV21->limitRange.minR_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.minR,awb_calib_v21->limitRange.minR,autoParaV21->limitRange.minR_len*sizeof(unsigned short));
    autoParaV21->limitRange.minG_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.minG,awb_calib_v21->limitRange.minG,autoParaV21->limitRange.minG_len*sizeof(unsigned short));
    autoParaV21->limitRange.minY_len= awb_calib_v21->limitRange.lumaNum;
    memcpy(autoParaV21->limitRange.minY,awb_calib_v21->limitRange.minY,autoParaV21->limitRange.minY_len*sizeof(unsigned short));
    memcpy(autoParaV21->rgb2TcsPara.rotationMat, awb_calib_v21->rgb2tcs_param.rotationMat, sizeof(autoParaV21->rgb2TcsPara.rotationMat));
    memcpy(autoParaV21->rgb2TcsPara.pseudoLuminanceWeight, awb_calib_v21->rgb2tcs_param.pseudoLuminanceWeight, sizeof(autoParaV21->rgb2TcsPara.pseudoLuminanceWeight));
    memcpy(autoParaV21->rgb2RotationYuvMat, awb_calib_v21->rgb2RYuv_matrix,sizeof(autoParaV21->rgb2RotationYuvMat));
    for(int i=0;i<CALD_AWB_EXCRANGE_NUM_MAX;i++){
        autoParaV21->extraWpRange[i].domain = (CalibDbV2_Awb_Ext_Range_Dom_t)awb_calib_v21->excludeWpRange[i].domain;
        if(awb_calib_v21->excludeWpRange[i].mode != CALIB_AWB_EXCLUDE_WP_MODE
            && awb_calib_v21->excludeWpRange[i].mode != CALIB_AWB_ETR_LIGHT_SOUR_MODE ){
            autoParaV21->extraWpRange[i].mode = CALIB_AWB_EXCLUDE_WP_MODE;
        }else{
            autoParaV21->extraWpRange[i].mode = (CalibDbV2_Awb_Ext_Range_Mode_t)awb_calib_v21->excludeWpRange[i].mode;
        }
        autoParaV21->extraWpRange[i].region[0] = awb_calib_v21->excludeWpRange[i].xu[0];
        autoParaV21->extraWpRange[i].region[1] = awb_calib_v21->excludeWpRange[i].xu[1];
        autoParaV21->extraWpRange[i].region[2] = awb_calib_v21->excludeWpRange[i].yv[0];
        autoParaV21->extraWpRange[i].region[3] = awb_calib_v21->excludeWpRange[i].yv[1];
    }
    autoParaV21->wpDiffBlkWeiEnable = awb_calib_v21->blkWeightEnable;
    for(int i=0;i<CALD_AWB_GRID_NUM_TOTAL;i++){
        autoParaV21->wpDiffBlkWeight[i] = (awb_calib_v21->blkWeight[i] * 2) > 63 ? 63 : awb_calib_v21->blkWeight[i] * 2;
    }
    autoParaV21->wpDiffLumaWeight.enable = awb_calib_v21->wpDiffWeiEnable;
    memcpy(autoParaV21->wpDiffLumaWeight.wpDiffwei_y, awb_calib_v21->wpDiffwei_y, sizeof(autoParaV21->wpDiffLumaWeight.wpDiffwei_y));
    memcpy(autoParaV21->wpDiffLumaWeight.perfectBin, awb_calib_v21->perfectBin, sizeof(autoParaV21->wpDiffLumaWeight.perfectBin));
    autoParaV21->wpDiffLumaWeight.wpDiffWeiEnableTh.wpDiffWeiNoTh= awb_calib_v21->wpDiffNoTh;
    autoParaV21->wpDiffLumaWeight.wpDiffWeiEnableTh.wpDiffWeiLvValueTh= awb_calib_v21->wpDiffLvValueTh;
    for(int i=0;i < autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len; i++){
       autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].LvValue = awb_calib_v21->wpDiffweiSet_w_LvValueTh[i];
       for(int j=0;j<autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet_len;j++){
            autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].ratioValue =  awb_calib_v21->wpDiffWeiRatioTh[j];
            if(i==1){
                memcpy(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight, awb_calib_v21->wpDiffweiSet_w_HigLV[j],
                   sizeof(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight));
            }else{
                memcpy(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight, awb_calib_v21->wpDiffweiSet_w_LowLV[j],
                   sizeof(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight));
            }
       }
    }
    for(int i=0;i<autoParaV21->lightSources_len;i++){
        strcpy(autoParaV21->lightSources[i].name, awb_calib_v21->lightName[i]);
        autoParaV21->lightSources[i].doorType = (CalibDbV2_Awb_DoorType_t)awb_calib_v21->doorType[i];
        memcpy(autoParaV21->lightSources[i].standardGainValue, awb_calib_v21->standardGainValue[i],sizeof(autoParaV21->lightSources[i].standardGainValue));
        memcpy(autoParaV21->lightSources[i].uvRegion.u, awb_calib_v21->uvRange_param[i].pu_region,sizeof(autoParaV21->lightSources[i].uvRegion.u));
        memcpy(autoParaV21->lightSources[i].uvRegion.v, awb_calib_v21->uvRange_param[i].pv_region,sizeof(autoParaV21->lightSources[i].uvRegion.v));
        autoParaV21->lightSources[i].xyRegion.normal[0] = awb_calib_v21->xyRangeLight[i].NorrangeX[0];
        autoParaV21->lightSources[i].xyRegion.normal[1] = awb_calib_v21->xyRangeLight[i].NorrangeX[1];
        autoParaV21->lightSources[i].xyRegion.normal[2] = awb_calib_v21->xyRangeLight[i].NorrangeY[0];
        autoParaV21->lightSources[i].xyRegion.normal[3] = awb_calib_v21->xyRangeLight[i].NorrangeY[1];
        autoParaV21->lightSources[i].xyRegion.big[0] = awb_calib_v21->xyRangeLight[i].SperangeX[0];
        autoParaV21->lightSources[i].xyRegion.big[1] = awb_calib_v21->xyRangeLight[i].SperangeX[1];
        autoParaV21->lightSources[i].xyRegion.big[2] = awb_calib_v21->xyRangeLight[i].SperangeY[0];
        autoParaV21->lightSources[i].xyRegion.big[3] = awb_calib_v21->xyRangeLight[i].SperangeY[1];
        memcpy(autoParaV21->lightSources[i].rtYuvRegion.thcurve_u, awb_calib_v21->yuv3D2Range_param[i].thcurve_u,
            sizeof(awb_calib_v21->yuv3D2Range_param[i].thcurve_u));
        memcpy(autoParaV21->lightSources[i].rtYuvRegion.thcure_th, awb_calib_v21->yuv3D2Range_param[i].thcure_th,
            sizeof(awb_calib_v21->yuv3D2Range_param[i].thcure_th));
        memcpy(autoParaV21->lightSources[i].rtYuvRegion.lineVector, awb_calib_v21->yuv3D2Range_param[i].line,
            sizeof(awb_calib_v21->yuv3D2Range_param[i].line));
        autoParaV21->lightSources[i].rtYuvRegion.disP1P2 = 15;

        memcpy(autoParaV21->lightSources[i].staWeight, awb_adjust->awb_light_info[i].staWeight, sizeof(autoParaV21->lightSources[i].staWeight));
        autoParaV21->lightSources[i].dayGainLvThSet[0] = awb_adjust->awb_light_info[i].spatialGain_LV_THL;
        autoParaV21->lightSources[i].dayGainLvThSet[1] = awb_adjust->awb_light_info[i].spatialGain_LV_THH;
        memcpy(autoParaV21->lightSources[i].defaultDayGainLow,awb_calib_v21->spatialGain_L, sizeof(awb_calib_v21->spatialGain_L));
        memcpy(autoParaV21->lightSources[i].defaultDayGainHigh,awb_calib_v21->spatialGain_H, sizeof(awb_calib_v21->spatialGain_H));
        autoParaV21->lightSources[i].xyType2Enable = awb_adjust->awb_light_info[i].xyType2Enable;
    }

    strcpy(commV21->lightSourceForFirstFrame, awb_adjust->lsForFirstFrame);
    memcpy(commV21->tolerance.lumaValue, awb_adjust->tolerance.LV,sizeof(float)*commV21->tolerance.lumaValue_len);
    memcpy(commV21->tolerance.toleranceValue, awb_adjust->tolerance.value,sizeof(float)*commV21->tolerance.toleranceValue_len);
    memcpy(commV21->runInterval.lumaValue, awb_adjust->runInterval.LV,sizeof(float)*commV21->runInterval.lumaValue_len);
    memcpy(commV21->runInterval.intervalValue, awb_adjust->runInterval.value,sizeof(float)*commV21->runInterval.intervalValue_len);
    commV21->dampFactor.dFStep = awb_adjust->dFStep;
    commV21->dampFactor.dFMin = awb_adjust->dFMin;
    commV21->dampFactor.dFMax = awb_adjust->dFMax;
    commV21->dampFactor.lvIIRsize = awb_adjust->LvIIRsize;
    commV21->dampFactor.lvVarTh = awb_adjust->LvVarTh;
    commV21->wbGainAdjust.enable = awb_adjust->wbGainAdjustEn;
    for(int i=0; i<commV21->wbGainAdjust.lutAll_len;i++){
        commV21->wbGainAdjust.lutAll[i].lumaValue = awb_adjust->cct_lut_cfg[i].lv;
        commV21->wbGainAdjust.lutAll[i].ct_grid_num = awb_adjust->cct_lut_cfg[0].ct_grid_num;
        commV21->wbGainAdjust.lutAll[i].cri_grid_num = awb_adjust->cct_lut_cfg[0].cri_grid_num;
        memcpy(commV21->wbGainAdjust.lutAll[i].ct_in_range, awb_adjust->cct_lut_cfg[0].ct_range,sizeof(commV21->wbGainAdjust.lutAll[i].ct_in_range));
        memcpy(commV21->wbGainAdjust.lutAll[i].cri_in_range, awb_adjust->cct_lut_cfg[0].cri_range,sizeof(commV21->wbGainAdjust.lutAll[i].cri_in_range));
        memcpy(commV21->wbGainAdjust.lutAll[i].ct_lut_out,awb_adjust->cct_lut_cfg[i].ct_lut_out,sizeof(float)*commV21->wbGainAdjust.lutAll[i].ct_lut_out_len);
        memcpy(commV21->wbGainAdjust.lutAll[i].cri_lut_out,awb_adjust->cct_lut_cfg[i].cri_lut_out,sizeof(float)*commV21->wbGainAdjust.lutAll[i].cri_lut_out_len);
    }
    commV21->wbGainDaylightClip.enable= awb_calib_v21->wbGainDaylightClipEn;
    commV21->wbGainDaylightClip.outdoor_cct_min = awb_calib_v21->cct_clip_cfg.outdoor_cct_min;
    commV21->wbGainClip.enable= awb_calib_v21->wbGainClipEn;
    memcpy(commV21->wbGainClip.cct, awb_calib_v21->cct_clip_cfg.cct,sizeof(float)*commV21->wbGainClip.cct_len);
    memcpy(commV21->wbGainClip.cri_bound_low, awb_calib_v21->cct_clip_cfg.cri_bound_low,sizeof(float)*commV21->wbGainClip.cri_bound_low_len);
    memcpy(commV21->wbGainClip.cri_bound_up, awb_calib_v21->cct_clip_cfg.cri_bound_up,sizeof(float)*commV21->wbGainClip.cri_bound_up_len);
    commV21->division.lumaValThLow= awb_adjust->LV_THL;
    commV21->division.lumaValThLow2= awb_adjust->LV_THL2;
    commV21->division.lumaValThHigh= awb_adjust->LV_THH;
    commV21->division.lumaValThHigh2= awb_adjust->LV_THH2;
    commV21->division.wpNumTh.lumaValue_len = awb_adjust->WP_TH.num;
    memcpy(commV21->division.wpNumTh.lumaValue, awb_adjust->WP_TH.lumaValue,sizeof(float)*commV21->division.wpNumTh.lumaValue_len);
    commV21->division.wpNumTh.high_len = awb_adjust->WP_TH.num;
    memcpy(commV21->division.wpNumTh.high, awb_adjust->WP_TH.WP_THH,sizeof(float)*commV21->division.wpNumTh.lumaValue_len);
    commV21->division.wpNumTh.low_len = awb_adjust->WP_TH.num;
    memcpy(commV21->division.wpNumTh.low, awb_adjust->WP_TH.WP_THL,sizeof(float)*commV21->division.wpNumTh.lumaValue_len);
    memcpy(commV21->defaultNightGain,awb_calib_v21->temporalDefaultGain, sizeof(commV21->defaultNightGain));
    memcpy(commV21->lumaValueMatrix,awb_adjust->LVMatrix, sizeof(commV21->lumaValueMatrix));
    memcpy(commV21->defaultNightGainWeight,awb_adjust->tempWeight, sizeof(commV21->defaultNightGainWeight));
    commV21->probCalcDis.proDis_THH = awb_adjust->proDis_THH;
    commV21->probCalcDis.proDis_THL = awb_adjust->proDis_THL;
    commV21->probCalcLv.outdoorLumaValThHigh = awb_adjust->proLV_Outdoor_THH;
    commV21->probCalcLv.outdoorLumaValThLow = awb_adjust->proLV_Outdoor_THL;
    commV21->probCalcWp.wpNumPercTh= awb_adjust->wpNumPercTh;
    commV21->probCalcWp.wpNumPercTh2= 0.2;
    commV21->converged.varThforDamp = awb_adjust->convergedVarTh;
    commV21->converged.varThforUnDamp= awb_adjust->convergedVarTh;
    commV21->xyRegionStableSelection.enable = true;
    commV21->xyRegionStableSelection.wpNumTh.lumaValue_len= awb_adjust->wpNumTh.num;
    memcpy(commV21->xyRegionStableSelection.wpNumTh.lumaValue,awb_adjust->wpNumTh.lumaValue,sizeof(float)*awb_adjust->wpNumTh.num);
    commV21->xyRegionStableSelection.wpNumTh.forBigType_len= awb_adjust->wpNumTh.num;
    memcpy(commV21->xyRegionStableSelection.wpNumTh.forBigType,awb_adjust->wpNumTh.wpNumThForBigType,sizeof(float)*awb_adjust->wpNumTh.num);
    commV21->xyRegionStableSelection.wpNumTh.forExtraType_len= awb_adjust->wpNumTh.num;
    memcpy(commV21->xyRegionStableSelection.wpNumTh.forExtraType,awb_adjust->wpNumTh.wpNumThForExtraType,sizeof(float)*awb_adjust->wpNumTh.num);
    commV21->xyRegionStableSelection.xyTypeListSize = awb_adjust->xyTypeListSize;
    commV21->xyRegionStableSelection.varianceLumaTh = awb_adjust->varianceLumaTh;
    memcpy(commV21->weightForNightGainCalc, awb_adjust->temporalGainSetWeight, commV21->weightForNightGainCalc_len*sizeof(unsigned char));
    commV21->singleColorProces.enable = true;
    for(int i=0; i<commV21->singleColorProces.colorBlock_len; i++){
        commV21->singleColorProces.colorBlock[i].index = awb_calib_v21->sIndSelColor[i];
        commV21->singleColorProces.colorBlock[i].meanC= awb_calib_v21->sMeanCh[0][i];
        commV21->singleColorProces.colorBlock[i].meanH= awb_calib_v21->sMeanCh[1][i];
    }
    for(int i=0; i<commV21->singleColorProces.lsUsedForEstimation_len; i++){
        strcpy(commV21->singleColorProces.lsUsedForEstimation[i].name, awb_calib_v21->sNameIllEst[i]);
        commV21->singleColorProces.lsUsedForEstimation[i].RGain= awb_calib_v21->srGain[i];
        commV21->singleColorProces.lsUsedForEstimation[i].BGain= awb_calib_v21->sbGain[i];
    }
    commV21->singleColorProces.alpha= awb_calib_v21->sAlpha;
    memcpy(commV21->lineRgBg,awb_calib_v21->lineRgBg,sizeof(commV21->lineRgBg));
    memcpy(commV21->lineRgProjCCT,awb_calib_v21->lineRgProjCCT,sizeof(commV21->lineRgProjCCT));
    commV21->chrAdpttAdj.enable = awb_adjust->ca_enable;
    commV21->chrAdpttAdj.laCalcFactor = awb_adjust->ca_LACalcFactor;
    memcpy(commV21->chrAdpttAdj.targetGain, awb_calib_v21->ca_targetGain, sizeof(commV21->chrAdpttAdj.targetGain));
    commV21->remosaicCfg.enable = awb_adjust->remosaic_cfg.enable;
    commV21->remosaicCfg.applyInvWbGainEnable= true;
    memcpy(commV21->remosaicCfg.sensorWbGain, awb_adjust->remosaic_cfg.sensor_awb_gain, sizeof(commV21->remosaicCfg.sensorWbGain));
    memcpy(&commV21->wbGainOffset, &awb_adjust->wbGainOffset, sizeof(commV21->wbGainOffset));

}


void CalibV2AwbV20Free(CamCalibDbV2Context_t *calibV2)
{
    CalibDbV2_Wb_Para_V20_t* wb_v20 =
            (CalibDbV2_Wb_Para_V20_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v20));
    if(wb_v20 == NULL)
          return;

    CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV20 = &wb_v20->autoExtPara;
    CalibDbV2_Wb_Awb_Para_V20_t* autoParaV20 =  &wb_v20->autoPara;
    free(commV20->lightSourceForFirstFrame);
    free(commV20->wbGainClip.cct);
    free(commV20->wbGainClip.cri_bound_up);
    free(commV20->wbGainClip.cri_bound_low);
    free(commV20->singleColorProces.colorBlock);
    for(int i=0;i<commV20->singleColorProces.lsUsedForEstimation_len;i++){
           free(commV20->singleColorProces.lsUsedForEstimation[i].name);
    }
    free(commV20->singleColorProces.lsUsedForEstimation);
    free(commV20->tolerance.toleranceValue);
    free(commV20->tolerance.lumaValue);
    free(commV20->runInterval.intervalValue);
    free(commV20->runInterval.lumaValue);
    for(int i=0;i<commV20->wbGainAdjust.lutAll_len;i++){
        free(commV20->wbGainAdjust.lutAll[i].ct_lut_out);
        free(commV20->wbGainAdjust.lutAll[i].cri_lut_out);
    }
    free(commV20->wbGainAdjust.lutAll);
    free(commV20->weightForNightGainCalc);
    free(commV20->division.wpNumTh.high);
    free(commV20->division.wpNumTh.low);
    free(commV20->division.wpNumTh.lumaValue);
    free(commV20->xyRegionStableSelection.wpNumTh.lumaValue);
    free(commV20->xyRegionStableSelection.wpNumTh.forBigType);
    free(commV20->xyRegionStableSelection.wpNumTh.forExtraType);
    for(int i=0;i<autoParaV20->lsUsedForYuvDet_len;i++){
        free(autoParaV20->lsUsedForYuvDet[i]);
    }
    free(autoParaV20->lsUsedForYuvDet);
    for(int i=0;i<autoParaV20->lightSources_len;i++){
        free(autoParaV20->lightSources[i].name);
    }
    free(autoParaV20->lightSources);
    free(autoParaV20->limitRange.lumaValue);
    free(autoParaV20->limitRange.maxB);
    free(autoParaV20->limitRange.maxR);
    free(autoParaV20->limitRange.maxG);
    free(autoParaV20->limitRange.maxY);
    free(autoParaV20->limitRange.minB);
    free(autoParaV20->limitRange.minR);
    free(autoParaV20->limitRange.minG);
    free(autoParaV20->limitRange.minY);
}

void convertCalib2calibV20(const CamCalibDbContext_t *calib,CamCalibDbV2Context_t *calibV2)
{
    //malloc
    const CalibDb_Awb_Calib_Para_V200_t *awb_calib_v20 = NULL;

    list_head *awb_calib_para_list =
        (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_calib_para_v200);

#ifdef RKAIQ_ENABLE_PARSER_V1
    if (awb_calib_para_list)
        GetAwbProfileFromAwbCalibV200ListByIdx(awb_calib_para_list, 0, &awb_calib_v20);
#else
        return;
#endif

    const CalibDb_Awb_Adjust_Para_t *awb_adjust = NULL;

    list_head *awb_adjust_list =
        (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_adjust_para);

    if (awb_adjust_list)
        GetAwbProfileFromAwbAdjustListByIdx(awb_adjust_list, 0, &awb_adjust);
    else
        return;

    CalibDbV2_Wb_Para_V20_t* wb_v20 =
            (CalibDbV2_Wb_Para_V20_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v20));
    memset(wb_v20, 0, sizeof(CalibDbV2_Wb_Para_V20_t));
    CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV20 = &wb_v20->autoExtPara;
    CalibDbV2_Wb_Awb_Para_V20_t* autoParaV20 =  &wb_v20->autoPara;
    commV20->lightSourceForFirstFrame= (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    commV20->wbGainClip.cct_len = awb_calib_v20->cct_clip_cfg.grid_num;
    commV20->wbGainClip.cri_bound_up_len = awb_calib_v20->cct_clip_cfg.grid_num;
    commV20->wbGainClip.cri_bound_low_len = awb_calib_v20->cct_clip_cfg.grid_num;
    commV20->wbGainClip.cct = (float*)malloc(sizeof(float) * commV20->wbGainClip.cct_len);
    commV20->wbGainClip.cri_bound_up = (float*)malloc(sizeof(float) * commV20->wbGainClip.cct_len);
    commV20->wbGainClip.cri_bound_low = (float*)malloc(sizeof(float) * commV20->wbGainClip.cct_len);
    commV20->singleColorProces.colorBlock_len = awb_calib_v20->sSelColorNUM;
    commV20->singleColorProces.lsUsedForEstimation_len = awb_calib_v20->sIllEstNum;
    commV20->singleColorProces.colorBlock = (CalibDbV2_Awb_Sgc_Cblk_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Cblk_t)*commV20->singleColorProces.colorBlock_len);
    commV20->singleColorProces.lsUsedForEstimation = (CalibDbV2_Awb_Sgc_Ls_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Ls_t)*commV20->singleColorProces.lsUsedForEstimation_len);
     for(int i=0;i<commV20->singleColorProces.lsUsedForEstimation_len;i++){
           commV20->singleColorProces.lsUsedForEstimation[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    }
    commV20->tolerance.lumaValue_len = awb_adjust->tolerance.num;
    commV20->tolerance.toleranceValue_len = awb_adjust->tolerance.num;
    commV20->tolerance.toleranceValue = (float*)malloc(sizeof(float)*commV20->tolerance.toleranceValue_len);
    commV20->tolerance.lumaValue= (float*)malloc(sizeof(float)*commV20->tolerance.lumaValue_len);
    commV20->runInterval.lumaValue_len = awb_adjust->runInterval.num;
    commV20->runInterval.intervalValue_len= awb_adjust->runInterval.num;
    commV20->runInterval.intervalValue = (float*)malloc(sizeof(float)*commV20->runInterval.intervalValue_len);
    commV20->runInterval.lumaValue= (float*)malloc(sizeof(float)*commV20->runInterval.lumaValue_len);
    commV20->wbGainAdjust.lutAll_len = awb_adjust->cct_lut_cfg_num;
    commV20->wbGainAdjust.lutAll = (CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t*)malloc(sizeof(CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t)*commV20->wbGainAdjust.lutAll_len);
    for(int i=0;i<commV20->wbGainAdjust.lutAll_len;i++){
        commV20->wbGainAdjust.lutAll[i].ct_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num *  awb_adjust->cct_lut_cfg[0].cri_grid_num;
        commV20->wbGainAdjust.lutAll[i].ct_lut_out = (float*)malloc(sizeof(float)*commV20->wbGainAdjust.lutAll[i].ct_lut_out_len);
        commV20->wbGainAdjust.lutAll[i].cri_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num *  awb_adjust->cct_lut_cfg[0].cri_grid_num;
        commV20->wbGainAdjust.lutAll[i].cri_lut_out = (float*)malloc(sizeof(float)*commV20->wbGainAdjust.lutAll[i].cri_lut_out_len);
    }
    commV20->weightForNightGainCalc_len = 4;
    commV20->weightForNightGainCalc = (unsigned char*)malloc(sizeof(unsigned char)*commV20->weightForNightGainCalc_len);
    autoParaV20->lsUsedForYuvDet_len = 7;
    autoParaV20->lsUsedForYuvDet = (char**)malloc(sizeof(char*)*autoParaV20->lsUsedForYuvDet_len);
    for(int i=0;i<autoParaV20->lsUsedForYuvDet_len;i++){
        autoParaV20->lsUsedForYuvDet[i] = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    }
    autoParaV20->lightSources_len = 7;
    autoParaV20->lightSources = (CalibDbV2_Awb_Light_V20_t*)malloc(sizeof(CalibDbV2_Awb_Light_V20_t)*autoParaV20->lightSources_len);
    for(int i=0;i<autoParaV20->lightSources_len;i++){
        autoParaV20->lightSources[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
    }
    autoParaV20->limitRange.lumaValue = (float*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(float));
    autoParaV20->limitRange.maxB= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV20->limitRange.maxR= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV20->limitRange.maxG= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV20->limitRange.maxY= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV20->limitRange.minB= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV20->limitRange.minR= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV20->limitRange.minG= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    autoParaV20->limitRange.minY= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
    commV20->division.wpNumTh.high = (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
    commV20->division.wpNumTh.low= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
    commV20->division.wpNumTh.lumaValue= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
    commV20->xyRegionStableSelection.wpNumTh.lumaValue = (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
    commV20->xyRegionStableSelection.wpNumTh.forBigType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
    commV20->xyRegionStableSelection.wpNumTh.forExtraType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
    //coppy value
    CalibDbV2_Wb_Para_t *control = &wb_v20->control;
    control->byPass = 0;
    control->mode = CALIB_WB_MODE_AUTO;
    CalibDbV2_Wb_Mwb_Para_t *manualPara =  &wb_v20->manualPara;
    manualPara->mode = CALIB_MWB_MODE_SCENE;
    manualPara->cfg.scene =  CALIB_WB_SCENE_CLOUDY_DAYLIGHT;
    manualPara->cfg.cct.CCT = 5000;
    manualPara->cfg.cct.CCRI = 0;
    memcpy(manualPara->cfg.mwbGain, awb_calib_v20->standardGainValue[0],sizeof(manualPara->cfg.mwbGain));
    autoParaV20->hdrPara.frameChoose = awb_calib_v20->hdrFrameChoose;
    autoParaV20->hdrPara.frameChooseMode= (CalibDbV2_Awb_Hdr_Fr_Ch_Mode_t)awb_calib_v20->hdrFrameChooseMode;
    autoParaV20->lscBypassEnable = awb_calib_v20->lscBypEnable;
    autoParaV20->uvDetectionEnable = awb_calib_v20->uvDetectionEnable;
    autoParaV20->xyDetectionEnable= awb_calib_v20->xyDetectionEnable;
    autoParaV20->yuvDetectionEnable = awb_calib_v20->yuvDetectionEnable;
    for(int i=0;i<autoParaV20->lsUsedForYuvDet_len;i++){
       strcpy(autoParaV20->lsUsedForYuvDet[i],awb_calib_v20->lsUsedForYuvDet[i]);
    }
    autoParaV20->yuvDetRef_u = awb_calib_v20->yuv3DRange_param[0].ref_u;
    autoParaV20->downScaleMode = (CalibDbV2_Awb_Down_Scale_Mode_t)awb_calib_v20->dsMode;
    autoParaV20->blkMeasureMode = (CalibDbV2_Awb_Blk_Stat_V20_t)awb_calib_v20->blkMeasureMode;
    autoParaV20->mainWindow.mode = (CalibDb_Window_Mode_t)awb_calib_v20->measeureWindow.mode;
    float window[4] ={0,0,1,1};
    memcpy(autoParaV20->mainWindow.window, window,sizeof(window));
    bool flag = false;
    if(autoParaV20->mainWindow.mode != CALIB_AWB_WINDOW_CFG_AUTO){
         char resName[CALD_AWB_RES_NAME];
        for(int i=0;i<awb_calib_v20->measeureWindow.resNum;i++){
            char* p;
            float width = 0;
            float height =0;
            strcpy(resName,awb_calib_v20->measeureWindow.resName[i]);
            p = strtok(resName, "x");
            if(p==NULL){
                printf("parse resName %s error0,\n",awb_calib_v20->measeureWindow.resName[i]);
                continue;
            }
            width = atoi(p);
            p = strtok(NULL, " ");
            if(p==NULL){
                printf("parse resName %s error1,\n",awb_calib_v20->measeureWindow.resName[i]);
                continue;
            }
            height = atoi(p);
            if (height*width>0.001){
                if((float)awb_calib_v20->measeureWindow.window[i][0]/width > window[0]){
                    window[0] = awb_calib_v20->measeureWindow.window[i][0]/width;
                    flag = true;
                }
                if((float)awb_calib_v20->measeureWindow.window[i][1]/height > window[1]){
                    window[1] = awb_calib_v20->measeureWindow.window[i][1]/height;
                    flag = true;
                }
                if((float)awb_calib_v20->measeureWindow.window[i][2]/width < window[2]){
                    window[2] = awb_calib_v20->measeureWindow.window[i][2]/width;
                    flag = true;
                }
                if((float)awb_calib_v20->measeureWindow.window[i][3]/height < window[3]){
                    window[3] = awb_calib_v20->measeureWindow.window[i][3]/height;
                    flag = true;
                }
            }else{
                printf("parse resName %s error2,\n",awb_calib_v20->measeureWindow.resName[i]);
            }
        }
    }
    if (flag){
        printf("please check parse mainWindow.window (ratio) is %f,%f,%f,%f\n",window[0],window[1],window[2],window[3]);

    }
    autoParaV20->limitRange.lumaValue_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.lumaValue,awb_calib_v20->limitRange.lumaValue,autoParaV20->limitRange.lumaValue_len*sizeof(float));
    autoParaV20->limitRange.maxB_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.maxB,awb_calib_v20->limitRange.maxB,autoParaV20->limitRange.maxB_len*sizeof(unsigned short));
    autoParaV20->limitRange.maxR_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.maxR,awb_calib_v20->limitRange.maxR,autoParaV20->limitRange.maxR_len*sizeof(unsigned short));
    autoParaV20->limitRange.maxG_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.maxG,awb_calib_v20->limitRange.maxG,autoParaV20->limitRange.maxG_len*sizeof(unsigned short));
    autoParaV20->limitRange.maxY_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.maxY,awb_calib_v20->limitRange.maxY,autoParaV20->limitRange.maxY_len*sizeof(unsigned short));
    autoParaV20->limitRange.minB_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.minB,awb_calib_v20->limitRange.minB,autoParaV20->limitRange.minB_len*sizeof(unsigned short));
    autoParaV20->limitRange.minR_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.minR,awb_calib_v20->limitRange.minR,autoParaV20->limitRange.minR_len*sizeof(unsigned short));
    autoParaV20->limitRange.minG_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.minG,awb_calib_v20->limitRange.minG,autoParaV20->limitRange.minG_len*sizeof(unsigned short));
    autoParaV20->limitRange.minY_len= awb_calib_v20->limitRange.lumaNum;
    memcpy(autoParaV20->limitRange.minY,awb_calib_v20->limitRange.minY,autoParaV20->limitRange.minY_len*sizeof(unsigned short));
    memcpy(autoParaV20->rgb2TcsPara.rotationMat, awb_calib_v20->rgb2tcs_param.rotationMat, sizeof(autoParaV20->rgb2TcsPara.rotationMat));
    memcpy(autoParaV20->rgb2TcsPara.pseudoLuminanceWeight, awb_calib_v20->rgb2tcs_param.pseudoLuminanceWeight, sizeof(autoParaV20->rgb2TcsPara.pseudoLuminanceWeight));
    autoParaV20->multiWindow.enable = awb_calib_v20->multiwindow_en;
    autoParaV20->multiWindow.multiwindowMode = (CalibDbV2_Awb_Mul_Win_Mode_t)awb_adjust->multiwindowMode;
    for(int i=0;i<CALD_AWB_WINDOW_NUM_MAX;i++){
        for(int j=0;j<4;j++){
            autoParaV20->multiWindow.window[i][j]= awb_calib_v20->multiwindow[i][j];
        }
    }
    for(int i=0;i<CALD_AWB_EXCRANGE_NUM_MAX;i++){
        autoParaV20->extraWpRange[i].domain = (CalibDbV2_Awb_Ext_Range_Dom_t)awb_calib_v20->excludeWpRange[i].domain;
        if(awb_calib_v20->excludeWpRange[i].mode != CALIB_AWB_EXCLUDE_WP_MODE
            && awb_calib_v20->excludeWpRange[i].mode != CALIB_AWB_ETR_LIGHT_SOUR_MODE ){
            autoParaV20->extraWpRange[i].mode = CALIB_AWB_EXCLUDE_WP_MODE;
        }else{
            autoParaV20->extraWpRange[i].mode = (CalibDbV2_Awb_Ext_Range_Mode_t)awb_calib_v20->excludeWpRange[i].mode;
        }
        autoParaV20->extraWpRange[i].region[0] = awb_calib_v20->excludeWpRange[i].xu[0];
        autoParaV20->extraWpRange[i].region[1] = awb_calib_v20->excludeWpRange[i].xu[1];
        autoParaV20->extraWpRange[i].region[2] = awb_calib_v20->excludeWpRange[i].yv[0];
        autoParaV20->extraWpRange[i].region[3] = awb_calib_v20->excludeWpRange[i].yv[1];
    }
    for(int i=0;i<autoParaV20->lightSources_len;i++){
        strcpy(autoParaV20->lightSources[i].name, awb_calib_v20->lightName[i]);
        autoParaV20->lightSources[i].doorType = (CalibDbV2_Awb_DoorType_t)awb_calib_v20->doorType[i];
        memcpy(autoParaV20->lightSources[i].standardGainValue, awb_calib_v20->standardGainValue[i],sizeof(autoParaV20->lightSources[i].standardGainValue));
        memcpy(autoParaV20->lightSources[i].uvRegion.u, awb_calib_v20->uvRange_param[i].pu_region,sizeof(autoParaV20->lightSources[i].uvRegion.u));
        memcpy(autoParaV20->lightSources[i].uvRegion.v, awb_calib_v20->uvRange_param[i].pv_region,sizeof(autoParaV20->lightSources[i].uvRegion.v));
        autoParaV20->lightSources[i].xyRegion.normal[0] = awb_calib_v20->xyRangeLight[i].NorrangeX[0];
        autoParaV20->lightSources[i].xyRegion.normal[1] = awb_calib_v20->xyRangeLight[i].NorrangeX[1];
        autoParaV20->lightSources[i].xyRegion.normal[2] = awb_calib_v20->xyRangeLight[i].NorrangeY[0];
        autoParaV20->lightSources[i].xyRegion.normal[3] = awb_calib_v20->xyRangeLight[i].NorrangeY[1];
        autoParaV20->lightSources[i].xyRegion.big[0] = awb_calib_v20->xyRangeLight[i].SperangeX[0];
        autoParaV20->lightSources[i].xyRegion.big[1] = awb_calib_v20->xyRangeLight[i].SperangeX[1];
        autoParaV20->lightSources[i].xyRegion.big[2] = awb_calib_v20->xyRangeLight[i].SperangeY[0];
        autoParaV20->lightSources[i].xyRegion.big[3] = awb_calib_v20->xyRangeLight[i].SperangeY[1];
        autoParaV20->lightSources[i].xyRegion.small[0] = awb_calib_v20->xyRangeLight[i].SmalrangeX[0];
        autoParaV20->lightSources[i].xyRegion.small[1] = awb_calib_v20->xyRangeLight[i].SmalrangeX[1];
        autoParaV20->lightSources[i].xyRegion.small[2] = awb_calib_v20->xyRangeLight[i].SmalrangeY[0];
        autoParaV20->lightSources[i].xyRegion.small[3] = awb_calib_v20->xyRangeLight[i].SmalrangeY[1];
        autoParaV20->lightSources[i].yuvRegion.b_uv = awb_calib_v20->yuv3DRange_param[i].b_uv;
        autoParaV20->lightSources[i].yuvRegion.slope_inv_neg_uv= awb_calib_v20->yuv3DRange_param[i].slope_inv_neg_uv;
        autoParaV20->lightSources[i].yuvRegion.slope_factor_uv= awb_calib_v20->yuv3DRange_param[i].slope_factor_uv;
        autoParaV20->lightSources[i].yuvRegion.slope_ydis= awb_calib_v20->yuv3DRange_param[i].slope_ydis;
        autoParaV20->lightSources[i].yuvRegion.b_ydis= awb_calib_v20->yuv3DRange_param[i].b_ydis;
        autoParaV20->lightSources[i].yuvRegion.ref_v= awb_calib_v20->yuv3DRange_param[i].ref_v;
        memcpy(autoParaV20->lightSources[i].yuvRegion.dis, awb_calib_v20->yuv3DRange_param[i].dis, sizeof(autoParaV20->lightSources[i].yuvRegion.dis));
        memcpy(autoParaV20->lightSources[i].yuvRegion.th, awb_calib_v20->yuv3DRange_param[i].th, sizeof(autoParaV20->lightSources[i].yuvRegion.th));
        memcpy(autoParaV20->lightSources[i].staWeight, awb_adjust->awb_light_info[i].staWeight, sizeof(autoParaV20->lightSources[i].staWeight));
        autoParaV20->lightSources[i].dayGainLvThSet[0] = awb_adjust->awb_light_info[i].spatialGain_LV_THL;
        autoParaV20->lightSources[i].dayGainLvThSet[1] = awb_adjust->awb_light_info[i].spatialGain_LV_THH;
        memcpy(autoParaV20->lightSources[i].defaultDayGainLow,awb_calib_v20->spatialGain_L, sizeof(awb_calib_v20->spatialGain_L));
        memcpy(autoParaV20->lightSources[i].defaultDayGainHigh,awb_calib_v20->spatialGain_H, sizeof(awb_calib_v20->spatialGain_H));
        autoParaV20->lightSources[i].xyType2Enable = awb_adjust->awb_light_info[i].xyType2Enable;
    }

    strcpy(commV20->lightSourceForFirstFrame, awb_adjust->lsForFirstFrame);
    memcpy(commV20->tolerance.lumaValue, awb_adjust->tolerance.LV,sizeof(float)*commV20->tolerance.lumaValue_len);
    memcpy(commV20->tolerance.toleranceValue, awb_adjust->tolerance.value,sizeof(float)*commV20->tolerance.toleranceValue_len);
    memcpy(commV20->runInterval.lumaValue, awb_adjust->runInterval.LV,sizeof(float)*commV20->runInterval.lumaValue_len);
    memcpy(commV20->runInterval.intervalValue, awb_adjust->runInterval.value,sizeof(float)*commV20->runInterval.intervalValue_len);
    commV20->dampFactor.dFStep = awb_adjust->dFStep;
    commV20->dampFactor.dFMin = awb_adjust->dFMin;
    commV20->dampFactor.dFMax = awb_adjust->dFMax;
    commV20->dampFactor.lvIIRsize = awb_adjust->LvIIRsize;
    commV20->dampFactor.lvVarTh = awb_adjust->LvVarTh;
    commV20->wbGainAdjust.enable = awb_adjust->wbGainAdjustEn;
    for(int i=0; i<commV20->wbGainAdjust.lutAll_len;i++){
        commV20->wbGainAdjust.lutAll[i].lumaValue = awb_adjust->cct_lut_cfg[i].lv;
        commV20->wbGainAdjust.lutAll[i].ct_grid_num = awb_adjust->cct_lut_cfg[0].ct_grid_num;
        commV20->wbGainAdjust.lutAll[i].cri_grid_num = awb_adjust->cct_lut_cfg[0].cri_grid_num;
        memcpy(commV20->wbGainAdjust.lutAll[i].ct_in_range, awb_adjust->cct_lut_cfg[0].ct_range,sizeof(commV20->wbGainAdjust.lutAll[i].ct_in_range));
        memcpy(commV20->wbGainAdjust.lutAll[i].cri_in_range, awb_adjust->cct_lut_cfg[0].cri_range,sizeof(commV20->wbGainAdjust.lutAll[i].cri_in_range));
        memcpy(commV20->wbGainAdjust.lutAll[i].ct_lut_out,awb_adjust->cct_lut_cfg[i].ct_lut_out,sizeof(float)*commV20->wbGainAdjust.lutAll[i].ct_lut_out_len);
        memcpy(commV20->wbGainAdjust.lutAll[i].cri_lut_out,awb_adjust->cct_lut_cfg[i].cri_lut_out,sizeof(float)*commV20->wbGainAdjust.lutAll[i].cri_lut_out_len);
    }
    commV20->wbGainDaylightClip.enable= awb_calib_v20->wbGainDaylightClipEn;
    commV20->wbGainDaylightClip.outdoor_cct_min = awb_calib_v20->cct_clip_cfg.outdoor_cct_min;
    commV20->wbGainClip.enable= awb_calib_v20->wbGainClipEn;
    memcpy(commV20->wbGainClip.cct, awb_calib_v20->cct_clip_cfg.cct,sizeof(float)*commV20->wbGainClip.cct_len);
    memcpy(commV20->wbGainClip.cri_bound_low, awb_calib_v20->cct_clip_cfg.cri_bound_low,sizeof(float)*commV20->wbGainClip.cri_bound_low_len);
    memcpy(commV20->wbGainClip.cri_bound_up, awb_calib_v20->cct_clip_cfg.cri_bound_up,sizeof(float)*commV20->wbGainClip.cri_bound_up_len);
    commV20->division.lumaValThLow= awb_adjust->LV_THL;
    commV20->division.lumaValThLow2= awb_adjust->LV_THL2;
    commV20->division.lumaValThHigh= awb_adjust->LV_THH;
    commV20->division.lumaValThHigh2= awb_adjust->LV_THH2;
    commV20->division.wpNumTh.lumaValue_len = awb_adjust->WP_TH.num;
    memcpy(commV20->division.wpNumTh.lumaValue, awb_adjust->WP_TH.lumaValue,sizeof(float)*commV20->division.wpNumTh.lumaValue_len);
    commV20->division.wpNumTh.high_len = awb_adjust->WP_TH.num;
    memcpy(commV20->division.wpNumTh.high, awb_adjust->WP_TH.WP_THH,sizeof(float)*commV20->division.wpNumTh.lumaValue_len);
    commV20->division.wpNumTh.low_len = awb_adjust->WP_TH.num;
    memcpy(commV20->division.wpNumTh.low, awb_adjust->WP_TH.WP_THL,sizeof(float)*commV20->division.wpNumTh.lumaValue_len);
    memcpy(commV20->defaultNightGain,awb_calib_v20->temporalDefaultGain, sizeof(commV20->defaultNightGain));
    memcpy(commV20->lumaValueMatrix,awb_adjust->LVMatrix, sizeof(commV20->lumaValueMatrix));
    memcpy(commV20->defaultNightGainWeight,awb_adjust->tempWeight, sizeof(commV20->defaultNightGainWeight));
    commV20->probCalcDis.proDis_THH = awb_adjust->proDis_THH;
    commV20->probCalcDis.proDis_THL = awb_adjust->proDis_THL;
    commV20->probCalcLv.outdoorLumaValThHigh = awb_adjust->proLV_Outdoor_THH;
    commV20->probCalcLv.outdoorLumaValThLow = awb_adjust->proLV_Outdoor_THL;
    commV20->probCalcWp.wpNumPercTh= awb_adjust->wpNumPercTh;
    commV20->probCalcWp.wpNumPercTh2= 0.2;
    commV20->converged.varThforDamp = awb_adjust->convergedVarTh;
    commV20->converged.varThforUnDamp= awb_adjust->convergedVarTh;
    commV20->xyRegionStableSelection.enable = true;
    commV20->xyRegionStableSelection.wpNumTh.lumaValue_len= awb_adjust->wpNumTh.num;
    memcpy(commV20->xyRegionStableSelection.wpNumTh.lumaValue,awb_adjust->wpNumTh.lumaValue,sizeof(float)*awb_adjust->wpNumTh.num);
    commV20->xyRegionStableSelection.wpNumTh.forBigType_len= awb_adjust->wpNumTh.num;
    memcpy(commV20->xyRegionStableSelection.wpNumTh.forBigType,awb_adjust->wpNumTh.wpNumThForBigType,sizeof(float)*awb_adjust->wpNumTh.num);
    commV20->xyRegionStableSelection.wpNumTh.forExtraType_len= awb_adjust->wpNumTh.num;
    memcpy(commV20->xyRegionStableSelection.wpNumTh.forExtraType,awb_adjust->wpNumTh.wpNumThForExtraType,sizeof(float)*awb_adjust->wpNumTh.num);
    commV20->xyRegionStableSelection.xyTypeListSize = awb_adjust->xyTypeListSize;
    commV20->xyRegionStableSelection.varianceLumaTh = awb_adjust->varianceLumaTh;
    memcpy(commV20->weightForNightGainCalc, awb_adjust->temporalGainSetWeight, commV20->weightForNightGainCalc_len*sizeof(unsigned char));
    commV20->singleColorProces.enable = true;
    for(int i=0; i<commV20->singleColorProces.colorBlock_len; i++){
        commV20->singleColorProces.colorBlock[i].index = awb_calib_v20->sIndSelColor[i];
        commV20->singleColorProces.colorBlock[i].meanC= awb_calib_v20->sMeanCh[0][i];
        commV20->singleColorProces.colorBlock[i].meanH= awb_calib_v20->sMeanCh[1][i];
    }
    for(int i=0; i<commV20->singleColorProces.lsUsedForEstimation_len; i++){
        strcpy(commV20->singleColorProces.lsUsedForEstimation[i].name, awb_calib_v20->sNameIllEst[i]);
        commV20->singleColorProces.lsUsedForEstimation[i].RGain= awb_calib_v20->srGain[i];
        commV20->singleColorProces.lsUsedForEstimation[i].BGain= awb_calib_v20->sbGain[i];
    }
    commV20->singleColorProces.alpha= awb_calib_v20->sAlpha;
    memcpy(commV20->lineRgBg,awb_calib_v20->lineRgBg,sizeof(commV20->lineRgBg));
    memcpy(commV20->lineRgProjCCT,awb_calib_v20->lineRgProjCCT,sizeof(commV20->lineRgProjCCT));
    commV20->chrAdpttAdj.enable = awb_adjust->ca_enable;
    commV20->chrAdpttAdj.laCalcFactor = awb_adjust->ca_LACalcFactor;
    memcpy(commV20->chrAdpttAdj.targetGain, awb_calib_v20->ca_targetGain, sizeof(commV20->chrAdpttAdj.targetGain));
    commV20->remosaicCfg.enable = awb_adjust->remosaic_cfg.enable;
    commV20->remosaicCfg.applyInvWbGainEnable= false;
    memcpy(commV20->remosaicCfg.sensorWbGain, awb_adjust->remosaic_cfg.sensor_awb_gain, sizeof(commV20->remosaicCfg.sensorWbGain));
    memcpy(&commV20->wbGainOffset, &awb_adjust->wbGainOffset, sizeof(commV20->wbGainOffset));

}
void convertCalib2calibV2(const CamCalibDbContext_t *calib,CamCalibDbV2Context_t *calibV2)
{

    convertCalib2calibV20(calib, calibV2);
    convertCalib2calibV21(calib, calibV2);

}