#include "iqconverter.h"

#define DEFAULT_MAIN_SCENE  "normal"
#define DEFAULT_SUB_SCENE  "day"

#if defined(ISP_HW_V20)
int g_rkaiq_isp_hw_ver = 20;
#elif defined(ISP_HW_V21)
int g_rkaiq_isp_hw_ver = 21;
#else
#error "WRONG ISP_HW_VERSION, ONLY SUPPORT V20 AND V21 NOW !"
#endif

namespace RkCam {

IQConverter::IQConverter(const char *xml, const char *json)
    : ifile(std::string(xml)), ofile(std::string(json)), calibv1(nullptr) {
    calibv2 = calibdbV2_ctx_new();
    memset(&calibproj, 0, sizeof(CamCalibDbProj_t));
}

int IQConverter::convert() {
    calibv1 = RkAiqCalibDb::createCalibDb((char *)ifile.c_str());
    if (!calibv1) {
        printf("[XML]load %s failed!\n", ifile.c_str());
        return -1;
    } else {
        printf("[XML] %s load finished!\n", ifile.c_str());
    }
    doConvert();

    calibproj.sensor_calib = *calibv2->sensor_info;
    calibproj.module_calib = *calibv2->module_info;
    calibproj.sys_static_cfg = *calibv2->sys_cfg;
    addToScene(&calibproj, DEFAULT_MAIN_SCENE, DEFAULT_SUB_SCENE, calibv2);

    if (0 != RkAiqCalibDbV2::calibproj2json(ofile.c_str(), &calibproj)) {
        printf("convert %s to %s failed!\n", ifile.c_str(), ofile.c_str());
        return -1;
    }

    CalibV2AecFree(calibv2);

    if (CHECK_ISP_HW_V20())
        CalibV2AwbV20Free(calibv2);
    if (CHECK_ISP_HW_V21())
        CalibV2AwbV21Free(calibv2);

    //bayernrV1_calibdbV2_free(calibv2->bayernr_v1);
    //mfnrV1_calibdbV2_free(calibv2->mfnr_v1);
    //uvnrV1_calibdbV2_free(calibv2->uvnr_v1);
    //ynrV1_calibdbV2_free(calibv2->ynr_v1);

    CalibV2CCMFree(calibv2);
    CalibV2AfFree(calibv2);
    CalibV2Lut3DFree(calibv2);
    return 0;
}

void CalibConverterAE::convert(CamCalibDbV2Context_t *calibv2,
                               CamCalibDbContext_t *calibv1) {

    CalibDb_Aec_ParaV2_t* calibv2_ae_calib =
        (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ae_calib));
    memset(calibv2_ae_calib, 0, sizeof(CalibDb_Aec_ParaV2_t));

    convertAecCalibV1ToCalibV2(calibv1, calibv2);

#if 1
    CalibDb_Sensor_ParaV2_t* calibv2_sensor_calib =
        (CalibDb_Sensor_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, sensor_calib));
    convertSensorinfoCalibV1ToCalibV2(calibv1, calibv2_sensor_calib);

    CalibDb_Module_ParaV2_t* calibv2_module_calib = 
        (CalibDb_Module_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, module_calib));
    convertModuleinfoCalibV1ToCalibV2(calibv1, calibv2_module_calib);
#endif
}

void CalibConverterAWB::convert(CamCalibDbV2Context_t *calibv2,
                                CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V20()) {
        convertCalib2calibV20(calibv1, calibv2);
    }
    if (CHECK_ISP_HW_V21()) {
        convertCalib2calibV21(calibv1, calibv2);
    }
}

void CalibConverterAblc::convert(CamCalibDbV2Context_t *calibv2,
                                 CamCalibDbContext_t *calibv1) {
    CalibDb_Blc_t* calib_v1_blc =
        (CalibDb_Blc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, blc);
    if (!calib_v1_blc)
        return;

    CalibDbV2_Ablc_t* calibv2_ablc_calib =
        (CalibDbV2_Ablc_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ablc_calib));
    if (!calibv2_ablc_calib)
        return;
    //len
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len = 13;
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.R_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gr_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gb_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.B_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;

    //malloc
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO = (float *) malloc(sizeof(float) * 13);
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.R_Channel = (float *) malloc(sizeof(float) * 13);
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gr_Channel = (float *) malloc(sizeof(float) * 13);
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gb_Channel = (float *) malloc(sizeof(float) * 13);
    calibv2_ablc_calib->BlcTuningPara.BLC_Data.B_Channel = (float *) malloc(sizeof(float) * 13);

    calibv2_ablc_calib->BlcTuningPara.enable = calib_v1_blc->enable ? true : false;
    for(int i = 0; i < calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len; i++) {
        calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO[i] = calib_v1_blc->mode_cell[0].iso[i];
        calibv2_ablc_calib->BlcTuningPara.BLC_Data.R_Channel[i] = calib_v1_blc->mode_cell[0].level[0][i];
        calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gr_Channel[i] = calib_v1_blc->mode_cell[0].level[1][i];
        calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gb_Channel[i] = calib_v1_blc->mode_cell[0].level[2][i];
        calibv2_ablc_calib->BlcTuningPara.BLC_Data.B_Channel[i] = calib_v1_blc->mode_cell[0].level[3][i];
    }
}

void CalibConverterAdpcc::convert(CamCalibDbV2Context_t *calibv2,
                                  CamCalibDbContext_t *calibv1) {
    CalibDb_Dpcc_t* calibv1_dpcc =
        (CalibDb_Dpcc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, dpcc);
    if (!calibv1_dpcc)
        return;

    CalibDbV2_Dpcc_t* calibv2_adpcc_calib =
        (CalibDbV2_Dpcc_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, adpcc_calib));
    if (!calibv2_adpcc_calib)
        return;

    //len
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len = 13;
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Single_level_len = calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len;
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Double_level_len = calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len;
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Triple_level_len = calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len;
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len = 13;
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_single_len = calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len;
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_multiple_len = calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len;

    //malloc
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO = (float *) malloc(sizeof(float) * 13);
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Single_level = (int *) malloc(sizeof(int) * 13);
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Double_level = (int *) malloc(sizeof(int) * 13);
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Triple_level = (int *) malloc(sizeof(int) * 13);
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO = (float *) malloc(sizeof(float) * 13);
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_single = (int *) malloc(sizeof(int) * 13);
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_multiple = (int *) malloc(sizeof(int) * 13);

    //enable
    calibv2_adpcc_calib->DpccTuningPara.Enable = calibv1_dpcc->enable ? true : false;

    //fast mode
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_mode_en = calibv1_dpcc->fast.fast_mode_double_en ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Single_enable = calibv1_dpcc->fast.fast_mode_single_en ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Double_enable = calibv1_dpcc->fast.fast_mode_double_en ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Triple_enable = calibv1_dpcc->fast.fast_mode_triple_en ? true : false;
    for(int i = 0; i < calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len; i++) {
        calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO[i] = calibv1_dpcc->fast.ISO[i];
        calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Single_level[i] = calibv1_dpcc->fast.fast_mode_single_level[i];
        calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Double_level[i] = calibv1_dpcc->fast.fast_mode_double_level[i];
        calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Triple_level[i] = calibv1_dpcc->fast.fast_mode_triple_level[i];
    }

    //expert mode
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.grayscale_mode = calibv1_dpcc->expert.grayscale_mode ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_Enable = calibv1_dpcc->expert.stage1_Enable[0] ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.rk_out_sel = calibv1_dpcc->expert.rk_out_sel[0];
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.dpcc_out_sel = calibv1_dpcc->expert.dpcc_out_sel[0] ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_g_3x3 = calibv1_dpcc->expert.stage1_g_3x3[0] ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_rb_3x3 = calibv1_dpcc->expert.stage1_rb_3x3[0] ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_inc_g_center = calibv1_dpcc->expert.stage1_inc_g_center[0] ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_inc_rb_center = calibv1_dpcc->expert.stage1_inc_rb_center[0] ? true : false;
    for(int i = 0; i < CALIBDB_ADPCC_KNOTS_NUM; i++) {
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.ISO[i] = calibv1_dpcc->expert.iso[i];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.fix_set[i] = calibv1_dpcc->expert.stage1_use_fix_set[i];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.set1[i] = calibv1_dpcc->expert.stage1_use_set1[i];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.set2[i] = calibv1_dpcc->expert.stage1_use_set2[i];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.set3[i] = calibv1_dpcc->expert.stage1_use_set3[i];
    }
    for(int j = 0; j < CALIBDB_ADPCC_KNOTS_NUM; j++) {
        //set1
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.RK_enable[j] = calibv1_dpcc->expert.set[0].rk.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.rb_sw_mindis[j] = calibv1_dpcc->expert.set[0].rk.rb_sw_mindis[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.g_sw_mindis[j] = calibv1_dpcc->expert.set[0].rk.g_sw_mindis[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.sw_dis_scale_min[j] = calibv1_dpcc->expert.set[0].rk.sw_dis_scale_min[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.sw_dis_scale_max[j] = calibv1_dpcc->expert.set[0].rk.sw_dis_scale_max[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.LC_enable[j] = calibv1_dpcc->expert.set[0].lc.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.g_line_thr[j] = calibv1_dpcc->expert.set[0].lc.g_line_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.rb_line_thr[j] = calibv1_dpcc->expert.set[0].lc.rb_line_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.g_line_mad_fac[j] = calibv1_dpcc->expert.set[0].lc.g_line_mad_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.rb_line_mad_fac[j] = calibv1_dpcc->expert.set[0].lc.rb_line_mad_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.PG.PG_enable[j] = calibv1_dpcc->expert.set[0].pg.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.PG.g_pg_fac[j] = calibv1_dpcc->expert.set[0].pg.g_pg_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.PG.rb_pg_fac[j] = calibv1_dpcc->expert.set[0].pg.rb_pg_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.RND_enable[j] = calibv1_dpcc->expert.set[0].rnd.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.g_rnd_thr[j] = calibv1_dpcc->expert.set[0].rnd.g_rnd_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.rb_rnd_thr[j] = calibv1_dpcc->expert.set[0].rnd.rb_rnd_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.g_rnd_offs[j] = calibv1_dpcc->expert.set[0].rnd.g_rnd_offs[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.rb_rnd_offs[j] = calibv1_dpcc->expert.set[0].rnd.rb_rnd_offs[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RG.RG_enable[j] = calibv1_dpcc->expert.set[0].rg.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RG.g_rg_fac[j] = calibv1_dpcc->expert.set[0].rg.g_rg_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RG.rb_rg_fac[j] = calibv1_dpcc->expert.set[0].rg.rb_rg_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RO.RO_enable[j] = calibv1_dpcc->expert.set[0].ro.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RO.rb_ro_lim[j] = calibv1_dpcc->expert.set[0].ro.rb_ro_lim[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RO.g_ro_lim[j] = calibv1_dpcc->expert.set[0].ro.g_ro_lim[j];
        //set2
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.RK_enable[j] = calibv1_dpcc->expert.set[1].rk.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.rb_sw_mindis[j] = calibv1_dpcc->expert.set[1].rk.rb_sw_mindis[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.g_sw_mindis[j] = calibv1_dpcc->expert.set[1].rk.g_sw_mindis[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.sw_dis_scale_min[j] = calibv1_dpcc->expert.set[1].rk.sw_dis_scale_min[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.sw_dis_scale_max[j] = calibv1_dpcc->expert.set[1].rk.sw_dis_scale_max[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.LC_enable[j] = calibv1_dpcc->expert.set[1].lc.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.g_line_thr[j] = calibv1_dpcc->expert.set[1].lc.g_line_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.rb_line_thr[j] = calibv1_dpcc->expert.set[1].lc.rb_line_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.g_line_mad_fac[j] = calibv1_dpcc->expert.set[1].lc.g_line_mad_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.rb_line_mad_fac[j] = calibv1_dpcc->expert.set[1].lc.rb_line_mad_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.PG.PG_enable[j] = calibv1_dpcc->expert.set[1].pg.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.PG.g_pg_fac[j] = calibv1_dpcc->expert.set[1].pg.g_pg_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.PG.rb_pg_fac[j] = calibv1_dpcc->expert.set[1].pg.rb_pg_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.RND_enable[j] = calibv1_dpcc->expert.set[1].rnd.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.g_rnd_thr[j] = calibv1_dpcc->expert.set[1].rnd.g_rnd_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.rb_rnd_thr[j] = calibv1_dpcc->expert.set[1].rnd.rb_rnd_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.g_rnd_offs[j] = calibv1_dpcc->expert.set[1].rnd.g_rnd_offs[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.rb_rnd_offs[j] = calibv1_dpcc->expert.set[1].rnd.rb_rnd_offs[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RG.RG_enable[j] = calibv1_dpcc->expert.set[1].rg.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RG.g_rg_fac[j] = calibv1_dpcc->expert.set[1].rg.g_rg_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RG.rb_rg_fac[j] = calibv1_dpcc->expert.set[1].rg.rb_rg_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RO.RO_enable[j] = calibv1_dpcc->expert.set[1].ro.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RO.rb_ro_lim[j] = calibv1_dpcc->expert.set[1].ro.rb_ro_lim[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RO.g_ro_lim[j] = calibv1_dpcc->expert.set[1].ro.g_ro_lim[j];
        //set3
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.RK_enable[j] = calibv1_dpcc->expert.set[2].rk.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.rb_sw_mindis[j] = calibv1_dpcc->expert.set[2].rk.rb_sw_mindis[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.g_sw_mindis[j] = calibv1_dpcc->expert.set[2].rk.g_sw_mindis[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.sw_dis_scale_min[j] = calibv1_dpcc->expert.set[2].rk.sw_dis_scale_min[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.sw_dis_scale_max[j] = calibv1_dpcc->expert.set[2].rk.sw_dis_scale_max[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.LC_enable[j] = calibv1_dpcc->expert.set[2].lc.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.g_line_thr[j] = calibv1_dpcc->expert.set[2].lc.g_line_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.rb_line_thr[j] = calibv1_dpcc->expert.set[2].lc.rb_line_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.g_line_mad_fac[j] = calibv1_dpcc->expert.set[2].lc.g_line_mad_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.rb_line_mad_fac[j] = calibv1_dpcc->expert.set[2].lc.rb_line_mad_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.PG.PG_enable[j] = calibv1_dpcc->expert.set[2].pg.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.PG.g_pg_fac[j] = calibv1_dpcc->expert.set[2].pg.g_pg_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.PG.rb_pg_fac[j] = calibv1_dpcc->expert.set[2].pg.rb_pg_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.RND_enable[j] = calibv1_dpcc->expert.set[2].rnd.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.g_rnd_thr[j] = calibv1_dpcc->expert.set[2].rnd.g_rnd_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.rb_rnd_thr[j] = calibv1_dpcc->expert.set[2].rnd.rb_rnd_thr[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.g_rnd_offs[j] = calibv1_dpcc->expert.set[2].rnd.g_rnd_offs[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.rb_rnd_offs[j] = calibv1_dpcc->expert.set[2].rnd.rb_rnd_offs[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RG.RG_enable[j] = calibv1_dpcc->expert.set[2].rg.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RG.g_rg_fac[j] = calibv1_dpcc->expert.set[2].rg.g_rg_fac[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RG.rb_rg_fac[j] = calibv1_dpcc->expert.set[2].rg.rb_rg_fac[j];

        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RO.RO_enable[j] = calibv1_dpcc->expert.set[2].ro.g_enable[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RO.rb_ro_lim[j] = calibv1_dpcc->expert.set[2].ro.rb_ro_lim[j];
        calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RO.g_ro_lim[j] = calibv1_dpcc->expert.set[2].ro.g_ro_lim[j];
    }

    //pdaf
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.en = calibv1_dpcc->pdaf.en ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.offsetx = calibv1_dpcc->pdaf.offsetx;
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.offsety = calibv1_dpcc->pdaf.offsety;
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapx = calibv1_dpcc->pdaf.wrapx;
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapy = calibv1_dpcc->pdaf.wrapy;
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapx_num = calibv1_dpcc->pdaf.wrapx_num;
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapy_num = calibv1_dpcc->pdaf.wrapy_num;
    calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.forward_med = calibv1_dpcc->pdaf.forward_med;
    for(int i = 0; i < 16; i++) {
        calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.point_en[i] = calibv1_dpcc->pdaf.point_en[i];
        calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.point_x[i] = calibv1_dpcc->pdaf.point_x[i];
        calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.point_y[i] = calibv1_dpcc->pdaf.point_y[i];
    }

    //sensor dpcc
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.sensor_dpcc_auto_en = calibv1_dpcc->sensor_dpcc.en ? true : false;
    calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.max_level = (int)(calibv1_dpcc->sensor_dpcc.max_level);
    for(int i = 0; i < calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len; i++) {
        calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO[i] = (int)(calibv1_dpcc->sensor_dpcc.iso[i]);
        calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_single[i] = (int)(calibv1_dpcc->sensor_dpcc.level_single[i]);
        calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_multiple[i] = (int)(calibv1_dpcc->sensor_dpcc.level_multiple[i]);
    }
}

void CalibConverterAdegamma::convert(CamCalibDbV2Context_t *calibv2,
                                     CamCalibDbContext_t *calibv1) {
    CalibDb_Degamma_t* calib_v1_degamma =
        (CalibDb_Degamma_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, degamma);
    if (!calib_v1_degamma)
        return;

    CalibDbV2_Adegmma_t* calibv2_adegamma_calib =
        (CalibDbV2_Adegmma_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, adegamma_calib));
    if (!calibv2_adegamma_calib)
        return;

    calibv2_adegamma_calib->DegammaTuningPara.degamma_en = calib_v1_degamma->degamma_en ? true : false;
    for(int i = 0; i < ADEGAMMA_CRUVE_KNOTS; i++) {
        calibv2_adegamma_calib->DegammaTuningPara.X_axis[i] = (int)(calib_v1_degamma->mode[0].X_axis[i] + 0.5);
        calibv2_adegamma_calib->DegammaTuningPara.curve_R[i] = (int)(calib_v1_degamma->mode[0].curve_R[i] + 0.5);
        calibv2_adegamma_calib->DegammaTuningPara.curve_G[i] = (int)(calib_v1_degamma->mode[0].curve_G[i] + 0.5);
        calibv2_adegamma_calib->DegammaTuningPara.curve_B[i] = (int)(calib_v1_degamma->mode[0].curve_B[i] + 0.5);
    }
}

void CalibConverterAgic::convert(CamCalibDbV2Context_t *calibv2,
                                 CamCalibDbContext_t *calibv1) {
    //len
    CalibDbV2_Gic_V20_t* calibv2_agic_calib_V20 =
        (CalibDbV2_Gic_V20_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, agic_calib_v20));
    if (calibv2_agic_calib_V20) {
        calibv2_agic_calib_V20->GicTuningPara.GicData.ISO_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_busy_thre_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr1_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr2_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.gb_thre_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorV_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorVboth_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.dark_thre_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.dark_threHi_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_dark_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_dark_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark1_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark2_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_0_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_1_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitLo_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitHi_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.textureStrength_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleHi_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleLo_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.globalStrength_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coea_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coeb_len = 9;
        calibv2_agic_calib_V20->GicTuningPara.GicData.diff_clip_len = 9;
    }

    CalibDbV2_Gic_V21_t* calibv2_agic_calib_V21 =
        (CalibDbV2_Gic_V21_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, agic_calib_v21));
    if (calibv2_agic_calib_V21) {
        calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len = 9;
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_busy_thre_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr2_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.gb_thre_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorV_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorVboth_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.dark_thre_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.dark_threHi_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_dark_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_dark_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark2_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_0_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseScale_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseBase_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.globalStrength_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
        calibv2_agic_calib_V21->GicTuningPara.GicData.diff_clip_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
    }

    //malloc
    if (calibv2_agic_calib_V20) {
        calibv2_agic_calib_V20->GicTuningPara.GicData.ISO = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_busy_thre = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr2 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.gb_thre = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorV = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorVboth = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.dark_thre = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.dark_threHi = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_dark = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_dark = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark2 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_0 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitLo = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitHi = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.textureStrength = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleHi = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleLo = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.globalStrength = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coea = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coeb = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V20->GicTuningPara.GicData.diff_clip = (float *) malloc(sizeof(float) * 9);
    }

    if (calibv2_agic_calib_V21) {
        calibv2_agic_calib_V21->GicTuningPara.GicData.ISO = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_busy_thre = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr2 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.gb_thre = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorV = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorVboth = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.dark_thre = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.dark_threHi = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_dark = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_dark = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark2 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_0 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_1 = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseScale = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseBase = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.globalStrength = (float *) malloc(sizeof(float) * 9);
        calibv2_agic_calib_V21->GicTuningPara.GicData.diff_clip = (float *) malloc(sizeof(float) * 9);
    }
    //v20
    if (CHECK_ISP_HW_V20()) {
        CalibDb_Gic_t* calibv1_gic =
            (CalibDb_Gic_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, gic);
        calibv2_agic_calib_V20->GicTuningPara.enable = calibv1_gic->calib_v20[0].gic_en ? true : false;
        calibv2_agic_calib_V20->GicTuningPara.edge_en = calibv1_gic->calib_v20[0].edge_en ? true : false;
        calibv2_agic_calib_V20->GicTuningPara.noise_cut_en = calibv1_gic->calib_v20[0].noise_cut_en ? true : false;
        calibv2_agic_calib_V20->GicTuningPara.gr_ration = calibv1_gic->calib_v20[0].gr_ration;
        for(int i = 0; i < calibv2_agic_calib_V20->GicTuningPara.GicData.ISO_len; i++) {
            calibv2_agic_calib_V20->GicTuningPara.GicData.ISO[i] = calibv1_gic->calib_v20[0].setting.iso[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.min_busy_thre[i] = calibv1_gic->calib_v20[0].setting.min_busy_thre[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr1[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr1[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr2[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr2[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1[i] = calibv1_gic->calib_v20[0].setting.k_grad1[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2[i] = calibv1_gic->calib_v20[0].setting.k_grad2[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.gb_thre[i] = calibv1_gic->calib_v20[0].setting.gb_thre[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorV[i] = calibv1_gic->calib_v20[0].setting.maxCorV[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorVboth[i] = calibv1_gic->calib_v20[0].setting.maxCorVboth[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.dark_thre[i] = calibv1_gic->calib_v20[0].setting.dark_thre[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.dark_threHi[i] = calibv1_gic->calib_v20[0].setting.dark_threHi[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_dark[i] = calibv1_gic->calib_v20[0].setting.k_grad1_dark[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_dark[i] = calibv1_gic->calib_v20[0].setting.k_grad2_dark[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark1[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr_dark1[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark2[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr_dark2[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_0[i] = calibv1_gic->calib_v20[0].setting.noiseCurve_0[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_1[i] = calibv1_gic->calib_v20[0].setting.noiseCurve_1[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitLo[i] = calibv1_gic->calib_v20[0].setting.GValueLimitLo[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitHi[i] = calibv1_gic->calib_v20[0].setting.GValueLimitHi[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.textureStrength[i] = calibv1_gic->calib_v20[0].setting.textureStrength[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleLo[i] = calibv1_gic->calib_v20[0].setting.ScaleLo[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleHi[i] = calibv1_gic->calib_v20[0].setting.ScaleHi[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.globalStrength[i] = calibv1_gic->calib_v20[0].setting.globalStrength[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coea[i] = calibv1_gic->calib_v20[0].setting.noise_coea[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coeb[i] = calibv1_gic->calib_v20[0].setting.noise_coeb[i];
            calibv2_agic_calib_V20->GicTuningPara.GicData.diff_clip[i] = calibv1_gic->calib_v20[0].setting.diff_clip[i];
        }
    }

    //v21
    if (CHECK_ISP_HW_V21()) {
        CalibDb_Gic_Isp21_t* calibv1_gic_isp21 =
            (CalibDb_Gic_Isp21_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, gic);
        calibv2_agic_calib_V21->GicTuningPara.enable = calibv1_gic_isp21->calib_v21[0].gic_en ? true : false;
        calibv2_agic_calib_V21->GicTuningPara.gr_ration = calibv1_gic_isp21->calib_v21[0].gr_ration;
        for(int i = 0; i < calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len; i++) {
            calibv2_agic_calib_V21->GicTuningPara.GicData.ISO[i] = calibv1_gic_isp21->calib_v21[0].setting.iso[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.min_busy_thre[i] = calibv1_gic_isp21->calib_v21[0].setting.min_busy_thre[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr1[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr1[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr2[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr2[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad1[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad2[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.gb_thre[i] = calibv1_gic_isp21->calib_v21[0].setting.gb_thre[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorV[i] = calibv1_gic_isp21->calib_v21[0].setting.maxCorV[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorVboth[i] = calibv1_gic_isp21->calib_v21[0].setting.maxCorVboth[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.dark_thre[i] = calibv1_gic_isp21->calib_v21[0].setting.dark_thre[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.dark_threHi[i] = calibv1_gic_isp21->calib_v21[0].setting.dark_threHi[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_dark[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad1_dark[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_dark[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad2_dark[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark1[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr_dark1[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark2[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr_dark2[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_0[i] = calibv1_gic_isp21->calib_v21[0].setting.noiseCurve_0[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_1[i] = calibv1_gic_isp21->calib_v21[0].setting.noiseCurve_1[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.globalStrength[i] = calibv1_gic_isp21->calib_v21[0].setting.globalStrength[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseBase[i] = calibv1_gic_isp21->calib_v21[0].setting.NoiseBase[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseScale[i] = calibv1_gic_isp21->calib_v21[0].setting.NoiseScale[i];
            calibv2_agic_calib_V21->GicTuningPara.GicData.diff_clip[i] = calibv1_gic_isp21->calib_v21[0].setting.diff_clip[i];
        }
    }
}

void CalibConverterAdehaze::convert(CamCalibDbV2Context_t *calibv2,
                                    CamCalibDbContext_t *calibv1) {
    convertDehazeCalib2CalibV2(calibv1, calibv2);
}

void CalibConverterAmerge::convert(CamCalibDbV2Context_t *calibv2,
                                   CamCalibDbContext_t *calibv1) {
    CalibDb_Amerge_Para_t* calibv1_amerge =
        (CalibDb_Amerge_Para_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, amerge);
    if (!calibv1_amerge)
        return;

    CalibDbV2_merge_t* calibv2_amerge_calib =
        (CalibDbV2_merge_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, amerge_calib));
    if (!calibv2_amerge_calib)
        return;

    //len
    calibv2_amerge_calib->MergeTuningPara.OECurve.EnvLv_len = 13;
    calibv2_amerge_calib->MergeTuningPara.OECurve.Smooth_len = calibv2_amerge_calib->MergeTuningPara.OECurve.EnvLv_len;
    calibv2_amerge_calib->MergeTuningPara.OECurve.Offset_len = calibv2_amerge_calib->MergeTuningPara.OECurve.EnvLv_len;

    calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef_len = 13;
    calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_smooth_len = calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef_len;
    calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_offset_len = calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef_len;
    calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_smooth_len = calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef_len;
    calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_offset_len = calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef_len;

    //malloc
    calibv2_amerge_calib->MergeTuningPara.OECurve.EnvLv = (float *) malloc(sizeof(float) * 13);
    calibv2_amerge_calib->MergeTuningPara.OECurve.Smooth = (float *) malloc(sizeof(float) * 13);
    calibv2_amerge_calib->MergeTuningPara.OECurve.Offset = (float *) malloc(sizeof(float) * 13);

    calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef = (float *) malloc(sizeof(float) * 13);
    calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_smooth = (float *) malloc(sizeof(float) * 13);
    calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_offset = (float *) malloc(sizeof(float) * 13);
    calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_smooth = (float *) malloc(sizeof(float) * 13);
    calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_offset = (float *) malloc(sizeof(float) * 13);

    for(int i = 0; i < 13; i++) {
        calibv2_amerge_calib->MergeTuningPara.OECurve.EnvLv[i] = calibv1_amerge->envLevel[i];
        calibv2_amerge_calib->MergeTuningPara.OECurve.Smooth[i] = calibv1_amerge->oeCurve_smooth[i];
        calibv2_amerge_calib->MergeTuningPara.OECurve.Offset[i] = calibv1_amerge->oeCurve_offset[i];
        calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef[i] = calibv1_amerge->moveCoef[i];
        calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_smooth[i] = calibv1_amerge->mdCurveLm_smooth[i];
        calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_offset[i] = calibv1_amerge->mdCurveLm_offset[i];
        calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_smooth[i] = calibv1_amerge->mdCurveMs_smooth[i];
        calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_offset[i] = calibv1_amerge->mdCurveMs_offset[i];
    }
    calibv2_amerge_calib->MergeTuningPara.ByPassThr = 0;
    calibv2_amerge_calib->MergeTuningPara.OECurve_damp = calibv1_amerge->oeCurve_damp;
    calibv2_amerge_calib->MergeTuningPara.MDCurveLM_damp = calibv1_amerge->mdCurveLm_damp;
    calibv2_amerge_calib->MergeTuningPara.MDCurveMS_damp = calibv1_amerge->mdCurveMs_damp;
}

void CalibConverterAtmo::convert(CamCalibDbV2Context_t *calibv2,
                                 CamCalibDbContext_t *calibv1) {
    CalibDb_Atmo_Para_t* calibv1_atmo =
        (CalibDb_Atmo_Para_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, atmo);
    if (!calibv1_atmo )
        return;

    CalibDbV2_tmo_t* calibv2_atmo_calib =
        (CalibDbV2_tmo_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, atmo_calib));
    if (!calibv2_atmo_calib)
        return;

    //len
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len = 13;
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;

    //malloc
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv = (float *) malloc(sizeof(float) * 13);
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength = (float *) malloc(sizeof(float) * 13);


    calibv2_atmo_calib->TmoTuningPara.Enable = calibv1_atmo->en[0].en;
    //global luma
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.Mode = calibv1_atmo->luma[0].GlobalLumaMode ? GLOBALLUMAMODE_ISO : GLOBALLUMAMODE_ENVLV;
    for(int i = 0; i < 13; i++) {
        calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv[i] = calibv1_atmo->luma[0].envLevel[i];
        calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO[i] = calibv1_atmo->luma[0].ISO[i];
        calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength[i] = calibv1_atmo->luma[0].globalLuma[i];
    }
    calibv2_atmo_calib->TmoTuningPara.GlobalLuma.Tolerance = calibv1_atmo->luma[0].Tolerance;
    //details high light
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.Mode = calibv1_atmo->HighLight[0].DetailsHighLightMode ? DETAILSHIGHLIGHTMODE_ENVLV : DETAILSHIGHLIGHTMODE_OEPDF;
    for(int i = 0; i < 13; i++) {

        calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf[i] = calibv1_atmo->HighLight[0].OEPdf[i];
        calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv[i] = calibv1_atmo->HighLight[0].EnvLv[i];
        calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength[i] = calibv1_atmo->HighLight[0].detailsHighLight[i];
    }
    calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.Tolerance = calibv1_atmo->HighLight[0].Tolerance;
    //details low light
    if(calibv1_atmo->LowLight[0].DetailsLowLightMode == 0)
        calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Mode = DETAILSLOWLIGHTMODE_FOCUSLUMA;
    else if(calibv1_atmo->LowLight[0].DetailsLowLightMode > 0 && calibv1_atmo->LowLight[0].DetailsLowLightMode < 2)
        calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Mode = DETAILSLOWLIGHTMODE_DARKPDF;
    else if(calibv1_atmo->LowLight[0].DetailsLowLightMode >= 2)
        calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Mode = DETAILSLOWLIGHTMODE_ISO;
    for(int i = 0; i < 13; i++) {

        calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma[i] = calibv1_atmo->LowLight[0].FocusLuma[i];
        calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf[i] = calibv1_atmo->LowLight[0].DarkPdf[i];
        calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO[i] = calibv1_atmo->LowLight[0].ISO[i];
        calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength[i] = calibv1_atmo->LowLight[0].detailsLowLight[i];
    }
    calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Tolerance = calibv1_atmo->LowLight[0].Tolerance;
    //global tmo
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.Enable = calibv1_atmo->GlobaTMO[0].en ? true : false;
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.IIR = calibv1_atmo->GlobaTMO[0].iir;
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.Mode = calibv1_atmo->GlobaTMO[0].mode ? TMOTYPEMODE_ENVLV : TMOTYPEMODE_DYNAMICRANGE;
    for(int i = 0; i < 13; i++) {

        calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange[i] = calibv1_atmo->GlobaTMO[0].DynamicRange[i];
        calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv[i] = calibv1_atmo->GlobaTMO[0].EnvLv[i];
        calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength[i] = calibv1_atmo->GlobaTMO[0].Strength[i];
    }
    calibv2_atmo_calib->TmoTuningPara.GlobaTMO.Tolerance = calibv1_atmo->GlobaTMO[0].Tolerance;
    //local tmo
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.Mode = calibv1_atmo->LocalTMO[0].LocalTMOMode ? TMOTYPEMODE_ENVLV : TMOTYPEMODE_DYNAMICRANGE;
    for(int i = 0; i < 13; i++) {

        calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange[i] = calibv1_atmo->LocalTMO[0].DynamicRange[i];
        calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv[i] = calibv1_atmo->LocalTMO[0].EnvLv[i];
        calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength[i] = calibv1_atmo->LocalTMO[0].Strength[i];
    }
    calibv2_atmo_calib->TmoTuningPara.LocalTMO.Tolerance = calibv1_atmo->LocalTMO[0].Tolerance;
    calibv2_atmo_calib->TmoTuningPara.damp = calibv1_atmo->damp;
}

void CalibConverterCpsl::convert(CamCalibDbV2Context_t* calibv2,
                                 CamCalibDbContext_t* calibv1) {
    CalibDb_Cpsl_t* calibv1_cpsl =
        (CalibDb_Cpsl_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, cpsl);
    if (!calibv1_cpsl)
        return;

    CalibDbV2_Cpsl_t* calibv2_cpsl_db =
        (CalibDbV2_Cpsl_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, cpsl));
    if (!calibv2_cpsl_db)
        return;
    CalibDbV2_Cpsl_Param_t* calibv2_cpsl_calib = &calibv2_cpsl_db->param;

    calibv2_cpsl_calib->enable = !!calibv1_cpsl->support_en;
    if (calibv1_cpsl->mode == 0) {
        calibv2_cpsl_calib->mode = RK_AIQ_OP_MODE_AUTO;
    } else if (calibv1_cpsl->mode == 1) {
        calibv2_cpsl_calib->mode = RK_AIQ_OP_MODE_MANUAL;
    } else {
        calibv2_cpsl_calib->mode = RK_AIQ_OP_MODE_INVALID;
    }

    calibv2_cpsl_calib->force_gray = !!calibv1_cpsl->gray;
    if (calibv1_cpsl->lght_src == 0) {
        calibv2_cpsl_calib->light_src = LED;
    } else if (calibv1_cpsl->lght_src == 1) {
        calibv2_cpsl_calib->light_src = IR;
    } else if (calibv1_cpsl->lght_src == 2) {
        calibv2_cpsl_calib->light_src = MIX;
    } else {
        calibv2_cpsl_calib->light_src = INVALID;
    }
    calibv2_cpsl_calib->auto_adjust_sens = calibv1_cpsl->ajust_sens;
    calibv2_cpsl_calib->auto_on2off_th = calibv1_cpsl->on2off_th;
    calibv2_cpsl_calib->auto_off2on_th = calibv1_cpsl->off2on_th;
    calibv2_cpsl_calib->manual_on = !!calibv1_cpsl->cpsl_on;
    calibv2_cpsl_calib->manual_strength = calibv1_cpsl->strength;
}

void CalibConverterAgamma::convert(CamCalibDbV2Context_t *calibv2,
                                   CamCalibDbContext_t *calibv1) {
    CalibDb_Gamma_t* calibv1_gamma =
        (CalibDb_Gamma_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, gamma);
    if (!calibv1_gamma)
        return;

    CalibDbV2_gamma_t* calibv2_agamma_calib =
        (CalibDbV2_gamma_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, agamma_calib));
    if (!calibv2_agamma_calib)
        return;

    calibv2_agamma_calib->GammaTuningPara.Gamma_en = calibv1_gamma->gamma_en ? true : false;
    calibv2_agamma_calib->GammaTuningPara.Gamma_out_segnum = calibv1_gamma->gamma_out_segnum ? GAMMATYPE_EQU : GAMMATYPE_LOG;
    calibv2_agamma_calib->GammaTuningPara.Gamma_out_offset = calibv1_gamma->gamma_out_offset;
    for(int i = 0; i < 45; i++)
        calibv2_agamma_calib->GammaTuningPara.Gamma_curve[i] = (int)(calibv1_gamma->curve_normal[i] + 0.5);
}

void CalibConverterBAYERNRV1::convert(CamCalibDbV2Context_t *calibv2,
                                      CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V20()) {
        CalibDb_BayerNr_2_t* calibv1_bayerNr =
            (CalibDb_BayerNr_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, bayerNr);
        if (!calibv1_bayerNr)
            return;

        CalibDbV2_BayerNrV1_t* calibv2_bayernr_v1 =
            (CalibDbV2_BayerNrV1_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, bayernr_v1));
        if (!calibv2_bayernr_v1)
            return;

        // TODO:
        bayernrV1_calibdb_to_calibdbV2(calibv1_bayerNr, calibv2_bayernr_v1, 0);
    }

}

void CalibConverterMFNRV1::convert(CamCalibDbV2Context_t *calibv2,
                                   CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V20()) {
        CalibDb_MFNR_2_t* calibv1_mfnr =
            (CalibDb_MFNR_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, mfnr);
        if (!calibv1_mfnr)
            return;

        CalibDbV2_MFNR_t* calibv2_mfnr_v1 =
            (CalibDbV2_MFNR_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, mfnr_v1));
        if (!calibv2_mfnr_v1)
            return;

        // TODO:
        mfnrV1_calibdb_to_calibdbV2(calibv1_mfnr, calibv2_mfnr_v1, 0);
    }

}

void CalibConverterUVNRV1::convert(CamCalibDbV2Context_t *calibv2,
                                   CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V20()) {
        CalibDb_UVNR_2_t* calibv1_uvnr =
            (CalibDb_UVNR_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, uvnr);
        if (!calibv1_uvnr)
            return;

        CalibDbV2_UVNR_t* calibv2_uvnr_v1 =
            (CalibDbV2_UVNR_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, uvnr_v1));
        if (!calibv2_uvnr_v1)
            return;

        // TODO:
        uvnrV1_calibdb_to_calibdbV2(calibv1_uvnr, calibv2_uvnr_v1, 0);
    }

}

void CalibConverterYNRV1::convert(CamCalibDbV2Context_t *calibv2,
                                  CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V20()) {
        CalibDb_YNR_2_t* calibv1_ynr =
            (CalibDb_YNR_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, ynr);
        if (!calibv1_ynr)
            return;

        CalibDbV2_YnrV1_t* calibv2_ynr_v1 =
            (CalibDbV2_YnrV1_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ynr_v1));
        if (!calibv2_ynr_v1)
            return;

        // TODO:
        ynrV1_calibdb_to_calibdbV2(calibv1_ynr, calibv2_ynr_v1, 0);
    }

}

void CalibConverterSHARPV1::convert(CamCalibDbV2Context_t *calibv2,
                                    CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V20()) {
        CalibDb_Sharp_2_t* calibv1_sharp =
            (CalibDb_Sharp_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, sharp);
        if (!calibv1_sharp)
            return;

        CalibDbV2_SharpV1_t* calibv2_sharp_v1 =
            (CalibDbV2_SharpV1_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, sharp_v1));
        if (!calibv2_sharp_v1)
            return;

        // TODO:
        sharpV1_calibdb_to_calibdbV2(calibv1_sharp, calibv2_sharp_v1, 0);
    }

}

void CalibConverterEDGEFILTERV1::convert(CamCalibDbV2Context_t *calibv2,
        CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V20()) {
        CalibDb_EdgeFilter_2_t* calibv1_edgeFilter =
            (CalibDb_EdgeFilter_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, edgeFilter);
        if (!calibv1_edgeFilter)
            return;

        CalibDbV2_Edgefilter_t* calibv2_edgefilter_v1 =
            (CalibDbV2_Edgefilter_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, edgefilter_v1));
        if (!calibv2_edgefilter_v1)
            return;

        // TODO:
        edgefilterV1_calibdb_to_calibdbV2(calibv1_edgeFilter, calibv2_edgefilter_v1, 0);
    }

}

void CalibConverterDebayer::convert(CamCalibDbV2Context_t* calibv2,
                                    CamCalibDbContext_t* calibv1) {
    CalibDb_RKDM_t* calibv1_dm =
        (CalibDb_RKDM_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, dm);
    if (!calibv1_dm)
        return;

    CalibDbV2_Debayer_t* calibv2_debayer =
        (CalibDbV2_Debayer_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, debayer));
    if (!calibv2_debayer)
        return;

    calibv2_debayer->param.debayer_en = !!calibv1_dm->debayer_en;
    for (int i = 0; i < 5; i++) {
        calibv2_debayer->param.debayer_filter1[i] = calibv1_dm->debayer_filter1[i];
        calibv2_debayer->param.debayer_filter2[i] = calibv1_dm->debayer_filter2[i];
    }
    calibv2_debayer->param.debayer_gain_offset = calibv1_dm->debayer_gain_offset;
    for (int i = 0; i < 9; i++) {
        calibv2_debayer->param.array.ISO[i] = calibv1_dm->ISO[i];
        calibv2_debayer->param.array.sharp_strength[i] = calibv1_dm->sharp_strength[i];
        calibv2_debayer->param.array.debayer_hf_offset[i] = calibv1_dm->debayer_hf_offset[i];

    }
    calibv2_debayer->param.debayer_gain_offset = calibv1_dm->debayer_gain_offset;
    for (int i = 0; i < 9; i++) {
        calibv2_debayer->param.array.ISO[i] = calibv1_dm->ISO[i];
        calibv2_debayer->param.array.sharp_strength[i] = calibv1_dm->sharp_strength[i];
        calibv2_debayer->param.array.debayer_hf_offset[i] = calibv1_dm->debayer_hf_offset[i];
    }
    calibv2_debayer->param.debayer_offset = calibv1_dm->debayer_offset;
    calibv2_debayer->param.debayer_clip_en = !!calibv1_dm->debayer_clip_en;
    calibv2_debayer->param.debayer_filter_g_en = !!calibv1_dm->debayer_filter_g_en;
    calibv2_debayer->param.debayer_filter_c_en = !!calibv1_dm->debayer_filter_c_en;
    calibv2_debayer->param.debayer_thed0 = calibv1_dm->debayer_thed0;
    calibv2_debayer->param.debayer_thed1 = calibv1_dm->debayer_thed1;
    calibv2_debayer->param.debayer_dist_scale = calibv1_dm->debayer_dist_scale;
    calibv2_debayer->param.debayer_cnr_strength = calibv1_dm->debayer_cnr_strength;
    calibv2_debayer->param.debayer_shift_num = calibv1_dm->debayer_shift_num;
}

void CalibConverterCproc::convert(CamCalibDbV2Context_t* calibv2,
                                  CamCalibDbContext_t* calibv1) {
    CalibDb_cProc_t* calibv1_cProc =
        (CalibDb_cProc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, cProc);
    if (!calibv1_cProc)
        return;

    CalibDbV2_Cproc_t* calibv2_cproc =
        (CalibDbV2_Cproc_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, cproc));
    if (!calibv2_cproc)
        return;

    calibv2_cproc->param.enable = !!calibv1_cProc->enable;
    calibv2_cproc->param.brightness = calibv1_cProc->brightness;
    calibv2_cproc->param.contrast = calibv1_cProc->contrast;
    calibv2_cproc->param.saturation = calibv1_cProc->saturation;
    calibv2_cproc->param.hue = calibv1_cProc->hue;
}

void CalibConverterIE::convert(CamCalibDbV2Context_t* calibv2,
                               CamCalibDbContext_t* calibv1) {
    CalibDb_IE_t* calibv1_ie =
        (CalibDb_IE_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, ie);
    if (!calibv1_ie)
        return;

    CalibDbV2_IE_t* calibv2_ie =
        (CalibDbV2_IE_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ie));
    if (!calibv2_ie)
        return;

    calibv2_ie->param.enable = !!calibv1_ie->enable;
    calibv2_ie->param.mode = calibv1_ie->mode;
}

void CalibConverterCCM::convert(CamCalibDbV2Context_t *calibv2,
                                CamCalibDbContext_t *calibv1) {

    convertCCMCalib2CalibV2(calibv1, calibv2);
}

void CalibConverterLUT3D::convert(CamCalibDbV2Context_t *calibv2,
                                  CamCalibDbContext_t *calibv1) {
    convertLut3DCalib2CalibV2(calibv1, calibv2);
}

void CalibConverterAdrc::convert(CamCalibDbV2Context_t *calibv2,
                                 CamCalibDbContext_t *calibv1) {

    convertAdrcCalibV1ToCalibV2(calibv1, calibv2);
}

/*

   void CalibConverterAF::convert(CamCalibDbV2Context_t* calibv2,
   CamCalibDbContext_t* calibv1)
   {

   }

   void CalibConverterASD::convert(CamCalibDbV2Context_t* calibv2,
   CamCalibDbContext_t* calibv1)
   {

   }

   .
   .
   .

*/

int IQConverter::addToScene(CamCalibDbProj_t *calibpj, const char *main_scene,
                            const char *sub_scene,
                            CamCalibDbV2Context_t *calibv2) {
    auto sub_vector = new CamCalibSubSceneList_t();
    auto main_vector = new CamCalibMainSceneList_t();

    sub_vector[0].name = strdup(sub_scene);
    memcpy(calibdbv2_get_scene_ptr(&sub_vector[0]),
           calibv2->calib_scene, calibdbV2_scene_ctx_size(calibv2));

    main_vector[0].name = strdup(main_scene);
    main_vector[0].sub_scene = sub_vector;
    main_vector[0].sub_scene_len = 1;

    calibpj->main_scene = main_vector;
    calibpj->main_scene_len = 1;

    return 0;
}

void CalibConverterALSC::convert(
    CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
{
    CalibDb_Lsc_t* calibv1_lsc =
        (CalibDb_Lsc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, lsc);
    if (!calibv1_lsc)
        return;

    CalibDbV2_LSC_t* calibv2_lsc_v2 =
        (CalibDbV2_LSC_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, lsc_v2));
    if (!calibv2_lsc_v2)
        return;

    CalibDb_LscTableProfile_t* tableV1;
    CalibDbV2_LscTableProfile_t* tableV2;

    CalibDbV2_LSC_t& lsc_v2 = *calibv2_lsc_v2;
    CalibDbV2_Lsc_Common_t& common = lsc_v2.common;

    common.enable = calibv1_lsc->enable;
    common.resolutionAll_len = calibv1_lsc->aLscCof.lscResNum;
    common.resolutionAll = (CalibDbV2_Lsc_Resolution_t*)
                           malloc(common.resolutionAll_len * sizeof(CalibDbV2_Lsc_Resolution_t));
    memset(common.resolutionAll, '\0', common.resolutionAll_len * sizeof(CalibDbV2_Lsc_Resolution_t));
    for (int i = 0; i < common.resolutionAll_len; i++) {
        strcpy(common.resolutionAll[i].name, calibv1_lsc->aLscCof.lscResName[i]);
    }

    lsc_v2.alscCoef.damp_enable = calibv1_lsc->damp_enable;

    int illuNumTotal = 0;
    CalibDb_AlscCof_t& pAlscCof = calibv1_lsc->aLscCof;
    for (int i = 0; i < USED_FOR_CASE_MAX; i++) {
        illuNumTotal += pAlscCof.illuNum[i];
    }
    lsc_v2.alscCoef.illAll_len = illuNumTotal;
    lsc_v2.alscCoef.illAll = (CalibDbV2_AlscCof_ill_t*)
                             malloc(illuNumTotal * sizeof(CalibDbV2_AlscCof_ill_t));
    CalibDbV2_AlscCof_ill_t* ill_v2 = lsc_v2.alscCoef.illAll;

    for (int ucase = 0; ucase < USED_FOR_CASE_MAX; ucase++) {
        int illuNum = pAlscCof.illuNum[ucase];
        for (int i = 0; i < illuNum; i++) {
            ill_v2->usedForCase = ucase;
            CalibDb_AlscCof_ill_t& ill_v1 = pAlscCof.illAll[ucase][i];
            strcpy(ill_v2->name, ill_v1.illuName);
            ill_v2->wbGain[0] = ill_v1.awbGain[0];
            ill_v2->wbGain[1] = ill_v1.awbGain[1];
            ill_v2->tableUsed_len = ill_v1.tableUsedNO;
            ill_v2->tableUsed = (lsc_name_t*)malloc(ill_v2->tableUsed_len * sizeof(lsc_name_t));
            for (int t = 0; t < ill_v2->tableUsed_len; t++) {
                strcpy(ill_v2->tableUsed[t].name, ill_v1.tableUsed[t]);
            }
            ill_v2->gains_len = ill_v1.vignettingCurve.arraySize;
            ill_v2->vig_len = ill_v1.vignettingCurve.arraySize;
            ill_v2->gains = (float*)malloc(ill_v2->gains_len * sizeof(float));
            ill_v2->vig   = (float*)malloc(ill_v2->vig_len * sizeof(float));
            for (int gains_id = 0; gains_id < ill_v2->gains_len; gains_id++) {
                ill_v2->gains[gains_id] = ill_v1.vignettingCurve.pSensorGain[gains_id];
            }
            for (int vig_id = 0; vig_id < ill_v2->vig_len; vig_id++) {
                ill_v2->vig[vig_id] = ill_v1.vignettingCurve.pVignetting[vig_id];
            }

            ill_v2++;
        }
    }

    lsc_v2.tbl.tableAll_len = calibv1_lsc->tableAllNum;
    lsc_v2.tbl.tableAll = (CalibDbV2_LscTableProfile_t*)
                          malloc(lsc_v2.tbl.tableAll_len * sizeof(CalibDbV2_LscTableProfile_t));

    for (int i = 0; i < lsc_v2.tbl.tableAll_len; i++) {
        tableV1 = calibv1_lsc->tableAll + i;
        tableV2 = lsc_v2.tbl.tableAll + i;

        memset(tableV2->name, '\0', sizeof(tableV2->name));
        strcpy(tableV2->name, tableV1->name);
        strcpy(tableV2->resolution, tableV1->resolution);
        strcpy(tableV2->illumination, tableV1->illumination);
        tableV2->vignetting = tableV1->vignetting;

        for (int j = 0; j < lsc_v2.common.resolutionAll_len; j++) {
            int ret = strcmp(lsc_v2.common.resolutionAll[j].name, tableV2->resolution);
            if(0 == ret) {
                memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_x, tableV1->LscXSizeTbl, sizeof(tableV1->LscXSizeTbl));
                memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_y, tableV1->LscYSizeTbl, sizeof(tableV1->LscYSizeTbl));
            }
        }

        memcpy(&tableV2->lsc_samples_red,    &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_RED],    sizeof(Cam17x17UShortMatrix_t));
        memcpy(&tableV2->lsc_samples_greenR, &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_GREENR], sizeof(Cam17x17UShortMatrix_t));
        memcpy(&tableV2->lsc_samples_greenB, &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_GREENB], sizeof(Cam17x17UShortMatrix_t));
        memcpy(&tableV2->lsc_samples_blue,   &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_BLUE],   sizeof(Cam17x17UShortMatrix_t));
    }
}

void CalibConverterAfec::convert(
    CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
{
    CalibDb_FEC_t* calibv1_fec =
        (CalibDb_FEC_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, afec);
    if (!calibv1_fec)
        return;

    CalibDbV2_FEC_t* calibv2_fec_db =
        (CalibDbV2_FEC_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, afec));
    if (!calibv2_fec_db)
        return;
    CalibDbV2_Fec_Param_t* calibv2_fec = &calibv2_fec_db->param;

    memcpy(calibv2_fec, calibv1_fec, sizeof(*calibv1_fec));
}

void CalibConverterAldch::convert(
    CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
{
    CalibDb_LDCH_t* calibv1_ldch =
        (CalibDb_LDCH_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, aldch);
    if (!calibv1_ldch)
        return;

    CalibDbV2_LDCH_t* calibv2_ldch_db =
        (CalibDbV2_LDCH_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, aldch));
    if (!calibv2_ldch_db)
        return;
    CalibDbV2_Ldch_Param_t* calibv2_ldch = &calibv2_ldch_db->param;

    calibv2_ldch->ldch_en           = calibv1_ldch->ldch_en;
    calibv2_ldch->correct_level     = calibv1_ldch->correct_level;
    calibv2_ldch->correct_level_max = calibv1_ldch->correct_level_max;
    memcpy(calibv2_ldch->meshfile, calibv1_ldch->meshfile, strlen(calibv1_ldch->meshfile));
    memcpy(calibv2_ldch->light_center, calibv1_ldch->light_center, sizeof(double) * 2);
    memcpy(calibv2_ldch->coefficient, calibv1_ldch->coefficient, sizeof(double) * 4);
}

void CalibConverterColorAsGrey::convert(
    CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
{
    CalibDb_ColorAsGrey_t* calibv1_colorAsGrey =
        (CalibDb_ColorAsGrey_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, colorAsGrey);
    if (!calibv1_colorAsGrey)
        return;

    CalibDbV2_ColorAsGrey_t* calibv2_colorAsGrey =
        (CalibDbV2_ColorAsGrey_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, colorAsGrey));
    if (!calibv2_colorAsGrey)
        return;

    memcpy(calibv2_colorAsGrey, calibv1_colorAsGrey, sizeof(*calibv1_colorAsGrey));
}

void CalibConverterLumaDetect::convert(
    CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
{
    CalibDb_LUMA_DETECT_t* calibv1_lumaDetect =
        (CalibDb_LUMA_DETECT_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, lumaDetect);
    if (!calibv1_lumaDetect)
        return;

    CalibDbV2_LUMA_DETECT_t* calibv2_lumaDetect =
        (CalibDbV2_LUMA_DETECT_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, lumaDetect));
    if (!calibv2_lumaDetect)
        return;

    memcpy(calibv2_lumaDetect, calibv1_lumaDetect, sizeof(*calibv1_lumaDetect));
}

void CalibConverterAf::convert(
    CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
{
    convertAfCalibV1ToCalibV2(calibv1, calibv2);
}

void CalibConverterThumbnails::convert(
    CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
{
    CalibDbV2_Thumbnails_t* calibv2_thumbnails_db =
        (CalibDbV2_Thumbnails_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, thumbnails));
    if (!calibv2_thumbnails_db)
        return;

    CalibDbV2_Thumbnails_Param_t* calibv2_thumbnails = &calibv2_thumbnails_db->param;
    calibv2_thumbnails->thumbnail_configs_len = 3;

    calibv2_thumbnails->thumbnail_configs = reinterpret_cast<rkaiq_thumbnails_config_t*>(calloc(
            calibv2_thumbnails->thumbnail_configs_len, sizeof(*calibv2_thumbnails->thumbnail_configs)));
    if (NULL == calibv2_thumbnails->thumbnail_configs) {
        goto failure;
        return;
    }

    for (uint32_t i = 0; i < calibv2_thumbnails->thumbnail_configs_len; i++) {
        auto* config = &calibv2_thumbnails->thumbnail_configs[i];
        config->owner_cookies = i;
        config->stream_type = 0;
        config->format[0] = 'N';
        config->format[1] = 'V';
        config->format[2] = '1';
        config->format[3] = '2';
        config->width_intfactor = 1 << (i + 1);
        config->height_intfactor = 1 << (i + 1);
    }

    return;

failure:
    if (calibv2_thumbnails->thumbnail_configs != NULL) {
        free(calibv2_thumbnails->thumbnail_configs);
    }

}


void CalibConverterBAYERNRV2::convert(CamCalibDbV2Context_t *calibv2,
                                      CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V21()) {
        struct list_head* bayernrV2_list =
            (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_bayernr_v2);
        if (!bayernrV2_list)
            return;

        CalibDbV2_BayerNrV2_t* calibv2_bayernr_v2 =
            (CalibDbV2_BayerNrV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, bayernr_v2));
        if (!calibv2_bayernr_v2)
            return;

        // TODO:
        bayernrV2_calibdb_to_calibdbV2(bayernrV2_list, calibv2_bayernr_v2, 0);
    }

}

void CalibConverterCNRV1::convert(CamCalibDbV2Context_t *calibv2,
                                  CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V21()) {
        struct list_head* calibv1_cnr_list =
            (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_cnr_v1);
        if (!calibv1_cnr_list)
            return;

        CalibDbV2_CNR_t* calibv2_cnr_v1 =
            (CalibDbV2_CNR_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, cnr_v1));
        if (!calibv2_cnr_v1)
            return;

        // TODO:
        cnrV1_calibdb_to_calibdbV2(calibv1_cnr_list, calibv2_cnr_v1, 0);
    }

}

void CalibConverterYNRV2::convert(CamCalibDbV2Context_t *calibv2,
                                  CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V21()) {
        struct list_head* calibv1_ynr_list =
            (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_ynr_v2);
        if (!calibv1_ynr_list)
            return;

        CalibDbV2_YnrV2_t* calibv2_ynr_v2 =
            (CalibDbV2_YnrV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ynr_v2));
        if (!calibv2_ynr_v2)
            return;

        // TODO:
        ynrV2_calibdb_to_calibdbV2(calibv1_ynr_list, calibv2_ynr_v2, 0);
    }

}

void CalibConverterSHARPV3::convert(CamCalibDbV2Context_t *calibv2,
                                    CamCalibDbContext_t *calibv1) {
    if (CHECK_ISP_HW_V21()) {
        struct list_head* calibv1_sharp_list =
            (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_sharp_v3);
        if (!calibv1_sharp_list)
            return;

        CalibDbV2_SharpV3_t* calibv2_sharp_v2 =
            (CalibDbV2_SharpV3_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, sharp_v3));
        if (!calibv2_sharp_v2)
            return;

        // TODO:
        sharpV3_calibdb_to_calibdbV2(calibv1_sharp_list, calibv2_sharp_v2, 0);
    }
}

} // namespace RkCam