1 #include "iqconverter.h"
2
3 #define DEFAULT_MAIN_SCENE "normal"
4 #define DEFAULT_SUB_SCENE "day"
5
6 #if defined(ISP_HW_V20)
7 int g_rkaiq_isp_hw_ver = 20;
8 #elif defined(ISP_HW_V21)
9 int g_rkaiq_isp_hw_ver = 21;
10 #elif defined(ISP_HW_V30)
11 int g_rkaiq_isp_hw_ver = 30;
12 #elif defined(ISP_HW_V32)
13 int g_rkaiq_isp_hw_ver = 32;
14 #elif defined(ISP_HW_V32_LITE)
15 int g_rkaiq_isp_hw_ver = 321;
16 #else
17 #error "WRONG ISP_HW_VERSION, ONLY SUPPORT V20/V21/V30/V32 NOW !"
18 #endif
19
20 namespace RkCam {
21
IQConverter(const char * xml,const char * json)22 IQConverter::IQConverter(const char *xml, const char *json)
23 : ifile(std::string(xml)), ofile(std::string(json)), calibv1(nullptr) {
24 calibv2 = calibdbV2_ctx_new();
25 memset(&calibproj, 0, sizeof(CamCalibDbProj_t));
26 }
27
convert()28 int IQConverter::convert() {
29 calibv1 = RkAiqCalibDb::createCalibDb((char *)ifile.c_str());
30 if (!calibv1) {
31 printf("[XML]load %s failed!\n", ifile.c_str());
32 return -1;
33 } else {
34 printf("[XML] %s load finished!\n", ifile.c_str());
35 }
36 doConvert();
37
38 calibproj.sensor_calib = *calibv2->sensor_info;
39 calibproj.module_calib = *calibv2->module_info;
40 calibproj.sys_static_cfg = *calibv2->sys_cfg;
41 addToScene(&calibproj, DEFAULT_MAIN_SCENE, DEFAULT_SUB_SCENE, calibv2);
42
43 if (0 != RkAiqCalibDbV2::calibproj2json(ofile.c_str(), &calibproj)) {
44 printf("convert %s to %s failed!\n", ifile.c_str(), ofile.c_str());
45 return -1;
46 }
47
48 CalibV2AecFree(calibv2);
49
50 if (CHECK_ISP_HW_V20())
51 CalibV2AwbV20Free(calibv2);
52 if (CHECK_ISP_HW_V21())
53 CalibV2AwbV21Free(calibv2);
54
55 //bayernrV1_calibdbV2_free(calibv2->bayernr_v1);
56 //mfnrV1_calibdbV2_free(calibv2->mfnr_v1);
57 //uvnrV1_calibdbV2_free(calibv2->uvnr_v1);
58 //ynrV1_calibdbV2_free(calibv2->ynr_v1);
59
60 CalibV2CCMFree(calibv2);
61 CalibV2AfFree(calibv2);
62 CalibV2Lut3DFree(calibv2);
63 return 0;
64 }
65
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)66 void CalibConverterAE::convert(CamCalibDbV2Context_t *calibv2,
67 CamCalibDbContext_t *calibv1) {
68
69 CalibDb_Aec_ParaV2_t* calibv2_ae_calib =
70 (CalibDb_Aec_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ae_calib));
71 memset(calibv2_ae_calib, 0, sizeof(CalibDb_Aec_ParaV2_t));
72
73 convertAecCalibV1ToCalibV2(calibv1, calibv2);
74
75 #if 1
76 CalibDb_Sensor_ParaV2_t* calibv2_sensor_calib =
77 (CalibDb_Sensor_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, sensor_calib));
78 convertSensorinfoCalibV1ToCalibV2(calibv1, calibv2_sensor_calib);
79
80 CalibDb_Module_ParaV2_t* calibv2_module_calib =
81 (CalibDb_Module_ParaV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, module_calib));
82 convertModuleinfoCalibV1ToCalibV2(calibv1, calibv2_module_calib);
83 #endif
84 }
85
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)86 void CalibConverterAWB::convert(CamCalibDbV2Context_t *calibv2,
87 CamCalibDbContext_t *calibv1) {
88 if (CHECK_ISP_HW_V20()) {
89 convertCalib2calibV20(calibv1, calibv2);
90 }
91 if (CHECK_ISP_HW_V21()) {
92 convertCalib2calibV21(calibv1, calibv2);
93 }
94 }
95
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)96 void CalibConverterAblc::convert(CamCalibDbV2Context_t *calibv2,
97 CamCalibDbContext_t *calibv1) {
98 CalibDb_Blc_t* calib_v1_blc =
99 (CalibDb_Blc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, blc);
100 if (!calib_v1_blc)
101 return;
102
103 CalibDbV2_Ablc_t* calibv2_ablc_calib =
104 (CalibDbV2_Ablc_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ablc_calib));
105 if (!calibv2_ablc_calib)
106 return;
107 //len
108 calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len = 13;
109 calibv2_ablc_calib->BlcTuningPara.BLC_Data.R_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;
110 calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gr_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;
111 calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gb_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;
112 calibv2_ablc_calib->BlcTuningPara.BLC_Data.B_Channel_len = calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len;
113
114 //malloc
115 calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO = (float *) malloc(sizeof(float) * 13);
116 calibv2_ablc_calib->BlcTuningPara.BLC_Data.R_Channel = (float *) malloc(sizeof(float) * 13);
117 calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gr_Channel = (float *) malloc(sizeof(float) * 13);
118 calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gb_Channel = (float *) malloc(sizeof(float) * 13);
119 calibv2_ablc_calib->BlcTuningPara.BLC_Data.B_Channel = (float *) malloc(sizeof(float) * 13);
120
121 calibv2_ablc_calib->BlcTuningPara.enable = calib_v1_blc->enable ? true : false;
122 for(int i = 0; i < calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO_len; i++) {
123 calibv2_ablc_calib->BlcTuningPara.BLC_Data.ISO[i] = calib_v1_blc->mode_cell[0].iso[i];
124 calibv2_ablc_calib->BlcTuningPara.BLC_Data.R_Channel[i] = calib_v1_blc->mode_cell[0].level[0][i];
125 calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gr_Channel[i] = calib_v1_blc->mode_cell[0].level[1][i];
126 calibv2_ablc_calib->BlcTuningPara.BLC_Data.Gb_Channel[i] = calib_v1_blc->mode_cell[0].level[2][i];
127 calibv2_ablc_calib->BlcTuningPara.BLC_Data.B_Channel[i] = calib_v1_blc->mode_cell[0].level[3][i];
128 }
129 }
130
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)131 void CalibConverterAdpcc::convert(CamCalibDbV2Context_t *calibv2,
132 CamCalibDbContext_t *calibv1) {
133 CalibDb_Dpcc_t* calibv1_dpcc =
134 (CalibDb_Dpcc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, dpcc);
135 if (!calibv1_dpcc)
136 return;
137
138 CalibDbV2_Dpcc_t* calibv2_adpcc_calib =
139 (CalibDbV2_Dpcc_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, adpcc_calib));
140 if (!calibv2_adpcc_calib)
141 return;
142
143 //len
144 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len = 13;
145 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Single_level_len = calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len;
146 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Double_level_len = calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len;
147 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Triple_level_len = calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len;
148 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len = 13;
149 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_single_len = calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len;
150 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_multiple_len = calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len;
151
152 //malloc
153 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO = (float *) malloc(sizeof(float) * 13);
154 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Single_level = (int *) malloc(sizeof(int) * 13);
155 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Double_level = (int *) malloc(sizeof(int) * 13);
156 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Triple_level = (int *) malloc(sizeof(int) * 13);
157 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO = (float *) malloc(sizeof(float) * 13);
158 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_single = (int *) malloc(sizeof(int) * 13);
159 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_multiple = (int *) malloc(sizeof(int) * 13);
160
161 //enable
162 calibv2_adpcc_calib->DpccTuningPara.Enable = calibv1_dpcc->enable ? true : false;
163
164 //fast mode
165 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_mode_en = calibv1_dpcc->fast.fast_mode_double_en ? true : false;
166 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Single_enable = calibv1_dpcc->fast.fast_mode_single_en ? true : false;
167 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Double_enable = calibv1_dpcc->fast.fast_mode_double_en ? true : false;
168 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Triple_enable = calibv1_dpcc->fast.fast_mode_triple_en ? true : false;
169 for(int i = 0; i < calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO_len; i++) {
170 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.ISO[i] = calibv1_dpcc->fast.ISO[i];
171 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Single_level[i] = calibv1_dpcc->fast.fast_mode_single_level[i];
172 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Double_level[i] = calibv1_dpcc->fast.fast_mode_double_level[i];
173 calibv2_adpcc_calib->DpccTuningPara.Fast_Mode.Fast_Data.Triple_level[i] = calibv1_dpcc->fast.fast_mode_triple_level[i];
174 }
175
176 //expert mode
177 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.grayscale_mode = calibv1_dpcc->expert.grayscale_mode ? true : false;
178 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_Enable = calibv1_dpcc->expert.stage1_Enable[0] ? true : false;
179 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.rk_out_sel = calibv1_dpcc->expert.rk_out_sel[0];
180 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.dpcc_out_sel = calibv1_dpcc->expert.dpcc_out_sel[0] ? true : false;
181 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_g_3x3 = calibv1_dpcc->expert.stage1_g_3x3[0] ? true : false;
182 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_rb_3x3 = calibv1_dpcc->expert.stage1_rb_3x3[0] ? true : false;
183 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_inc_g_center = calibv1_dpcc->expert.stage1_inc_g_center[0] ? true : false;
184 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.stage1_inc_rb_center = calibv1_dpcc->expert.stage1_inc_rb_center[0] ? true : false;
185 for(int i = 0; i < CALIBDB_ADPCC_KNOTS_NUM; i++) {
186 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.ISO[i] = calibv1_dpcc->expert.iso[i];
187 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.fix_set[i] = calibv1_dpcc->expert.stage1_use_fix_set[i];
188 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.set1[i] = calibv1_dpcc->expert.stage1_use_set1[i];
189 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.set2[i] = calibv1_dpcc->expert.stage1_use_set2[i];
190 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.SetEnable.set3[i] = calibv1_dpcc->expert.stage1_use_set3[i];
191 }
192 for(int j = 0; j < CALIBDB_ADPCC_KNOTS_NUM; j++) {
193 //set1
194 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.RK_enable[j] = calibv1_dpcc->expert.set[0].rk.g_enable[j];
195 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.rb_sw_mindis[j] = calibv1_dpcc->expert.set[0].rk.rb_sw_mindis[j];
196 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.g_sw_mindis[j] = calibv1_dpcc->expert.set[0].rk.g_sw_mindis[j];
197 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.sw_dis_scale_min[j] = calibv1_dpcc->expert.set[0].rk.sw_dis_scale_min[j];
198 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RK.sw_dis_scale_max[j] = calibv1_dpcc->expert.set[0].rk.sw_dis_scale_max[j];
199
200 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.LC_enable[j] = calibv1_dpcc->expert.set[0].lc.g_enable[j];
201 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.g_line_thr[j] = calibv1_dpcc->expert.set[0].lc.g_line_thr[j];
202 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.rb_line_thr[j] = calibv1_dpcc->expert.set[0].lc.rb_line_thr[j];
203 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.g_line_mad_fac[j] = calibv1_dpcc->expert.set[0].lc.g_line_mad_fac[j];
204 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.LC.rb_line_mad_fac[j] = calibv1_dpcc->expert.set[0].lc.rb_line_mad_fac[j];
205
206 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.PG.PG_enable[j] = calibv1_dpcc->expert.set[0].pg.g_enable[j];
207 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.PG.g_pg_fac[j] = calibv1_dpcc->expert.set[0].pg.g_pg_fac[j];
208 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.PG.rb_pg_fac[j] = calibv1_dpcc->expert.set[0].pg.rb_pg_fac[j];
209
210 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.RND_enable[j] = calibv1_dpcc->expert.set[0].rnd.g_enable[j];
211 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.g_rnd_thr[j] = calibv1_dpcc->expert.set[0].rnd.g_rnd_thr[j];
212 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.rb_rnd_thr[j] = calibv1_dpcc->expert.set[0].rnd.rb_rnd_thr[j];
213 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.g_rnd_offs[j] = calibv1_dpcc->expert.set[0].rnd.g_rnd_offs[j];
214 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RND.rb_rnd_offs[j] = calibv1_dpcc->expert.set[0].rnd.rb_rnd_offs[j];
215
216 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RG.RG_enable[j] = calibv1_dpcc->expert.set[0].rg.g_enable[j];
217 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RG.g_rg_fac[j] = calibv1_dpcc->expert.set[0].rg.g_rg_fac[j];
218 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RG.rb_rg_fac[j] = calibv1_dpcc->expert.set[0].rg.rb_rg_fac[j];
219
220 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RO.RO_enable[j] = calibv1_dpcc->expert.set[0].ro.g_enable[j];
221 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RO.rb_ro_lim[j] = calibv1_dpcc->expert.set[0].ro.rb_ro_lim[j];
222 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set1.RO.g_ro_lim[j] = calibv1_dpcc->expert.set[0].ro.g_ro_lim[j];
223 //set2
224 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.RK_enable[j] = calibv1_dpcc->expert.set[1].rk.g_enable[j];
225 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.rb_sw_mindis[j] = calibv1_dpcc->expert.set[1].rk.rb_sw_mindis[j];
226 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.g_sw_mindis[j] = calibv1_dpcc->expert.set[1].rk.g_sw_mindis[j];
227 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.sw_dis_scale_min[j] = calibv1_dpcc->expert.set[1].rk.sw_dis_scale_min[j];
228 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RK.sw_dis_scale_max[j] = calibv1_dpcc->expert.set[1].rk.sw_dis_scale_max[j];
229
230 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.LC_enable[j] = calibv1_dpcc->expert.set[1].lc.g_enable[j];
231 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.g_line_thr[j] = calibv1_dpcc->expert.set[1].lc.g_line_thr[j];
232 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.rb_line_thr[j] = calibv1_dpcc->expert.set[1].lc.rb_line_thr[j];
233 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.g_line_mad_fac[j] = calibv1_dpcc->expert.set[1].lc.g_line_mad_fac[j];
234 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.LC.rb_line_mad_fac[j] = calibv1_dpcc->expert.set[1].lc.rb_line_mad_fac[j];
235
236 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.PG.PG_enable[j] = calibv1_dpcc->expert.set[1].pg.g_enable[j];
237 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.PG.g_pg_fac[j] = calibv1_dpcc->expert.set[1].pg.g_pg_fac[j];
238 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.PG.rb_pg_fac[j] = calibv1_dpcc->expert.set[1].pg.rb_pg_fac[j];
239
240 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.RND_enable[j] = calibv1_dpcc->expert.set[1].rnd.g_enable[j];
241 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.g_rnd_thr[j] = calibv1_dpcc->expert.set[1].rnd.g_rnd_thr[j];
242 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.rb_rnd_thr[j] = calibv1_dpcc->expert.set[1].rnd.rb_rnd_thr[j];
243 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.g_rnd_offs[j] = calibv1_dpcc->expert.set[1].rnd.g_rnd_offs[j];
244 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RND.rb_rnd_offs[j] = calibv1_dpcc->expert.set[1].rnd.rb_rnd_offs[j];
245
246 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RG.RG_enable[j] = calibv1_dpcc->expert.set[1].rg.g_enable[j];
247 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RG.g_rg_fac[j] = calibv1_dpcc->expert.set[1].rg.g_rg_fac[j];
248 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RG.rb_rg_fac[j] = calibv1_dpcc->expert.set[1].rg.rb_rg_fac[j];
249
250 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RO.RO_enable[j] = calibv1_dpcc->expert.set[1].ro.g_enable[j];
251 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RO.rb_ro_lim[j] = calibv1_dpcc->expert.set[1].ro.rb_ro_lim[j];
252 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set2.RO.g_ro_lim[j] = calibv1_dpcc->expert.set[1].ro.g_ro_lim[j];
253 //set3
254 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.RK_enable[j] = calibv1_dpcc->expert.set[2].rk.g_enable[j];
255 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.rb_sw_mindis[j] = calibv1_dpcc->expert.set[2].rk.rb_sw_mindis[j];
256 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.g_sw_mindis[j] = calibv1_dpcc->expert.set[2].rk.g_sw_mindis[j];
257 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.sw_dis_scale_min[j] = calibv1_dpcc->expert.set[2].rk.sw_dis_scale_min[j];
258 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RK.sw_dis_scale_max[j] = calibv1_dpcc->expert.set[2].rk.sw_dis_scale_max[j];
259
260 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.LC_enable[j] = calibv1_dpcc->expert.set[2].lc.g_enable[j];
261 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.g_line_thr[j] = calibv1_dpcc->expert.set[2].lc.g_line_thr[j];
262 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.rb_line_thr[j] = calibv1_dpcc->expert.set[2].lc.rb_line_thr[j];
263 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.g_line_mad_fac[j] = calibv1_dpcc->expert.set[2].lc.g_line_mad_fac[j];
264 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.LC.rb_line_mad_fac[j] = calibv1_dpcc->expert.set[2].lc.rb_line_mad_fac[j];
265
266 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.PG.PG_enable[j] = calibv1_dpcc->expert.set[2].pg.g_enable[j];
267 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.PG.g_pg_fac[j] = calibv1_dpcc->expert.set[2].pg.g_pg_fac[j];
268 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.PG.rb_pg_fac[j] = calibv1_dpcc->expert.set[2].pg.rb_pg_fac[j];
269
270 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.RND_enable[j] = calibv1_dpcc->expert.set[2].rnd.g_enable[j];
271 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.g_rnd_thr[j] = calibv1_dpcc->expert.set[2].rnd.g_rnd_thr[j];
272 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.rb_rnd_thr[j] = calibv1_dpcc->expert.set[2].rnd.rb_rnd_thr[j];
273 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.g_rnd_offs[j] = calibv1_dpcc->expert.set[2].rnd.g_rnd_offs[j];
274 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RND.rb_rnd_offs[j] = calibv1_dpcc->expert.set[2].rnd.rb_rnd_offs[j];
275
276 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RG.RG_enable[j] = calibv1_dpcc->expert.set[2].rg.g_enable[j];
277 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RG.g_rg_fac[j] = calibv1_dpcc->expert.set[2].rg.g_rg_fac[j];
278 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RG.rb_rg_fac[j] = calibv1_dpcc->expert.set[2].rg.rb_rg_fac[j];
279
280 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RO.RO_enable[j] = calibv1_dpcc->expert.set[2].ro.g_enable[j];
281 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RO.rb_ro_lim[j] = calibv1_dpcc->expert.set[2].ro.rb_ro_lim[j];
282 calibv2_adpcc_calib->DpccTuningPara.Expert_Mode.set3.RO.g_ro_lim[j] = calibv1_dpcc->expert.set[2].ro.g_ro_lim[j];
283 }
284
285 //pdaf
286 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.en = calibv1_dpcc->pdaf.en ? true : false;
287 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.offsetx = calibv1_dpcc->pdaf.offsetx;
288 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.offsety = calibv1_dpcc->pdaf.offsety;
289 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapx = calibv1_dpcc->pdaf.wrapx;
290 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapy = calibv1_dpcc->pdaf.wrapy;
291 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapx_num = calibv1_dpcc->pdaf.wrapx_num;
292 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.wrapy_num = calibv1_dpcc->pdaf.wrapy_num;
293 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.forward_med = calibv1_dpcc->pdaf.forward_med;
294 for(int i = 0; i < 16; i++) {
295 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.point_en[i] = calibv1_dpcc->pdaf.point_en[i];
296 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.point_x[i] = calibv1_dpcc->pdaf.point_x[i];
297 calibv2_adpcc_calib->DpccTuningPara.Dpcc_pdaf.point_y[i] = calibv1_dpcc->pdaf.point_y[i];
298 }
299
300 //sensor dpcc
301 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.sensor_dpcc_auto_en = calibv1_dpcc->sensor_dpcc.en ? true : false;
302 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.max_level = (int)(calibv1_dpcc->sensor_dpcc.max_level);
303 for(int i = 0; i < calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO_len; i++) {
304 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.ISO[i] = (int)(calibv1_dpcc->sensor_dpcc.iso[i]);
305 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_single[i] = (int)(calibv1_dpcc->sensor_dpcc.level_single[i]);
306 calibv2_adpcc_calib->DpccTuningPara.Sensor_dpcc.SensorDpcc_Data.level_multiple[i] = (int)(calibv1_dpcc->sensor_dpcc.level_multiple[i]);
307 }
308 }
309
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)310 void CalibConverterAdegamma::convert(CamCalibDbV2Context_t *calibv2,
311 CamCalibDbContext_t *calibv1) {
312 CalibDb_Degamma_t* calib_v1_degamma =
313 (CalibDb_Degamma_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, degamma);
314 if (!calib_v1_degamma)
315 return;
316
317 CalibDbV2_Adegmma_t* calibv2_adegamma_calib =
318 (CalibDbV2_Adegmma_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, adegamma_calib));
319 if (!calibv2_adegamma_calib)
320 return;
321
322 calibv2_adegamma_calib->DegammaTuningPara.degamma_en = calib_v1_degamma->degamma_en ? true : false;
323 for(int i = 0; i < ADEGAMMA_CRUVE_KNOTS; i++) {
324 calibv2_adegamma_calib->DegammaTuningPara.X_axis[i] = (int)(calib_v1_degamma->mode[0].X_axis[i] + 0.5);
325 calibv2_adegamma_calib->DegammaTuningPara.curve_R[i] = (int)(calib_v1_degamma->mode[0].curve_R[i] + 0.5);
326 calibv2_adegamma_calib->DegammaTuningPara.curve_G[i] = (int)(calib_v1_degamma->mode[0].curve_G[i] + 0.5);
327 calibv2_adegamma_calib->DegammaTuningPara.curve_B[i] = (int)(calib_v1_degamma->mode[0].curve_B[i] + 0.5);
328 }
329 }
330
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)331 void CalibConverterAgic::convert(CamCalibDbV2Context_t *calibv2,
332 CamCalibDbContext_t *calibv1) {
333 //len
334 CalibDbV2_Gic_V20_t* calibv2_agic_calib_V20 =
335 (CalibDbV2_Gic_V20_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, agic_calib_v20));
336 if (calibv2_agic_calib_V20) {
337 calibv2_agic_calib_V20->GicTuningPara.GicData.ISO_len = 9;
338 calibv2_agic_calib_V20->GicTuningPara.GicData.min_busy_thre_len = 9;
339 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr1_len = 9;
340 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr2_len = 9;
341 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_len = 9;
342 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_len = 9;
343 calibv2_agic_calib_V20->GicTuningPara.GicData.gb_thre_len = 9;
344 calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorV_len = 9;
345 calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorVboth_len = 9;
346 calibv2_agic_calib_V20->GicTuningPara.GicData.dark_thre_len = 9;
347 calibv2_agic_calib_V20->GicTuningPara.GicData.dark_threHi_len = 9;
348 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_dark_len = 9;
349 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_dark_len = 9;
350 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark1_len = 9;
351 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark2_len = 9;
352 calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_0_len = 9;
353 calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_1_len = 9;
354 calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitLo_len = 9;
355 calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitHi_len = 9;
356 calibv2_agic_calib_V20->GicTuningPara.GicData.textureStrength_len = 9;
357 calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleHi_len = 9;
358 calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleLo_len = 9;
359 calibv2_agic_calib_V20->GicTuningPara.GicData.globalStrength_len = 9;
360 calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coea_len = 9;
361 calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coeb_len = 9;
362 calibv2_agic_calib_V20->GicTuningPara.GicData.diff_clip_len = 9;
363 }
364
365 CalibDbV2_Gic_V21_t* calibv2_agic_calib_V21 =
366 (CalibDbV2_Gic_V21_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, agic_calib_v21));
367 if (calibv2_agic_calib_V21) {
368 calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len = 9;
369 calibv2_agic_calib_V21->GicTuningPara.GicData.min_busy_thre_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
370 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
371 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr2_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
372 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
373 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
374 calibv2_agic_calib_V21->GicTuningPara.GicData.gb_thre_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
375 calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorV_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
376 calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorVboth_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
377 calibv2_agic_calib_V21->GicTuningPara.GicData.dark_thre_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
378 calibv2_agic_calib_V21->GicTuningPara.GicData.dark_threHi_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
379 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_dark_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
380 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_dark_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
381 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
382 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark2_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
383 calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_0_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
384 calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_1_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
385 calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseScale_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
386 calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseBase_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
387 calibv2_agic_calib_V21->GicTuningPara.GicData.globalStrength_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
388 calibv2_agic_calib_V21->GicTuningPara.GicData.diff_clip_len = calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len;
389 }
390
391 //malloc
392 if (calibv2_agic_calib_V20) {
393 calibv2_agic_calib_V20->GicTuningPara.GicData.ISO = (float *) malloc(sizeof(float) * 9);
394 calibv2_agic_calib_V20->GicTuningPara.GicData.min_busy_thre = (float *) malloc(sizeof(float) * 9);
395 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr1 = (float *) malloc(sizeof(float) * 9);
396 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr2 = (float *) malloc(sizeof(float) * 9);
397 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1 = (float *) malloc(sizeof(float) * 9);
398 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2 = (float *) malloc(sizeof(float) * 9);
399 calibv2_agic_calib_V20->GicTuningPara.GicData.gb_thre = (float *) malloc(sizeof(float) * 9);
400 calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorV = (float *) malloc(sizeof(float) * 9);
401 calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorVboth = (float *) malloc(sizeof(float) * 9);
402 calibv2_agic_calib_V20->GicTuningPara.GicData.dark_thre = (float *) malloc(sizeof(float) * 9);
403 calibv2_agic_calib_V20->GicTuningPara.GicData.dark_threHi = (float *) malloc(sizeof(float) * 9);
404 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_dark = (float *) malloc(sizeof(float) * 9);
405 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_dark = (float *) malloc(sizeof(float) * 9);
406 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark1 = (float *) malloc(sizeof(float) * 9);
407 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark2 = (float *) malloc(sizeof(float) * 9);
408 calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_0 = (float *) malloc(sizeof(float) * 9);
409 calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_1 = (float *) malloc(sizeof(float) * 9);
410 calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitLo = (float *) malloc(sizeof(float) * 9);
411 calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitHi = (float *) malloc(sizeof(float) * 9);
412 calibv2_agic_calib_V20->GicTuningPara.GicData.textureStrength = (float *) malloc(sizeof(float) * 9);
413 calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleHi = (float *) malloc(sizeof(float) * 9);
414 calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleLo = (float *) malloc(sizeof(float) * 9);
415 calibv2_agic_calib_V20->GicTuningPara.GicData.globalStrength = (float *) malloc(sizeof(float) * 9);
416 calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coea = (float *) malloc(sizeof(float) * 9);
417 calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coeb = (float *) malloc(sizeof(float) * 9);
418 calibv2_agic_calib_V20->GicTuningPara.GicData.diff_clip = (float *) malloc(sizeof(float) * 9);
419 }
420
421 if (calibv2_agic_calib_V21) {
422 calibv2_agic_calib_V21->GicTuningPara.GicData.ISO = (float *) malloc(sizeof(float) * 9);
423 calibv2_agic_calib_V21->GicTuningPara.GicData.min_busy_thre = (float *) malloc(sizeof(float) * 9);
424 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr1 = (float *) malloc(sizeof(float) * 9);
425 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr2 = (float *) malloc(sizeof(float) * 9);
426 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1 = (float *) malloc(sizeof(float) * 9);
427 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2 = (float *) malloc(sizeof(float) * 9);
428 calibv2_agic_calib_V21->GicTuningPara.GicData.gb_thre = (float *) malloc(sizeof(float) * 9);
429 calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorV = (float *) malloc(sizeof(float) * 9);
430 calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorVboth = (float *) malloc(sizeof(float) * 9);
431 calibv2_agic_calib_V21->GicTuningPara.GicData.dark_thre = (float *) malloc(sizeof(float) * 9);
432 calibv2_agic_calib_V21->GicTuningPara.GicData.dark_threHi = (float *) malloc(sizeof(float) * 9);
433 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_dark = (float *) malloc(sizeof(float) * 9);
434 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_dark = (float *) malloc(sizeof(float) * 9);
435 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark1 = (float *) malloc(sizeof(float) * 9);
436 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark2 = (float *) malloc(sizeof(float) * 9);
437 calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_0 = (float *) malloc(sizeof(float) * 9);
438 calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_1 = (float *) malloc(sizeof(float) * 9);
439 calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseScale = (float *) malloc(sizeof(float) * 9);
440 calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseBase = (float *) malloc(sizeof(float) * 9);
441 calibv2_agic_calib_V21->GicTuningPara.GicData.globalStrength = (float *) malloc(sizeof(float) * 9);
442 calibv2_agic_calib_V21->GicTuningPara.GicData.diff_clip = (float *) malloc(sizeof(float) * 9);
443 }
444 //v20
445 if (CHECK_ISP_HW_V20()) {
446 CalibDb_Gic_t* calibv1_gic =
447 (CalibDb_Gic_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, gic);
448 calibv2_agic_calib_V20->GicTuningPara.enable = calibv1_gic->calib_v20[0].gic_en ? true : false;
449 calibv2_agic_calib_V20->GicTuningPara.edge_en = calibv1_gic->calib_v20[0].edge_en ? true : false;
450 calibv2_agic_calib_V20->GicTuningPara.noise_cut_en = calibv1_gic->calib_v20[0].noise_cut_en ? true : false;
451 calibv2_agic_calib_V20->GicTuningPara.gr_ration = calibv1_gic->calib_v20[0].gr_ration;
452 for(int i = 0; i < calibv2_agic_calib_V20->GicTuningPara.GicData.ISO_len; i++) {
453 calibv2_agic_calib_V20->GicTuningPara.GicData.ISO[i] = calibv1_gic->calib_v20[0].setting.iso[i];
454 calibv2_agic_calib_V20->GicTuningPara.GicData.min_busy_thre[i] = calibv1_gic->calib_v20[0].setting.min_busy_thre[i];
455 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr1[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr1[i];
456 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr2[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr2[i];
457 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1[i] = calibv1_gic->calib_v20[0].setting.k_grad1[i];
458 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2[i] = calibv1_gic->calib_v20[0].setting.k_grad2[i];
459 calibv2_agic_calib_V20->GicTuningPara.GicData.gb_thre[i] = calibv1_gic->calib_v20[0].setting.gb_thre[i];
460 calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorV[i] = calibv1_gic->calib_v20[0].setting.maxCorV[i];
461 calibv2_agic_calib_V20->GicTuningPara.GicData.maxCorVboth[i] = calibv1_gic->calib_v20[0].setting.maxCorVboth[i];
462 calibv2_agic_calib_V20->GicTuningPara.GicData.dark_thre[i] = calibv1_gic->calib_v20[0].setting.dark_thre[i];
463 calibv2_agic_calib_V20->GicTuningPara.GicData.dark_threHi[i] = calibv1_gic->calib_v20[0].setting.dark_threHi[i];
464 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad1_dark[i] = calibv1_gic->calib_v20[0].setting.k_grad1_dark[i];
465 calibv2_agic_calib_V20->GicTuningPara.GicData.k_grad2_dark[i] = calibv1_gic->calib_v20[0].setting.k_grad2_dark[i];
466 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark1[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr_dark1[i];
467 calibv2_agic_calib_V20->GicTuningPara.GicData.min_grad_thr_dark2[i] = calibv1_gic->calib_v20[0].setting.min_grad_thr_dark2[i];
468 calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_0[i] = calibv1_gic->calib_v20[0].setting.noiseCurve_0[i];
469 calibv2_agic_calib_V20->GicTuningPara.GicData.noiseCurve_1[i] = calibv1_gic->calib_v20[0].setting.noiseCurve_1[i];
470 calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitLo[i] = calibv1_gic->calib_v20[0].setting.GValueLimitLo[i];
471 calibv2_agic_calib_V20->GicTuningPara.GicData.GValueLimitHi[i] = calibv1_gic->calib_v20[0].setting.GValueLimitHi[i];
472 calibv2_agic_calib_V20->GicTuningPara.GicData.textureStrength[i] = calibv1_gic->calib_v20[0].setting.textureStrength[i];
473 calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleLo[i] = calibv1_gic->calib_v20[0].setting.ScaleLo[i];
474 calibv2_agic_calib_V20->GicTuningPara.GicData.ScaleHi[i] = calibv1_gic->calib_v20[0].setting.ScaleHi[i];
475 calibv2_agic_calib_V20->GicTuningPara.GicData.globalStrength[i] = calibv1_gic->calib_v20[0].setting.globalStrength[i];
476 calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coea[i] = calibv1_gic->calib_v20[0].setting.noise_coea[i];
477 calibv2_agic_calib_V20->GicTuningPara.GicData.noise_coeb[i] = calibv1_gic->calib_v20[0].setting.noise_coeb[i];
478 calibv2_agic_calib_V20->GicTuningPara.GicData.diff_clip[i] = calibv1_gic->calib_v20[0].setting.diff_clip[i];
479 }
480 }
481
482 //v21
483 if (CHECK_ISP_HW_V21()) {
484 CalibDb_Gic_Isp21_t* calibv1_gic_isp21 =
485 (CalibDb_Gic_Isp21_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, gic);
486 calibv2_agic_calib_V21->GicTuningPara.enable = calibv1_gic_isp21->calib_v21[0].gic_en ? true : false;
487 calibv2_agic_calib_V21->GicTuningPara.gr_ration = calibv1_gic_isp21->calib_v21[0].gr_ration;
488 for(int i = 0; i < calibv2_agic_calib_V21->GicTuningPara.GicData.ISO_len; i++) {
489 calibv2_agic_calib_V21->GicTuningPara.GicData.ISO[i] = calibv1_gic_isp21->calib_v21[0].setting.iso[i];
490 calibv2_agic_calib_V21->GicTuningPara.GicData.min_busy_thre[i] = calibv1_gic_isp21->calib_v21[0].setting.min_busy_thre[i];
491 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr1[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr1[i];
492 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr2[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr2[i];
493 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad1[i];
494 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad2[i];
495 calibv2_agic_calib_V21->GicTuningPara.GicData.gb_thre[i] = calibv1_gic_isp21->calib_v21[0].setting.gb_thre[i];
496 calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorV[i] = calibv1_gic_isp21->calib_v21[0].setting.maxCorV[i];
497 calibv2_agic_calib_V21->GicTuningPara.GicData.maxCorVboth[i] = calibv1_gic_isp21->calib_v21[0].setting.maxCorVboth[i];
498 calibv2_agic_calib_V21->GicTuningPara.GicData.dark_thre[i] = calibv1_gic_isp21->calib_v21[0].setting.dark_thre[i];
499 calibv2_agic_calib_V21->GicTuningPara.GicData.dark_threHi[i] = calibv1_gic_isp21->calib_v21[0].setting.dark_threHi[i];
500 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad1_dark[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad1_dark[i];
501 calibv2_agic_calib_V21->GicTuningPara.GicData.k_grad2_dark[i] = calibv1_gic_isp21->calib_v21[0].setting.k_grad2_dark[i];
502 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark1[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr_dark1[i];
503 calibv2_agic_calib_V21->GicTuningPara.GicData.min_grad_thr_dark2[i] = calibv1_gic_isp21->calib_v21[0].setting.min_grad_thr_dark2[i];
504 calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_0[i] = calibv1_gic_isp21->calib_v21[0].setting.noiseCurve_0[i];
505 calibv2_agic_calib_V21->GicTuningPara.GicData.noiseCurve_1[i] = calibv1_gic_isp21->calib_v21[0].setting.noiseCurve_1[i];
506 calibv2_agic_calib_V21->GicTuningPara.GicData.globalStrength[i] = calibv1_gic_isp21->calib_v21[0].setting.globalStrength[i];
507 calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseBase[i] = calibv1_gic_isp21->calib_v21[0].setting.NoiseBase[i];
508 calibv2_agic_calib_V21->GicTuningPara.GicData.NoiseScale[i] = calibv1_gic_isp21->calib_v21[0].setting.NoiseScale[i];
509 calibv2_agic_calib_V21->GicTuningPara.GicData.diff_clip[i] = calibv1_gic_isp21->calib_v21[0].setting.diff_clip[i];
510 }
511 }
512 }
513
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)514 void CalibConverterAdehaze::convert(CamCalibDbV2Context_t *calibv2,
515 CamCalibDbContext_t *calibv1) {
516 convertDehazeCalib2CalibV2(calibv1, calibv2);
517 }
518
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)519 void CalibConverterAmerge::convert(CamCalibDbV2Context_t *calibv2,
520 CamCalibDbContext_t *calibv1) {
521 CalibDb_Amerge_Para_t* calibv1_amerge =
522 (CalibDb_Amerge_Para_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, amerge);
523 if (!calibv1_amerge)
524 return;
525
526 CalibDbV2_merge_v10_t* calibv2_amerge_calib =
527 (CalibDbV2_merge_v10_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, amerge_calib));
528 if (!calibv2_amerge_calib)
529 return;
530
531 for(int i = 0; i < 13; i++) {
532 calibv2_amerge_calib->MergeTuningPara.OECurve.EnvLv[i] = calibv1_amerge->envLevel[i];
533 calibv2_amerge_calib->MergeTuningPara.OECurve.Smooth[i] = calibv1_amerge->oeCurve_smooth[i];
534 calibv2_amerge_calib->MergeTuningPara.OECurve.Offset[i] = calibv1_amerge->oeCurve_offset[i];
535 calibv2_amerge_calib->MergeTuningPara.MDCurve.MoveCoef[i] = calibv1_amerge->moveCoef[i];
536 calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_smooth[i] = calibv1_amerge->mdCurveLm_smooth[i];
537 calibv2_amerge_calib->MergeTuningPara.MDCurve.LM_offset[i] = calibv1_amerge->mdCurveLm_offset[i];
538 calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_smooth[i] = calibv1_amerge->mdCurveMs_smooth[i];
539 calibv2_amerge_calib->MergeTuningPara.MDCurve.MS_offset[i] = calibv1_amerge->mdCurveMs_offset[i];
540 }
541 calibv2_amerge_calib->MergeTuningPara.ByPassThr = 0;
542 calibv2_amerge_calib->MergeTuningPara.OECurve_damp = calibv1_amerge->oeCurve_damp;
543 calibv2_amerge_calib->MergeTuningPara.MDCurveLM_damp = calibv1_amerge->mdCurveLm_damp;
544 calibv2_amerge_calib->MergeTuningPara.MDCurveMS_damp = calibv1_amerge->mdCurveMs_damp;
545 }
546
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)547 void CalibConverterAtmo::convert(CamCalibDbV2Context_t *calibv2,
548 CamCalibDbContext_t *calibv1) {
549 CalibDb_Atmo_Para_t* calibv1_atmo =
550 (CalibDb_Atmo_Para_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, atmo);
551 if (!calibv1_atmo )
552 return;
553
554 CalibDbV2_tmo_t* calibv2_atmo_calib =
555 (CalibDbV2_tmo_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, atmo_calib));
556 if (!calibv2_atmo_calib)
557 return;
558
559 //len
560 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len = 13;
561 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
562 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
563 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
564 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
565 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
566 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
567 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
568 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
569 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
570 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
571 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
572 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
573 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
574 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
575 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength_len = calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv_len;
576
577 //malloc
578 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv = (float *) malloc(sizeof(float) * 13);
579 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO = (float *) malloc(sizeof(float) * 13);
580 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength = (float *) malloc(sizeof(float) * 13);
581 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf = (float *) malloc(sizeof(float) * 13);
582 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv = (float *) malloc(sizeof(float) * 13);
583 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength = (float *) malloc(sizeof(float) * 13);
584 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma = (float *) malloc(sizeof(float) * 13);
585 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf = (float *) malloc(sizeof(float) * 13);
586 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO = (float *) malloc(sizeof(float) * 13);
587 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength = (float *) malloc(sizeof(float) * 13);
588 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange = (float *) malloc(sizeof(float) * 13);
589 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv = (float *) malloc(sizeof(float) * 13);
590 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength = (float *) malloc(sizeof(float) * 13);
591 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange = (float *) malloc(sizeof(float) * 13);
592 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv = (float *) malloc(sizeof(float) * 13);
593 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength = (float *) malloc(sizeof(float) * 13);
594
595
596 calibv2_atmo_calib->TmoTuningPara.Enable = calibv1_atmo->en[0].en;
597 //global luma
598 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.Mode = calibv1_atmo->luma[0].GlobalLumaMode ? GLOBALLUMAMODE_ISO : GLOBALLUMAMODE_ENVLV;
599 for(int i = 0; i < 13; i++) {
600 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.EnvLv[i] = calibv1_atmo->luma[0].envLevel[i];
601 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.ISO[i] = calibv1_atmo->luma[0].ISO[i];
602 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.GlobalLumaData.Strength[i] = calibv1_atmo->luma[0].globalLuma[i];
603 }
604 calibv2_atmo_calib->TmoTuningPara.GlobalLuma.Tolerance = calibv1_atmo->luma[0].Tolerance;
605 //details high light
606 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.Mode = calibv1_atmo->HighLight[0].DetailsHighLightMode ? DETAILSHIGHLIGHTMODE_ENVLV : DETAILSHIGHLIGHTMODE_OEPDF;
607 for(int i = 0; i < 13; i++) {
608
609 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.OEPdf[i] = calibv1_atmo->HighLight[0].OEPdf[i];
610 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.EnvLv[i] = calibv1_atmo->HighLight[0].EnvLv[i];
611 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.HighLightData.Strength[i] = calibv1_atmo->HighLight[0].detailsHighLight[i];
612 }
613 calibv2_atmo_calib->TmoTuningPara.DetailsHighLight.Tolerance = calibv1_atmo->HighLight[0].Tolerance;
614 //details low light
615 if(calibv1_atmo->LowLight[0].DetailsLowLightMode == 0)
616 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Mode = DETAILSLOWLIGHTMODE_FOCUSLUMA;
617 else if(calibv1_atmo->LowLight[0].DetailsLowLightMode > 0 && calibv1_atmo->LowLight[0].DetailsLowLightMode < 2)
618 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Mode = DETAILSLOWLIGHTMODE_DARKPDF;
619 else if(calibv1_atmo->LowLight[0].DetailsLowLightMode >= 2)
620 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Mode = DETAILSLOWLIGHTMODE_ISO;
621 for(int i = 0; i < 13; i++) {
622
623 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.FocusLuma[i] = calibv1_atmo->LowLight[0].FocusLuma[i];
624 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.DarkPdf[i] = calibv1_atmo->LowLight[0].DarkPdf[i];
625 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.ISO[i] = calibv1_atmo->LowLight[0].ISO[i];
626 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.LowLightData.Strength[i] = calibv1_atmo->LowLight[0].detailsLowLight[i];
627 }
628 calibv2_atmo_calib->TmoTuningPara.DetailsLowLight.Tolerance = calibv1_atmo->LowLight[0].Tolerance;
629 //global tmo
630 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.Enable = calibv1_atmo->GlobaTMO[0].en ? true : false;
631 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.IIR = calibv1_atmo->GlobaTMO[0].iir;
632 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.Mode = calibv1_atmo->GlobaTMO[0].mode ? TMOTYPEMODE_ENVLV : TMOTYPEMODE_DYNAMICRANGE;
633 for(int i = 0; i < 13; i++) {
634
635 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.DynamicRange[i] = calibv1_atmo->GlobaTMO[0].DynamicRange[i];
636 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.EnvLv[i] = calibv1_atmo->GlobaTMO[0].EnvLv[i];
637 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.GlobalTmoData.Strength[i] = calibv1_atmo->GlobaTMO[0].Strength[i];
638 }
639 calibv2_atmo_calib->TmoTuningPara.GlobaTMO.Tolerance = calibv1_atmo->GlobaTMO[0].Tolerance;
640 //local tmo
641 calibv2_atmo_calib->TmoTuningPara.LocalTMO.Mode = calibv1_atmo->LocalTMO[0].LocalTMOMode ? TMOTYPEMODE_ENVLV : TMOTYPEMODE_DYNAMICRANGE;
642 for(int i = 0; i < 13; i++) {
643
644 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.DynamicRange[i] = calibv1_atmo->LocalTMO[0].DynamicRange[i];
645 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.EnvLv[i] = calibv1_atmo->LocalTMO[0].EnvLv[i];
646 calibv2_atmo_calib->TmoTuningPara.LocalTMO.LocalTmoData.Strength[i] = calibv1_atmo->LocalTMO[0].Strength[i];
647 }
648 calibv2_atmo_calib->TmoTuningPara.LocalTMO.Tolerance = calibv1_atmo->LocalTMO[0].Tolerance;
649 calibv2_atmo_calib->TmoTuningPara.damp = calibv1_atmo->damp;
650 }
651
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)652 void CalibConverterCpsl::convert(CamCalibDbV2Context_t* calibv2,
653 CamCalibDbContext_t* calibv1) {
654 CalibDb_Cpsl_t* calibv1_cpsl =
655 (CalibDb_Cpsl_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, cpsl);
656 if (!calibv1_cpsl)
657 return;
658
659 CalibDbV2_Cpsl_t* calibv2_cpsl_db =
660 (CalibDbV2_Cpsl_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, cpsl));
661 if (!calibv2_cpsl_db)
662 return;
663 CalibDbV2_Cpsl_Param_t* calibv2_cpsl_calib = &calibv2_cpsl_db->param;
664
665 calibv2_cpsl_calib->enable = !!calibv1_cpsl->support_en;
666 if (calibv1_cpsl->mode == 0) {
667 calibv2_cpsl_calib->mode = RK_AIQ_OP_MODE_AUTO;
668 } else if (calibv1_cpsl->mode == 1) {
669 calibv2_cpsl_calib->mode = RK_AIQ_OP_MODE_MANUAL;
670 } else {
671 calibv2_cpsl_calib->mode = RK_AIQ_OP_MODE_INVALID;
672 }
673
674 calibv2_cpsl_calib->force_gray = !!calibv1_cpsl->gray;
675 if (calibv1_cpsl->lght_src == 0) {
676 calibv2_cpsl_calib->light_src = LED;
677 } else if (calibv1_cpsl->lght_src == 1) {
678 calibv2_cpsl_calib->light_src = IR;
679 } else if (calibv1_cpsl->lght_src == 2) {
680 calibv2_cpsl_calib->light_src = MIX;
681 } else {
682 calibv2_cpsl_calib->light_src = INVALID;
683 }
684 calibv2_cpsl_calib->auto_adjust_sens = calibv1_cpsl->ajust_sens;
685 calibv2_cpsl_calib->auto_on2off_th = calibv1_cpsl->on2off_th;
686 calibv2_cpsl_calib->auto_off2on_th = calibv1_cpsl->off2on_th;
687 calibv2_cpsl_calib->manual_on = !!calibv1_cpsl->cpsl_on;
688 calibv2_cpsl_calib->manual_strength = calibv1_cpsl->strength;
689 }
690
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)691 void CalibConverterAgamma::convert(CamCalibDbV2Context_t *calibv2,
692 CamCalibDbContext_t *calibv1) {
693 CalibDb_Gamma_t* calibv1_gamma =
694 (CalibDb_Gamma_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, gamma);
695 if (!calibv1_gamma)
696 return;
697
698 CalibDbV2_gamma_v10_t* calibv2_agamma_calib =
699 (CalibDbV2_gamma_v10_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, agamma_calib));
700 if (!calibv2_agamma_calib)
701 return;
702
703 calibv2_agamma_calib->GammaTuningPara.Gamma_en = calibv1_gamma->gamma_en ? true : false;
704 calibv2_agamma_calib->GammaTuningPara.Gamma_out_segnum = calibv1_gamma->gamma_out_segnum ? GAMMATYPE_EQU : GAMMATYPE_LOG;
705 calibv2_agamma_calib->GammaTuningPara.Gamma_out_offset = calibv1_gamma->gamma_out_offset;
706 for(int i = 0; i < 45; i++)
707 calibv2_agamma_calib->GammaTuningPara.Gamma_curve[i] = (int)(calibv1_gamma->curve_normal[i] + 0.5);
708 }
709
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)710 void CalibConverterBAYERNRV1::convert(CamCalibDbV2Context_t *calibv2,
711 CamCalibDbContext_t *calibv1) {
712 if (CHECK_ISP_HW_V20()) {
713 CalibDb_BayerNr_2_t* calibv1_bayerNr =
714 (CalibDb_BayerNr_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, bayerNr);
715 if (!calibv1_bayerNr)
716 return;
717
718 CalibDbV2_BayerNrV1_t* calibv2_bayernr_v1 =
719 (CalibDbV2_BayerNrV1_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, bayernr_v1));
720 if (!calibv2_bayernr_v1)
721 return;
722
723 // TODO:
724 bayernrV1_calibdb_to_calibdbV2(calibv1_bayerNr, calibv2_bayernr_v1, 0);
725 }
726
727 }
728
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)729 void CalibConverterMFNRV1::convert(CamCalibDbV2Context_t *calibv2,
730 CamCalibDbContext_t *calibv1) {
731 if (CHECK_ISP_HW_V20()) {
732 CalibDb_MFNR_2_t* calibv1_mfnr =
733 (CalibDb_MFNR_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, mfnr);
734 if (!calibv1_mfnr)
735 return;
736
737 CalibDbV2_MFNR_t* calibv2_mfnr_v1 =
738 (CalibDbV2_MFNR_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, mfnr_v1));
739 if (!calibv2_mfnr_v1)
740 return;
741
742 // TODO:
743 mfnrV1_calibdb_to_calibdbV2(calibv1_mfnr, calibv2_mfnr_v1, 0);
744 }
745
746 }
747
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)748 void CalibConverterUVNRV1::convert(CamCalibDbV2Context_t *calibv2,
749 CamCalibDbContext_t *calibv1) {
750 if (CHECK_ISP_HW_V20()) {
751 CalibDb_UVNR_2_t* calibv1_uvnr =
752 (CalibDb_UVNR_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, uvnr);
753 if (!calibv1_uvnr)
754 return;
755
756 CalibDbV2_UVNR_t* calibv2_uvnr_v1 =
757 (CalibDbV2_UVNR_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, uvnr_v1));
758 if (!calibv2_uvnr_v1)
759 return;
760
761 // TODO:
762 uvnrV1_calibdb_to_calibdbV2(calibv1_uvnr, calibv2_uvnr_v1, 0);
763 }
764
765 }
766
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)767 void CalibConverterYNRV1::convert(CamCalibDbV2Context_t *calibv2,
768 CamCalibDbContext_t *calibv1) {
769 if (CHECK_ISP_HW_V20()) {
770 CalibDb_YNR_2_t* calibv1_ynr =
771 (CalibDb_YNR_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, ynr);
772 if (!calibv1_ynr)
773 return;
774
775 CalibDbV2_YnrV1_t* calibv2_ynr_v1 =
776 (CalibDbV2_YnrV1_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ynr_v1));
777 if (!calibv2_ynr_v1)
778 return;
779
780 // TODO:
781 ynrV1_calibdb_to_calibdbV2(calibv1_ynr, calibv2_ynr_v1, 0);
782 }
783
784 }
785
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)786 void CalibConverterSHARPV1::convert(CamCalibDbV2Context_t *calibv2,
787 CamCalibDbContext_t *calibv1) {
788 if (CHECK_ISP_HW_V20()) {
789 CalibDb_Sharp_2_t* calibv1_sharp =
790 (CalibDb_Sharp_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, sharp);
791 if (!calibv1_sharp)
792 return;
793
794 CalibDbV2_SharpV1_t* calibv2_sharp_v1 =
795 (CalibDbV2_SharpV1_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, sharp_v1));
796 if (!calibv2_sharp_v1)
797 return;
798
799 // TODO:
800 sharpV1_calibdb_to_calibdbV2(calibv1_sharp, calibv2_sharp_v1, 0);
801 }
802
803 }
804
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)805 void CalibConverterEDGEFILTERV1::convert(CamCalibDbV2Context_t *calibv2,
806 CamCalibDbContext_t *calibv1) {
807 if (CHECK_ISP_HW_V20()) {
808 CalibDb_EdgeFilter_2_t* calibv1_edgeFilter =
809 (CalibDb_EdgeFilter_2_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, edgeFilter);
810 if (!calibv1_edgeFilter)
811 return;
812
813 CalibDbV2_Edgefilter_t* calibv2_edgefilter_v1 =
814 (CalibDbV2_Edgefilter_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, edgefilter_v1));
815 if (!calibv2_edgefilter_v1)
816 return;
817
818 // TODO:
819 edgefilterV1_calibdb_to_calibdbV2(calibv1_edgeFilter, calibv2_edgefilter_v1, 0);
820 }
821
822 }
823
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)824 void CalibConverterDebayer::convert(CamCalibDbV2Context_t* calibv2,
825 CamCalibDbContext_t* calibv1) {
826 CalibDb_RKDM_t* calibv1_dm =
827 (CalibDb_RKDM_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, dm);
828 if (!calibv1_dm)
829 return;
830
831 CalibDbV2_Debayer_t* calibv2_debayer =
832 (CalibDbV2_Debayer_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, debayer));
833 if (!calibv2_debayer)
834 return;
835
836 calibv2_debayer->param.debayer_en = !!calibv1_dm->debayer_en;
837 for (int i = 0; i < 5; i++) {
838 calibv2_debayer->param.debayer_filter1[i] = calibv1_dm->debayer_filter1[i];
839 calibv2_debayer->param.debayer_filter2[i] = calibv1_dm->debayer_filter2[i];
840 }
841 calibv2_debayer->param.debayer_gain_offset = calibv1_dm->debayer_gain_offset;
842 for (int i = 0; i < 9; i++) {
843 calibv2_debayer->param.array.ISO[i] = calibv1_dm->ISO[i];
844 calibv2_debayer->param.array.sharp_strength[i] = calibv1_dm->sharp_strength[i];
845 calibv2_debayer->param.array.debayer_hf_offset[i] = calibv1_dm->debayer_hf_offset[i];
846
847 }
848 calibv2_debayer->param.debayer_gain_offset = calibv1_dm->debayer_gain_offset;
849 for (int i = 0; i < 9; i++) {
850 calibv2_debayer->param.array.ISO[i] = calibv1_dm->ISO[i];
851 calibv2_debayer->param.array.sharp_strength[i] = calibv1_dm->sharp_strength[i];
852 calibv2_debayer->param.array.debayer_hf_offset[i] = calibv1_dm->debayer_hf_offset[i];
853 }
854 calibv2_debayer->param.debayer_offset = calibv1_dm->debayer_offset;
855 calibv2_debayer->param.debayer_clip_en = !!calibv1_dm->debayer_clip_en;
856 calibv2_debayer->param.debayer_filter_g_en = !!calibv1_dm->debayer_filter_g_en;
857 calibv2_debayer->param.debayer_filter_c_en = !!calibv1_dm->debayer_filter_c_en;
858 calibv2_debayer->param.debayer_thed0 = calibv1_dm->debayer_thed0;
859 calibv2_debayer->param.debayer_thed1 = calibv1_dm->debayer_thed1;
860 calibv2_debayer->param.debayer_dist_scale = calibv1_dm->debayer_dist_scale;
861 calibv2_debayer->param.debayer_cnr_strength = calibv1_dm->debayer_cnr_strength;
862 calibv2_debayer->param.debayer_shift_num = calibv1_dm->debayer_shift_num;
863 }
864
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)865 void CalibConverterCproc::convert(CamCalibDbV2Context_t* calibv2,
866 CamCalibDbContext_t* calibv1) {
867 CalibDb_cProc_t* calibv1_cProc =
868 (CalibDb_cProc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, cProc);
869 if (!calibv1_cProc)
870 return;
871
872 CalibDbV2_Cproc_t* calibv2_cproc =
873 (CalibDbV2_Cproc_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, cproc));
874 if (!calibv2_cproc)
875 return;
876
877 calibv2_cproc->param.enable = !!calibv1_cProc->enable;
878 calibv2_cproc->param.brightness = calibv1_cProc->brightness;
879 calibv2_cproc->param.contrast = calibv1_cProc->contrast;
880 calibv2_cproc->param.saturation = calibv1_cProc->saturation;
881 calibv2_cproc->param.hue = calibv1_cProc->hue;
882 }
883
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)884 void CalibConverterIE::convert(CamCalibDbV2Context_t* calibv2,
885 CamCalibDbContext_t* calibv1) {
886 CalibDb_IE_t* calibv1_ie =
887 (CalibDb_IE_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, ie);
888 if (!calibv1_ie)
889 return;
890
891 CalibDbV2_IE_t* calibv2_ie =
892 (CalibDbV2_IE_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ie));
893 if (!calibv2_ie)
894 return;
895
896 calibv2_ie->param.enable = !!calibv1_ie->enable;
897 calibv2_ie->param.mode = calibv1_ie->mode;
898 }
899
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)900 void CalibConverterCCM::convert(CamCalibDbV2Context_t *calibv2,
901 CamCalibDbContext_t *calibv1) {
902
903 convertCCMCalib2CalibV2(calibv1, calibv2);
904 }
905
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)906 void CalibConverterLUT3D::convert(CamCalibDbV2Context_t *calibv2,
907 CamCalibDbContext_t *calibv1) {
908 convertLut3DCalib2CalibV2(calibv1, calibv2);
909 }
910
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)911 void CalibConverterAdrc::convert(CamCalibDbV2Context_t *calibv2,
912 CamCalibDbContext_t *calibv1) {
913
914 convertAdrcCalibV1ToCalibV2(calibv1, calibv2);
915 }
916
917 /*
918
919 void CalibConverterAF::convert(CamCalibDbV2Context_t* calibv2,
920 CamCalibDbContext_t* calibv1)
921 {
922
923 }
924
925 void CalibConverterASD::convert(CamCalibDbV2Context_t* calibv2,
926 CamCalibDbContext_t* calibv1)
927 {
928
929 }
930
931 .
932 .
933 .
934
935 */
936
addToScene(CamCalibDbProj_t * calibpj,const char * main_scene,const char * sub_scene,CamCalibDbV2Context_t * calibv2)937 int IQConverter::addToScene(CamCalibDbProj_t *calibpj, const char *main_scene,
938 const char *sub_scene,
939 CamCalibDbV2Context_t *calibv2) {
940 auto sub_vector = new CamCalibSubSceneList_t();
941 auto main_vector = new CamCalibMainSceneList_t();
942
943 sub_vector[0].name = strdup(sub_scene);
944 memcpy(calibdbv2_get_scene_ptr(&sub_vector[0]),
945 calibv2->calib_scene, calibdbV2_scene_ctx_size(calibv2));
946
947 main_vector[0].name = strdup(main_scene);
948 main_vector[0].sub_scene = sub_vector;
949 main_vector[0].sub_scene_len = 1;
950
951 calibpj->main_scene = main_vector;
952 calibpj->main_scene_len = 1;
953
954 return 0;
955 }
956
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)957 void CalibConverterALSC::convert(
958 CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
959 {
960 CalibDb_Lsc_t* calibv1_lsc =
961 (CalibDb_Lsc_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, lsc);
962 if (!calibv1_lsc)
963 return;
964
965 CalibDbV2_LSC_t* calibv2_lsc_v2 =
966 (CalibDbV2_LSC_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, lsc_v2));
967 if (!calibv2_lsc_v2)
968 return;
969
970 CalibDb_LscTableProfile_t* tableV1;
971 CalibDbV2_LscTableProfile_t* tableV2;
972
973 CalibDbV2_LSC_t& lsc_v2 = *calibv2_lsc_v2;
974 CalibDbV2_Lsc_Common_t& common = lsc_v2.common;
975
976 common.enable = calibv1_lsc->enable;
977 common.resolutionAll_len = calibv1_lsc->aLscCof.lscResNum;
978 common.resolutionAll = (CalibDbV2_Lsc_Resolution_t*)
979 malloc(common.resolutionAll_len * sizeof(CalibDbV2_Lsc_Resolution_t));
980 memset(common.resolutionAll, '\0', common.resolutionAll_len * sizeof(CalibDbV2_Lsc_Resolution_t));
981 for (int i = 0; i < common.resolutionAll_len; i++) {
982 strcpy(common.resolutionAll[i].name, calibv1_lsc->aLscCof.lscResName[i]);
983 }
984
985 lsc_v2.alscCoef.damp_enable = calibv1_lsc->damp_enable;
986
987 int illuNumTotal = 0;
988 CalibDb_AlscCof_t& pAlscCof = calibv1_lsc->aLscCof;
989 for (int i = 0; i < USED_FOR_CASE_MAX; i++) {
990 illuNumTotal += pAlscCof.illuNum[i];
991 }
992 lsc_v2.alscCoef.illAll_len = illuNumTotal;
993 lsc_v2.alscCoef.illAll = (CalibDbV2_AlscCof_ill_t*)
994 malloc(illuNumTotal * sizeof(CalibDbV2_AlscCof_ill_t));
995 CalibDbV2_AlscCof_ill_t* ill_v2 = lsc_v2.alscCoef.illAll;
996
997 for (int ucase = 0; ucase < USED_FOR_CASE_MAX; ucase++) {
998 int illuNum = pAlscCof.illuNum[ucase];
999 for (int i = 0; i < illuNum; i++) {
1000 ill_v2->usedForCase = ucase;
1001 CalibDb_AlscCof_ill_t& ill_v1 = pAlscCof.illAll[ucase][i];
1002 strcpy(ill_v2->name, ill_v1.illuName);
1003 ill_v2->wbGain[0] = ill_v1.awbGain[0];
1004 ill_v2->wbGain[1] = ill_v1.awbGain[1];
1005 ill_v2->tableUsed_len = ill_v1.tableUsedNO;
1006 ill_v2->tableUsed = (lsc_name_t*)malloc(ill_v2->tableUsed_len * sizeof(lsc_name_t));
1007 for (int t = 0; t < ill_v2->tableUsed_len; t++) {
1008 strcpy(ill_v2->tableUsed[t].name, ill_v1.tableUsed[t]);
1009 }
1010 ill_v2->gains_len = ill_v1.vignettingCurve.arraySize;
1011 ill_v2->vig_len = ill_v1.vignettingCurve.arraySize;
1012 ill_v2->gains = (float*)malloc(ill_v2->gains_len * sizeof(float));
1013 ill_v2->vig = (float*)malloc(ill_v2->vig_len * sizeof(float));
1014 for (int gains_id = 0; gains_id < ill_v2->gains_len; gains_id++) {
1015 ill_v2->gains[gains_id] = ill_v1.vignettingCurve.pSensorGain[gains_id];
1016 }
1017 for (int vig_id = 0; vig_id < ill_v2->vig_len; vig_id++) {
1018 ill_v2->vig[vig_id] = ill_v1.vignettingCurve.pVignetting[vig_id];
1019 }
1020
1021 ill_v2++;
1022 }
1023 }
1024
1025 lsc_v2.tbl.tableAll_len = calibv1_lsc->tableAllNum;
1026 lsc_v2.tbl.tableAll = (CalibDbV2_LscTableProfile_t*)
1027 malloc(lsc_v2.tbl.tableAll_len * sizeof(CalibDbV2_LscTableProfile_t));
1028
1029 for (int i = 0; i < lsc_v2.tbl.tableAll_len; i++) {
1030 tableV1 = calibv1_lsc->tableAll + i;
1031 tableV2 = lsc_v2.tbl.tableAll + i;
1032
1033 memset(tableV2->name, '\0', sizeof(tableV2->name));
1034 strcpy(tableV2->name, tableV1->name);
1035 strcpy(tableV2->resolution, tableV1->resolution);
1036 strcpy(tableV2->illumination, tableV1->illumination);
1037 tableV2->vignetting = tableV1->vignetting;
1038
1039 for (int j = 0; j < lsc_v2.common.resolutionAll_len; j++) {
1040 int ret = strcmp(lsc_v2.common.resolutionAll[j].name, tableV2->resolution);
1041 if(0 == ret) {
1042 if (g_rkaiq_isp_hw_ver == 20 || g_rkaiq_isp_hw_ver == 22) {
1043 memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_x, tableV1->LscXSizeTbl, sizeof(tableV1->LscXSizeTbl));
1044 memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_y, tableV1->LscYSizeTbl, sizeof(tableV1->LscYSizeTbl));
1045 } else if (g_rkaiq_isp_hw_ver == 30 || g_rkaiq_isp_hw_ver == 32 || g_rkaiq_isp_hw_ver == 321) {
1046 memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_x, tableV1->LscXSizeTbl, sizeof(tableV1->LscXSizeTbl));
1047 memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_x+8, tableV1->LscXSizeTbl, sizeof(tableV1->LscXSizeTbl));
1048 memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_y, tableV1->LscYSizeTbl, sizeof(tableV1->LscYSizeTbl));
1049 memcpy(lsc_v2.common.resolutionAll[j].lsc_sect_size_y+8, tableV1->LscYSizeTbl, sizeof(tableV1->LscYSizeTbl));
1050 }
1051
1052 }
1053 }
1054
1055 memcpy(&tableV2->lsc_samples_red, &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_RED], sizeof(Cam17x17UShortMatrix_t));
1056 memcpy(&tableV2->lsc_samples_greenR, &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_GREENR], sizeof(Cam17x17UShortMatrix_t));
1057 memcpy(&tableV2->lsc_samples_greenB, &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_GREENB], sizeof(Cam17x17UShortMatrix_t));
1058 memcpy(&tableV2->lsc_samples_blue, &tableV1->LscMatrix[CAM_4CH_COLOR_COMPONENT_BLUE], sizeof(Cam17x17UShortMatrix_t));
1059 }
1060 }
1061
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1062 void CalibConverterAfec::convert(
1063 CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
1064 {
1065 CalibDb_FEC_t* calibv1_fec =
1066 (CalibDb_FEC_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, afec);
1067 if (!calibv1_fec)
1068 return;
1069
1070 CalibDbV2_FEC_t* calibv2_fec_db =
1071 (CalibDbV2_FEC_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, afec));
1072 if (!calibv2_fec_db)
1073 return;
1074 CalibDbV2_Fec_Param_t* calibv2_fec = &calibv2_fec_db->param;
1075
1076 memcpy(calibv2_fec, calibv1_fec, sizeof(*calibv1_fec));
1077 }
1078
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1079 void CalibConverterAldch::convert(
1080 CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
1081 {
1082 CalibDb_LDCH_t* calibv1_ldch =
1083 (CalibDb_LDCH_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, aldch);
1084 if (!calibv1_ldch)
1085 return;
1086
1087 CalibDbV2_LDCH_t* calibv2_ldch_db =
1088 (CalibDbV2_LDCH_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, aldch));
1089 if (!calibv2_ldch_db)
1090 return;
1091 CalibDbV2_Ldch_Param_t* calibv2_ldch = &calibv2_ldch_db->param;
1092
1093 calibv2_ldch->ldch_en = calibv1_ldch->ldch_en;
1094 calibv2_ldch->correct_level = calibv1_ldch->correct_level;
1095 calibv2_ldch->correct_level_max = calibv1_ldch->correct_level_max;
1096 memcpy(calibv2_ldch->meshfile, calibv1_ldch->meshfile, strlen(calibv1_ldch->meshfile));
1097 memcpy(calibv2_ldch->light_center, calibv1_ldch->light_center, sizeof(double) * 2);
1098 memcpy(calibv2_ldch->coefficient, calibv1_ldch->coefficient, sizeof(double) * 4);
1099 }
1100
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1101 void CalibConverterColorAsGrey::convert(
1102 CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
1103 {
1104 CalibDb_ColorAsGrey_t* calibv1_colorAsGrey =
1105 (CalibDb_ColorAsGrey_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, colorAsGrey);
1106 if (!calibv1_colorAsGrey)
1107 return;
1108
1109 CalibDbV2_ColorAsGrey_t* calibv2_colorAsGrey =
1110 (CalibDbV2_ColorAsGrey_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, colorAsGrey));
1111 if (!calibv2_colorAsGrey)
1112 return;
1113
1114 memcpy(calibv2_colorAsGrey, calibv1_colorAsGrey, sizeof(*calibv1_colorAsGrey));
1115 }
1116
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1117 void CalibConverterLumaDetect::convert(
1118 CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
1119 {
1120 CalibDb_LUMA_DETECT_t* calibv1_lumaDetect =
1121 (CalibDb_LUMA_DETECT_t*)CALIBDB_GET_MODULE_PTR((void*)calibv1, lumaDetect);
1122 if (!calibv1_lumaDetect)
1123 return;
1124
1125 CalibDbV2_LUMA_DETECT_t* calibv2_lumaDetect =
1126 (CalibDbV2_LUMA_DETECT_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, lumaDetect));
1127 if (!calibv2_lumaDetect)
1128 return;
1129
1130 memcpy(calibv2_lumaDetect, calibv1_lumaDetect, sizeof(*calibv1_lumaDetect));
1131 }
1132
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1133 void CalibConverterAf::convert(
1134 CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
1135 {
1136 convertAfCalibV1ToCalibV2(calibv1, calibv2);
1137 }
1138
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1139 void CalibConverterThumbnails::convert(
1140 CamCalibDbV2Context_t *calibv2, CamCalibDbContext_t *calibv1)
1141 {
1142 CalibDbV2_Thumbnails_t* calibv2_thumbnails_db =
1143 (CalibDbV2_Thumbnails_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, thumbnails));
1144 if (!calibv2_thumbnails_db)
1145 return;
1146
1147 CalibDbV2_Thumbnails_Param_t* calibv2_thumbnails = &calibv2_thumbnails_db->param;
1148 calibv2_thumbnails->thumbnail_configs_len = 3;
1149
1150 calibv2_thumbnails->thumbnail_configs = reinterpret_cast<rkaiq_thumbnails_config_t*>(calloc(
1151 calibv2_thumbnails->thumbnail_configs_len, sizeof(*calibv2_thumbnails->thumbnail_configs)));
1152 if (NULL == calibv2_thumbnails->thumbnail_configs) {
1153 goto failure;
1154 return;
1155 }
1156
1157 for (uint32_t i = 0; i < calibv2_thumbnails->thumbnail_configs_len; i++) {
1158 auto* config = &calibv2_thumbnails->thumbnail_configs[i];
1159 config->owner_cookies = i;
1160 config->stream_type = 0;
1161 config->format[0] = 'N';
1162 config->format[1] = 'V';
1163 config->format[2] = '1';
1164 config->format[3] = '2';
1165 config->width_intfactor = 1 << (i + 1);
1166 config->height_intfactor = 1 << (i + 1);
1167 }
1168
1169 return;
1170
1171 failure:
1172 if (calibv2_thumbnails->thumbnail_configs != NULL) {
1173 free(calibv2_thumbnails->thumbnail_configs);
1174 }
1175
1176 }
1177
1178
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1179 void CalibConverterBAYERNRV2::convert(CamCalibDbV2Context_t *calibv2,
1180 CamCalibDbContext_t *calibv1) {
1181 if (CHECK_ISP_HW_V21()) {
1182 struct list_head* bayernrV2_list =
1183 (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_bayernr_v2);
1184 if (!bayernrV2_list)
1185 return;
1186
1187 CalibDbV2_BayerNrV2_t* calibv2_bayernr_v2 =
1188 (CalibDbV2_BayerNrV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, bayernr_v2));
1189 if (!calibv2_bayernr_v2)
1190 return;
1191
1192 // TODO:
1193 bayernrV2_calibdb_to_calibdbV2(bayernrV2_list, calibv2_bayernr_v2, 0);
1194 }
1195
1196 }
1197
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1198 void CalibConverterCNRV1::convert(CamCalibDbV2Context_t *calibv2,
1199 CamCalibDbContext_t *calibv1) {
1200 if (CHECK_ISP_HW_V21()) {
1201 struct list_head* calibv1_cnr_list =
1202 (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_cnr_v1);
1203 if (!calibv1_cnr_list)
1204 return;
1205
1206 CalibDbV2_CNR_t* calibv2_cnr_v1 =
1207 (CalibDbV2_CNR_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, cnr_v1));
1208 if (!calibv2_cnr_v1)
1209 return;
1210
1211 // TODO:
1212 cnrV1_calibdb_to_calibdbV2(calibv1_cnr_list, calibv2_cnr_v1, 0);
1213 }
1214
1215 }
1216
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1217 void CalibConverterYNRV2::convert(CamCalibDbV2Context_t *calibv2,
1218 CamCalibDbContext_t *calibv1) {
1219 if (CHECK_ISP_HW_V21()) {
1220 struct list_head* calibv1_ynr_list =
1221 (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_ynr_v2);
1222 if (!calibv1_ynr_list)
1223 return;
1224
1225 CalibDbV2_YnrV2_t* calibv2_ynr_v2 =
1226 (CalibDbV2_YnrV2_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, ynr_v2));
1227 if (!calibv2_ynr_v2)
1228 return;
1229
1230 // TODO:
1231 ynrV2_calibdb_to_calibdbV2(calibv1_ynr_list, calibv2_ynr_v2, 0);
1232 }
1233
1234 }
1235
convert(CamCalibDbV2Context_t * calibv2,CamCalibDbContext_t * calibv1)1236 void CalibConverterSHARPV3::convert(CamCalibDbV2Context_t *calibv2,
1237 CamCalibDbContext_t *calibv1) {
1238 if (CHECK_ISP_HW_V21()) {
1239 struct list_head* calibv1_sharp_list =
1240 (struct list_head*)CALIBDB_GET_MODULE_PTR((void*)calibv1, list_sharp_v3);
1241 if (!calibv1_sharp_list)
1242 return;
1243
1244 CalibDbV2_SharpV3_t* calibv2_sharp_v2 =
1245 (CalibDbV2_SharpV3_t*)(CALIBDBV2_GET_MODULE_PTR(calibv2, sharp_v3));
1246 if (!calibv2_sharp_v2)
1247 return;
1248
1249 // TODO:
1250 sharpV3_calibdb_to_calibdbV2(calibv1_sharp_list, calibv2_sharp_v2, 0);
1251 }
1252 }
1253
1254 } // namespace RkCam
1255