1 #include "awb_xml2json.h"
2 #include "RkAiqCalibApi.h"
3
CalibV2AwbV21Free(CamCalibDbV2Context_t * calibV2)4 void CalibV2AwbV21Free(CamCalibDbV2Context_t *calibV2)
5 {
6 CalibDbV2_Wb_Para_V21_t* wb_v21 =
7 (CalibDbV2_Wb_Para_V21_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v21));
8 if(wb_v21 == NULL){
9 return;
10 }
11 CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV21 = &wb_v21->autoExtPara;
12 CalibDbV2_Wb_Awb_Para_V21_t* autoParaV21 = &wb_v21->autoPara;
13 free(commV21->lightSourceForFirstFrame);
14 free(commV21->wbGainClip.cct);
15 free(commV21->wbGainClip.cri_bound_up);
16 free(commV21->wbGainClip.cri_bound_low);
17 free(commV21->singleColorProces.colorBlock);
18 for(int i=0;i<commV21->singleColorProces.lsUsedForEstimation_len;i++){
19 free(commV21->singleColorProces.lsUsedForEstimation[i].name);
20 }
21 free(commV21->singleColorProces.lsUsedForEstimation);
22 free(commV21->tolerance.toleranceValue);
23 free(commV21->tolerance.lumaValue);
24 free(commV21->runInterval.intervalValue);
25 free(commV21->runInterval.lumaValue);
26 for(int i=0;i<commV21->wbGainAdjust.lutAll_len;i++){
27 free(commV21->wbGainAdjust.lutAll[i].ct_lut_out);
28 free(commV21->wbGainAdjust.lutAll[i].cri_lut_out);
29 }
30 free(commV21->wbGainAdjust.lutAll);
31 free(commV21->weightForNightGainCalc);
32 free(commV21->division.wpNumTh.high);
33 free(commV21->division.wpNumTh.low);
34 free(commV21->division.wpNumTh.lumaValue);
35 free(commV21->xyRegionStableSelection.wpNumTh.lumaValue);
36 free(commV21->xyRegionStableSelection.wpNumTh.forBigType);
37 free(commV21->xyRegionStableSelection.wpNumTh.forExtraType);
38 for(int i=0;i<autoParaV21->lsUsedForYuvDet_len;i++){
39 free(autoParaV21->lsUsedForYuvDet[i]);
40 }
41 free(autoParaV21->lsUsedForYuvDet);
42 for(int i=0;i<autoParaV21->lightSources_len;i++){
43 free(autoParaV21->lightSources[i].name);
44 }
45 free(autoParaV21->lightSources);
46 free(autoParaV21->limitRange.lumaValue);
47 free(autoParaV21->limitRange.maxB);
48 free(autoParaV21->limitRange.maxR);
49 free(autoParaV21->limitRange.maxG);
50 free(autoParaV21->limitRange.maxY);
51 free(autoParaV21->limitRange.minB);
52 free(autoParaV21->limitRange.minR);
53 free(autoParaV21->limitRange.minG);
54 free(autoParaV21->limitRange.minY);
55 }
convertCalib2calibV21(const CamCalibDbContext_t * calib,CamCalibDbV2Context_t * calibV2)56 void convertCalib2calibV21(const CamCalibDbContext_t *calib,CamCalibDbV2Context_t *calibV2)
57 {
58 const CalibDb_Awb_Calib_Para_V201_t *awb_calib_v21 = NULL;
59
60 list_head *awb_calib_para_list =
61 (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_calib_para_v201);
62
63 if (awb_calib_para_list)
64 GetAwbProfileFromAwbCalibV201ListByIdx(awb_calib_para_list, 0, &awb_calib_v21);
65 else
66 return;
67
68 const CalibDb_Awb_Adjust_Para_t *awb_adjust = NULL;
69
70 list_head *awb_adjust_list =
71 (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_adjust_para);
72
73 if (awb_adjust_list)
74 GetAwbProfileFromAwbAdjustListByIdx(awb_adjust_list, 0, &awb_adjust);
75 else
76 return;
77
78 CalibDbV2_Wb_Para_V21_t* wb_v21 =
79 (CalibDbV2_Wb_Para_V21_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v21));
80 memset(wb_v21, 0, sizeof(CalibDbV2_Wb_Para_V21_t));
81 CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV21 = &wb_v21->autoExtPara;
82 CalibDbV2_Wb_Awb_Para_V21_t* autoParaV21 = &wb_v21->autoPara;
83 commV21->lightSourceForFirstFrame= (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
84 commV21->wbGainClip.cct_len = awb_calib_v21->cct_clip_cfg.grid_num;
85 commV21->wbGainClip.cri_bound_up_len = awb_calib_v21->cct_clip_cfg.grid_num;
86 commV21->wbGainClip.cri_bound_low_len = awb_calib_v21->cct_clip_cfg.grid_num;
87 commV21->wbGainClip.cct = (float*)malloc(sizeof(float) * commV21->wbGainClip.cct_len);
88 commV21->wbGainClip.cri_bound_up = (float*)malloc(sizeof(float) * commV21->wbGainClip.cct_len);
89 commV21->wbGainClip.cri_bound_low = (float*)malloc(sizeof(float) * commV21->wbGainClip.cct_len);
90 commV21->singleColorProces.colorBlock_len = awb_calib_v21->sSelColorNUM;
91 commV21->singleColorProces.lsUsedForEstimation_len = awb_calib_v21->sIllEstNum;
92 commV21->singleColorProces.colorBlock = (CalibDbV2_Awb_Sgc_Cblk_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Cblk_t)*commV21->singleColorProces.colorBlock_len);
93 commV21->singleColorProces.lsUsedForEstimation = (CalibDbV2_Awb_Sgc_Ls_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Ls_t)*commV21->singleColorProces.lsUsedForEstimation_len);
94 for(int i=0;i<commV21->singleColorProces.lsUsedForEstimation_len;i++){
95 commV21->singleColorProces.lsUsedForEstimation[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
96 }
97 commV21->tolerance.lumaValue_len = awb_adjust->tolerance.num;
98 commV21->tolerance.toleranceValue_len = awb_adjust->tolerance.num;
99 commV21->tolerance.toleranceValue = (float*)malloc(sizeof(float)*commV21->tolerance.toleranceValue_len);
100 commV21->tolerance.lumaValue= (float*)malloc(sizeof(float)*commV21->tolerance.lumaValue_len);
101 commV21->runInterval.lumaValue_len = awb_adjust->runInterval.num;
102 commV21->runInterval.intervalValue_len= awb_adjust->runInterval.num;
103 commV21->runInterval.intervalValue = (float*)malloc(sizeof(float)*commV21->runInterval.intervalValue_len);
104 commV21->runInterval.lumaValue= (float*)malloc(sizeof(float)*commV21->runInterval.lumaValue_len);
105 commV21->wbGainAdjust.lutAll_len = awb_adjust->cct_lut_cfg_num;
106 commV21->wbGainAdjust.lutAll = (CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t*)malloc(sizeof(CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t)*commV21->wbGainAdjust.lutAll_len);
107 for(int i=0;i<commV21->wbGainAdjust.lutAll_len;i++){
108 commV21->wbGainAdjust.lutAll[i].ct_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num * awb_adjust->cct_lut_cfg[0].cri_grid_num;
109 commV21->wbGainAdjust.lutAll[i].ct_lut_out = (float*)malloc(sizeof(float)*commV21->wbGainAdjust.lutAll[i].ct_lut_out_len);
110 commV21->wbGainAdjust.lutAll[i].cri_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num * awb_adjust->cct_lut_cfg[0].cri_grid_num;
111 commV21->wbGainAdjust.lutAll[i].cri_lut_out = (float*)malloc(sizeof(float)*commV21->wbGainAdjust.lutAll[i].cri_lut_out_len);
112 }
113 commV21->weightForNightGainCalc_len = 4;
114 commV21->weightForNightGainCalc = (unsigned char*)malloc(sizeof(unsigned char)*commV21->weightForNightGainCalc_len);
115 autoParaV21->lsUsedForYuvDet_len = 7;
116 autoParaV21->lsUsedForYuvDet = (char**)malloc(sizeof(char*)*autoParaV21->lsUsedForYuvDet_len);
117 for(int i=0;i<autoParaV21->lsUsedForYuvDet_len;i++){
118 autoParaV21->lsUsedForYuvDet[i] = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
119 }
120 autoParaV21->lightSources_len = 7;
121 autoParaV21->lightSources = (CalibDbV2_Awb_Light_V21_t*)malloc(sizeof(CalibDbV2_Awb_Light_V21_t)*autoParaV21->lightSources_len);
122 for(int i=0;i<autoParaV21->lightSources_len;i++){
123 autoParaV21->lightSources[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
124 }
125 autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len = 2;
126 autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet =
127 (CalibDbV2_Awb_Luma_Weight_Lv_t*)malloc(sizeof(CalibDbV2_Awb_Luma_Weight_Lv_t)*autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len);
128 for(int i=0;i<autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len;i++){
129 autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet_len = 3;
130 autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet =
131 (CalibDbV2_Awb_Lum_Wgt_Lv_Rto_t*)malloc(sizeof(CalibDbV2_Awb_Lum_Wgt_Lv_Rto_t)*autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet_len);
132 }
133 autoParaV21->limitRange.lumaValue = (float*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(float));
134 autoParaV21->limitRange.maxB= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
135 autoParaV21->limitRange.maxR= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
136 autoParaV21->limitRange.maxG= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
137 autoParaV21->limitRange.maxY= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
138 autoParaV21->limitRange.minB= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
139 autoParaV21->limitRange.minR= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
140 autoParaV21->limitRange.minG= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
141 autoParaV21->limitRange.minY= (unsigned short*)malloc(awb_calib_v21->limitRange.lumaNum *sizeof(unsigned short));
142 commV21->division.wpNumTh.high = (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
143 commV21->division.wpNumTh.low= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
144 commV21->division.wpNumTh.lumaValue= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
145 commV21->xyRegionStableSelection.wpNumTh.lumaValue = (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
146 commV21->xyRegionStableSelection.wpNumTh.forBigType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
147 commV21->xyRegionStableSelection.wpNumTh.forExtraType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
148 //coppy value
149 CalibDbV2_Wb_Para_t *control = &wb_v21->control;
150 control->byPass = 0;
151 control->mode = CALIB_WB_MODE_AUTO;
152 CalibDbV2_Wb_Mwb_Para_t *manualPara = &wb_v21->manualPara;
153 manualPara->mode = CALIB_MWB_MODE_SCENE;
154 manualPara->cfg.scene = CALIB_WB_SCENE_CLOUDY_DAYLIGHT;
155 manualPara->cfg.cct.CCT = 5000;
156 manualPara->cfg.cct.CCRI = 0;
157 memcpy(manualPara->cfg.mwbGain, awb_calib_v21->standardGainValue[0],sizeof(manualPara->cfg.mwbGain));
158 autoParaV21->hdrPara.frameChoose = awb_calib_v21->hdrFrameChoose;
159 autoParaV21->hdrPara.frameChooseMode= (CalibDbV2_Awb_Hdr_Fr_Ch_Mode_t)awb_calib_v21->hdrFrameChooseMode;
160 autoParaV21->lscBypassEnable = awb_calib_v21->lscBypEnable;
161 autoParaV21->uvDetectionEnable = awb_calib_v21->uvDetectionEnable;
162 autoParaV21->xyDetectionEnable= awb_calib_v21->xyDetectionEnable;
163 autoParaV21->yuvDetectionEnable = awb_calib_v21->yuvDetectionEnable;
164 for(int i=0;i<autoParaV21->lsUsedForYuvDet_len;i++){
165 strcpy(autoParaV21->lsUsedForYuvDet[i],awb_calib_v21->lsUsedForYuvDet[i]);
166 }
167 autoParaV21->blkStatisticsEnable = awb_calib_v21->blkStatisticsEnable;
168 autoParaV21->downScaleMode = (CalibDbV2_Awb_Down_Scale_Mode_t)awb_calib_v21->dsMode;
169 autoParaV21->blkMeasureMode = (CalibDbV2_Awb_Blk_Stat_V21_t)awb_calib_v21->blkMeasureMode;
170 autoParaV21->mainWindow.mode = (CalibDb_Window_Mode_t)awb_calib_v21->measeureWindow.mode;
171 float window[4] ={0,0,1,1};
172 bool flag = false;
173 if(autoParaV21->mainWindow.mode != CALIB_AWB_WINDOW_CFG_AUTO){
174 char resName[CALD_AWB_RES_NAME];
175 for(int i=0;i<awb_calib_v21->measeureWindow.resNum;i++){
176 char* p;
177 float width = 0;
178 float height =0;
179 strcpy(resName,awb_calib_v21->measeureWindow.resName[i]);
180 p = strtok(resName, "x");
181 if(p==NULL){
182 printf("parse resName %s error0,\n",awb_calib_v21->measeureWindow.resName[i]);
183 continue;
184 }
185 width = atoi(p);
186 p = strtok(NULL, " ");
187 if(p==NULL){
188 printf("parse resName %s error1,\n",awb_calib_v21->measeureWindow.resName[i]);
189 continue;
190 }
191 height = atoi(p);
192 if (height*width>0.001){
193 if((float)awb_calib_v21->measeureWindow.window[i][0]/width > window[0]){
194 window[0] = awb_calib_v21->measeureWindow.window[i][0]/width;
195 flag = true;
196 }
197 if((float)awb_calib_v21->measeureWindow.window[i][1]/height > window[1]){
198 window[1] = awb_calib_v21->measeureWindow.window[i][1]/height;
199 flag = true;
200 }
201 if((float)awb_calib_v21->measeureWindow.window[i][2]/width < window[2]){
202 window[2] = awb_calib_v21->measeureWindow.window[i][2]/width;
203 flag = true;
204 }
205 if((float)awb_calib_v21->measeureWindow.window[i][3]/height < window[3]){
206 window[3] = awb_calib_v21->measeureWindow.window[i][3]/height;
207 flag = true;
208 }
209 }else{
210 printf("parse resName %s error2,\n",awb_calib_v21->measeureWindow.resName[i]);
211 }
212 }
213 }
214 if (flag){
215 printf("please check parse mainWindow.window (ratio) is %f,%f,%f,%f\n",window[0],window[1],window[2],window[3]);
216
217 }
218 memcpy(autoParaV21->mainWindow.window, window,sizeof(window));
219
220 autoParaV21->limitRange.lumaValue_len= awb_calib_v21->limitRange.lumaNum;
221 memcpy(autoParaV21->limitRange.lumaValue,awb_calib_v21->limitRange.lumaValue,autoParaV21->limitRange.lumaValue_len*sizeof(float));
222 autoParaV21->limitRange.maxB_len= awb_calib_v21->limitRange.lumaNum;
223 memcpy(autoParaV21->limitRange.maxB,awb_calib_v21->limitRange.maxB,autoParaV21->limitRange.maxB_len*sizeof(unsigned short));
224 autoParaV21->limitRange.maxR_len= awb_calib_v21->limitRange.lumaNum;
225 memcpy(autoParaV21->limitRange.maxR,awb_calib_v21->limitRange.maxR,autoParaV21->limitRange.maxR_len*sizeof(unsigned short));
226 autoParaV21->limitRange.maxG_len= awb_calib_v21->limitRange.lumaNum;
227 memcpy(autoParaV21->limitRange.maxG,awb_calib_v21->limitRange.maxG,autoParaV21->limitRange.maxG_len*sizeof(unsigned short));
228 autoParaV21->limitRange.maxY_len= awb_calib_v21->limitRange.lumaNum;
229 memcpy(autoParaV21->limitRange.maxY,awb_calib_v21->limitRange.maxY,autoParaV21->limitRange.maxY_len*sizeof(unsigned short));
230 autoParaV21->limitRange.minB_len= awb_calib_v21->limitRange.lumaNum;
231 memcpy(autoParaV21->limitRange.minB,awb_calib_v21->limitRange.minB,autoParaV21->limitRange.minB_len*sizeof(unsigned short));
232 autoParaV21->limitRange.minR_len= awb_calib_v21->limitRange.lumaNum;
233 memcpy(autoParaV21->limitRange.minR,awb_calib_v21->limitRange.minR,autoParaV21->limitRange.minR_len*sizeof(unsigned short));
234 autoParaV21->limitRange.minG_len= awb_calib_v21->limitRange.lumaNum;
235 memcpy(autoParaV21->limitRange.minG,awb_calib_v21->limitRange.minG,autoParaV21->limitRange.minG_len*sizeof(unsigned short));
236 autoParaV21->limitRange.minY_len= awb_calib_v21->limitRange.lumaNum;
237 memcpy(autoParaV21->limitRange.minY,awb_calib_v21->limitRange.minY,autoParaV21->limitRange.minY_len*sizeof(unsigned short));
238 memcpy(autoParaV21->rgb2TcsPara.rotationMat, awb_calib_v21->rgb2tcs_param.rotationMat, sizeof(autoParaV21->rgb2TcsPara.rotationMat));
239 memcpy(autoParaV21->rgb2TcsPara.pseudoLuminanceWeight, awb_calib_v21->rgb2tcs_param.pseudoLuminanceWeight, sizeof(autoParaV21->rgb2TcsPara.pseudoLuminanceWeight));
240 memcpy(autoParaV21->rgb2RotationYuvMat, awb_calib_v21->rgb2RYuv_matrix,sizeof(autoParaV21->rgb2RotationYuvMat));
241 for(int i=0;i<CALD_AWB_EXCRANGE_NUM_MAX;i++){
242 autoParaV21->extraWpRange[i].domain = (CalibDbV2_Awb_Ext_Range_Dom_t)awb_calib_v21->excludeWpRange[i].domain;
243 if(awb_calib_v21->excludeWpRange[i].mode != CALIB_AWB_EXCLUDE_WP_MODE
244 && awb_calib_v21->excludeWpRange[i].mode != CALIB_AWB_ETR_LIGHT_SOUR_MODE ){
245 autoParaV21->extraWpRange[i].mode = CALIB_AWB_EXCLUDE_WP_MODE;
246 }else{
247 autoParaV21->extraWpRange[i].mode = (CalibDbV2_Awb_Ext_Range_Mode_t)awb_calib_v21->excludeWpRange[i].mode;
248 }
249 autoParaV21->extraWpRange[i].region[0] = awb_calib_v21->excludeWpRange[i].xu[0];
250 autoParaV21->extraWpRange[i].region[1] = awb_calib_v21->excludeWpRange[i].xu[1];
251 autoParaV21->extraWpRange[i].region[2] = awb_calib_v21->excludeWpRange[i].yv[0];
252 autoParaV21->extraWpRange[i].region[3] = awb_calib_v21->excludeWpRange[i].yv[1];
253 }
254 autoParaV21->wpDiffBlkWeiEnable = awb_calib_v21->blkWeightEnable;
255 for(int i=0;i<CALD_AWB_GRID_NUM_TOTAL;i++){
256 autoParaV21->wpDiffBlkWeight[i] = (awb_calib_v21->blkWeight[i] * 2) > 63 ? 63 : awb_calib_v21->blkWeight[i] * 2;
257 }
258 autoParaV21->wpDiffLumaWeight.enable = awb_calib_v21->wpDiffWeiEnable;
259 memcpy(autoParaV21->wpDiffLumaWeight.wpDiffwei_y, awb_calib_v21->wpDiffwei_y, sizeof(autoParaV21->wpDiffLumaWeight.wpDiffwei_y));
260 memcpy(autoParaV21->wpDiffLumaWeight.perfectBin, awb_calib_v21->perfectBin, sizeof(autoParaV21->wpDiffLumaWeight.perfectBin));
261 autoParaV21->wpDiffLumaWeight.wpDiffWeiEnableTh.wpDiffWeiNoTh= awb_calib_v21->wpDiffNoTh;
262 autoParaV21->wpDiffLumaWeight.wpDiffWeiEnableTh.wpDiffWeiLvValueTh= awb_calib_v21->wpDiffLvValueTh;
263 for(int i=0;i < autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet_len; i++){
264 autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].LvValue = awb_calib_v21->wpDiffweiSet_w_LvValueTh[i];
265 for(int j=0;j<autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet_len;j++){
266 autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].ratioValue = awb_calib_v21->wpDiffWeiRatioTh[j];
267 if(i==1){
268 memcpy(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight, awb_calib_v21->wpDiffweiSet_w_HigLV[j],
269 sizeof(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight));
270 }else{
271 memcpy(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight, awb_calib_v21->wpDiffweiSet_w_LowLV[j],
272 sizeof(autoParaV21->wpDiffLumaWeight.wpDiffWeightLvSet[i].ratioSet[j].weight));
273 }
274 }
275 }
276 for(int i=0;i<autoParaV21->lightSources_len;i++){
277 strcpy(autoParaV21->lightSources[i].name, awb_calib_v21->lightName[i]);
278 autoParaV21->lightSources[i].doorType = (CalibDbV2_Awb_DoorType_t)awb_calib_v21->doorType[i];
279 memcpy(autoParaV21->lightSources[i].standardGainValue, awb_calib_v21->standardGainValue[i],sizeof(autoParaV21->lightSources[i].standardGainValue));
280 memcpy(autoParaV21->lightSources[i].uvRegion.u, awb_calib_v21->uvRange_param[i].pu_region,sizeof(autoParaV21->lightSources[i].uvRegion.u));
281 memcpy(autoParaV21->lightSources[i].uvRegion.v, awb_calib_v21->uvRange_param[i].pv_region,sizeof(autoParaV21->lightSources[i].uvRegion.v));
282 autoParaV21->lightSources[i].xyRegion.normal[0] = awb_calib_v21->xyRangeLight[i].NorrangeX[0];
283 autoParaV21->lightSources[i].xyRegion.normal[1] = awb_calib_v21->xyRangeLight[i].NorrangeX[1];
284 autoParaV21->lightSources[i].xyRegion.normal[2] = awb_calib_v21->xyRangeLight[i].NorrangeY[0];
285 autoParaV21->lightSources[i].xyRegion.normal[3] = awb_calib_v21->xyRangeLight[i].NorrangeY[1];
286 autoParaV21->lightSources[i].xyRegion.big[0] = awb_calib_v21->xyRangeLight[i].SperangeX[0];
287 autoParaV21->lightSources[i].xyRegion.big[1] = awb_calib_v21->xyRangeLight[i].SperangeX[1];
288 autoParaV21->lightSources[i].xyRegion.big[2] = awb_calib_v21->xyRangeLight[i].SperangeY[0];
289 autoParaV21->lightSources[i].xyRegion.big[3] = awb_calib_v21->xyRangeLight[i].SperangeY[1];
290 memcpy(autoParaV21->lightSources[i].rtYuvRegion.thcurve_u, awb_calib_v21->yuv3D2Range_param[i].thcurve_u,
291 sizeof(awb_calib_v21->yuv3D2Range_param[i].thcurve_u));
292 memcpy(autoParaV21->lightSources[i].rtYuvRegion.thcure_th, awb_calib_v21->yuv3D2Range_param[i].thcure_th,
293 sizeof(awb_calib_v21->yuv3D2Range_param[i].thcure_th));
294 memcpy(autoParaV21->lightSources[i].rtYuvRegion.lineVector, awb_calib_v21->yuv3D2Range_param[i].line,
295 sizeof(awb_calib_v21->yuv3D2Range_param[i].line));
296 autoParaV21->lightSources[i].rtYuvRegion.disP1P2 = 15;
297
298 memcpy(autoParaV21->lightSources[i].staWeight, awb_adjust->awb_light_info[i].staWeight, sizeof(autoParaV21->lightSources[i].staWeight));
299 autoParaV21->lightSources[i].dayGainLvThSet[0] = awb_adjust->awb_light_info[i].spatialGain_LV_THL;
300 autoParaV21->lightSources[i].dayGainLvThSet[1] = awb_adjust->awb_light_info[i].spatialGain_LV_THH;
301 memcpy(autoParaV21->lightSources[i].defaultDayGainLow,awb_calib_v21->spatialGain_L, sizeof(awb_calib_v21->spatialGain_L));
302 memcpy(autoParaV21->lightSources[i].defaultDayGainHigh,awb_calib_v21->spatialGain_H, sizeof(awb_calib_v21->spatialGain_H));
303 autoParaV21->lightSources[i].xyType2Enable = awb_adjust->awb_light_info[i].xyType2Enable;
304 }
305
306 strcpy(commV21->lightSourceForFirstFrame, awb_adjust->lsForFirstFrame);
307 memcpy(commV21->tolerance.lumaValue, awb_adjust->tolerance.LV,sizeof(float)*commV21->tolerance.lumaValue_len);
308 memcpy(commV21->tolerance.toleranceValue, awb_adjust->tolerance.value,sizeof(float)*commV21->tolerance.toleranceValue_len);
309 memcpy(commV21->runInterval.lumaValue, awb_adjust->runInterval.LV,sizeof(float)*commV21->runInterval.lumaValue_len);
310 memcpy(commV21->runInterval.intervalValue, awb_adjust->runInterval.value,sizeof(float)*commV21->runInterval.intervalValue_len);
311 commV21->dampFactor.dFStep = awb_adjust->dFStep;
312 commV21->dampFactor.dFMin = awb_adjust->dFMin;
313 commV21->dampFactor.dFMax = awb_adjust->dFMax;
314 commV21->dampFactor.lvIIRsize = awb_adjust->LvIIRsize;
315 commV21->dampFactor.lvVarTh = awb_adjust->LvVarTh;
316 commV21->wbGainAdjust.enable = awb_adjust->wbGainAdjustEn;
317 for(int i=0; i<commV21->wbGainAdjust.lutAll_len;i++){
318 commV21->wbGainAdjust.lutAll[i].lumaValue = awb_adjust->cct_lut_cfg[i].lv;
319 commV21->wbGainAdjust.lutAll[i].ct_grid_num = awb_adjust->cct_lut_cfg[0].ct_grid_num;
320 commV21->wbGainAdjust.lutAll[i].cri_grid_num = awb_adjust->cct_lut_cfg[0].cri_grid_num;
321 memcpy(commV21->wbGainAdjust.lutAll[i].ct_in_range, awb_adjust->cct_lut_cfg[0].ct_range,sizeof(commV21->wbGainAdjust.lutAll[i].ct_in_range));
322 memcpy(commV21->wbGainAdjust.lutAll[i].cri_in_range, awb_adjust->cct_lut_cfg[0].cri_range,sizeof(commV21->wbGainAdjust.lutAll[i].cri_in_range));
323 memcpy(commV21->wbGainAdjust.lutAll[i].ct_lut_out,awb_adjust->cct_lut_cfg[i].ct_lut_out,sizeof(float)*commV21->wbGainAdjust.lutAll[i].ct_lut_out_len);
324 memcpy(commV21->wbGainAdjust.lutAll[i].cri_lut_out,awb_adjust->cct_lut_cfg[i].cri_lut_out,sizeof(float)*commV21->wbGainAdjust.lutAll[i].cri_lut_out_len);
325 }
326 commV21->wbGainDaylightClip.enable= awb_calib_v21->wbGainDaylightClipEn;
327 commV21->wbGainDaylightClip.outdoor_cct_min = awb_calib_v21->cct_clip_cfg.outdoor_cct_min;
328 commV21->wbGainClip.enable= awb_calib_v21->wbGainClipEn;
329 memcpy(commV21->wbGainClip.cct, awb_calib_v21->cct_clip_cfg.cct,sizeof(float)*commV21->wbGainClip.cct_len);
330 memcpy(commV21->wbGainClip.cri_bound_low, awb_calib_v21->cct_clip_cfg.cri_bound_low,sizeof(float)*commV21->wbGainClip.cri_bound_low_len);
331 memcpy(commV21->wbGainClip.cri_bound_up, awb_calib_v21->cct_clip_cfg.cri_bound_up,sizeof(float)*commV21->wbGainClip.cri_bound_up_len);
332 commV21->division.lumaValThLow= awb_adjust->LV_THL;
333 commV21->division.lumaValThLow2= awb_adjust->LV_THL2;
334 commV21->division.lumaValThHigh= awb_adjust->LV_THH;
335 commV21->division.lumaValThHigh2= awb_adjust->LV_THH2;
336 commV21->division.wpNumTh.lumaValue_len = awb_adjust->WP_TH.num;
337 memcpy(commV21->division.wpNumTh.lumaValue, awb_adjust->WP_TH.lumaValue,sizeof(float)*commV21->division.wpNumTh.lumaValue_len);
338 commV21->division.wpNumTh.high_len = awb_adjust->WP_TH.num;
339 memcpy(commV21->division.wpNumTh.high, awb_adjust->WP_TH.WP_THH,sizeof(float)*commV21->division.wpNumTh.lumaValue_len);
340 commV21->division.wpNumTh.low_len = awb_adjust->WP_TH.num;
341 memcpy(commV21->division.wpNumTh.low, awb_adjust->WP_TH.WP_THL,sizeof(float)*commV21->division.wpNumTh.lumaValue_len);
342 memcpy(commV21->defaultNightGain,awb_calib_v21->temporalDefaultGain, sizeof(commV21->defaultNightGain));
343 memcpy(commV21->lumaValueMatrix,awb_adjust->LVMatrix, sizeof(commV21->lumaValueMatrix));
344 memcpy(commV21->defaultNightGainWeight,awb_adjust->tempWeight, sizeof(commV21->defaultNightGainWeight));
345 commV21->probCalcDis.proDis_THH = awb_adjust->proDis_THH;
346 commV21->probCalcDis.proDis_THL = awb_adjust->proDis_THL;
347 commV21->probCalcLv.outdoorLumaValThHigh = awb_adjust->proLV_Outdoor_THH;
348 commV21->probCalcLv.outdoorLumaValThLow = awb_adjust->proLV_Outdoor_THL;
349 commV21->probCalcWp.wpNumPercTh= awb_adjust->wpNumPercTh;
350 commV21->probCalcWp.wpNumPercTh2= 0.2;
351 commV21->converged.varThforDamp = awb_adjust->convergedVarTh;
352 commV21->converged.varThforUnDamp= awb_adjust->convergedVarTh;
353 commV21->xyRegionStableSelection.enable = true;
354 commV21->xyRegionStableSelection.wpNumTh.lumaValue_len= awb_adjust->wpNumTh.num;
355 memcpy(commV21->xyRegionStableSelection.wpNumTh.lumaValue,awb_adjust->wpNumTh.lumaValue,sizeof(float)*awb_adjust->wpNumTh.num);
356 commV21->xyRegionStableSelection.wpNumTh.forBigType_len= awb_adjust->wpNumTh.num;
357 memcpy(commV21->xyRegionStableSelection.wpNumTh.forBigType,awb_adjust->wpNumTh.wpNumThForBigType,sizeof(float)*awb_adjust->wpNumTh.num);
358 commV21->xyRegionStableSelection.wpNumTh.forExtraType_len= awb_adjust->wpNumTh.num;
359 memcpy(commV21->xyRegionStableSelection.wpNumTh.forExtraType,awb_adjust->wpNumTh.wpNumThForExtraType,sizeof(float)*awb_adjust->wpNumTh.num);
360 commV21->xyRegionStableSelection.xyTypeListSize = awb_adjust->xyTypeListSize;
361 commV21->xyRegionStableSelection.varianceLumaTh = awb_adjust->varianceLumaTh;
362 memcpy(commV21->weightForNightGainCalc, awb_adjust->temporalGainSetWeight, commV21->weightForNightGainCalc_len*sizeof(unsigned char));
363 commV21->singleColorProces.enable = true;
364 for(int i=0; i<commV21->singleColorProces.colorBlock_len; i++){
365 commV21->singleColorProces.colorBlock[i].index = awb_calib_v21->sIndSelColor[i];
366 commV21->singleColorProces.colorBlock[i].meanC= awb_calib_v21->sMeanCh[0][i];
367 commV21->singleColorProces.colorBlock[i].meanH= awb_calib_v21->sMeanCh[1][i];
368 }
369 for(int i=0; i<commV21->singleColorProces.lsUsedForEstimation_len; i++){
370 strcpy(commV21->singleColorProces.lsUsedForEstimation[i].name, awb_calib_v21->sNameIllEst[i]);
371 commV21->singleColorProces.lsUsedForEstimation[i].RGain= awb_calib_v21->srGain[i];
372 commV21->singleColorProces.lsUsedForEstimation[i].BGain= awb_calib_v21->sbGain[i];
373 }
374 commV21->singleColorProces.alpha= awb_calib_v21->sAlpha;
375 memcpy(commV21->lineRgBg,awb_calib_v21->lineRgBg,sizeof(commV21->lineRgBg));
376 memcpy(commV21->lineRgProjCCT,awb_calib_v21->lineRgProjCCT,sizeof(commV21->lineRgProjCCT));
377 commV21->chrAdpttAdj.enable = awb_adjust->ca_enable;
378 commV21->chrAdpttAdj.laCalcFactor = awb_adjust->ca_LACalcFactor;
379 memcpy(commV21->chrAdpttAdj.targetGain, awb_calib_v21->ca_targetGain, sizeof(commV21->chrAdpttAdj.targetGain));
380 commV21->remosaicCfg.enable = awb_adjust->remosaic_cfg.enable;
381 commV21->remosaicCfg.applyInvWbGainEnable= true;
382 memcpy(commV21->remosaicCfg.sensorWbGain, awb_adjust->remosaic_cfg.sensor_awb_gain, sizeof(commV21->remosaicCfg.sensorWbGain));
383 memcpy(&commV21->wbGainOffset, &awb_adjust->wbGainOffset, sizeof(commV21->wbGainOffset));
384
385 }
386
387
CalibV2AwbV20Free(CamCalibDbV2Context_t * calibV2)388 void CalibV2AwbV20Free(CamCalibDbV2Context_t *calibV2)
389 {
390 CalibDbV2_Wb_Para_V20_t* wb_v20 =
391 (CalibDbV2_Wb_Para_V20_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v20));
392 if(wb_v20 == NULL)
393 return;
394
395 CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV20 = &wb_v20->autoExtPara;
396 CalibDbV2_Wb_Awb_Para_V20_t* autoParaV20 = &wb_v20->autoPara;
397 free(commV20->lightSourceForFirstFrame);
398 free(commV20->wbGainClip.cct);
399 free(commV20->wbGainClip.cri_bound_up);
400 free(commV20->wbGainClip.cri_bound_low);
401 free(commV20->singleColorProces.colorBlock);
402 for(int i=0;i<commV20->singleColorProces.lsUsedForEstimation_len;i++){
403 free(commV20->singleColorProces.lsUsedForEstimation[i].name);
404 }
405 free(commV20->singleColorProces.lsUsedForEstimation);
406 free(commV20->tolerance.toleranceValue);
407 free(commV20->tolerance.lumaValue);
408 free(commV20->runInterval.intervalValue);
409 free(commV20->runInterval.lumaValue);
410 for(int i=0;i<commV20->wbGainAdjust.lutAll_len;i++){
411 free(commV20->wbGainAdjust.lutAll[i].ct_lut_out);
412 free(commV20->wbGainAdjust.lutAll[i].cri_lut_out);
413 }
414 free(commV20->wbGainAdjust.lutAll);
415 free(commV20->weightForNightGainCalc);
416 free(commV20->division.wpNumTh.high);
417 free(commV20->division.wpNumTh.low);
418 free(commV20->division.wpNumTh.lumaValue);
419 free(commV20->xyRegionStableSelection.wpNumTh.lumaValue);
420 free(commV20->xyRegionStableSelection.wpNumTh.forBigType);
421 free(commV20->xyRegionStableSelection.wpNumTh.forExtraType);
422 for(int i=0;i<autoParaV20->lsUsedForYuvDet_len;i++){
423 free(autoParaV20->lsUsedForYuvDet[i]);
424 }
425 free(autoParaV20->lsUsedForYuvDet);
426 for(int i=0;i<autoParaV20->lightSources_len;i++){
427 free(autoParaV20->lightSources[i].name);
428 }
429 free(autoParaV20->lightSources);
430 free(autoParaV20->limitRange.lumaValue);
431 free(autoParaV20->limitRange.maxB);
432 free(autoParaV20->limitRange.maxR);
433 free(autoParaV20->limitRange.maxG);
434 free(autoParaV20->limitRange.maxY);
435 free(autoParaV20->limitRange.minB);
436 free(autoParaV20->limitRange.minR);
437 free(autoParaV20->limitRange.minG);
438 free(autoParaV20->limitRange.minY);
439 }
440
convertCalib2calibV20(const CamCalibDbContext_t * calib,CamCalibDbV2Context_t * calibV2)441 void convertCalib2calibV20(const CamCalibDbContext_t *calib,CamCalibDbV2Context_t *calibV2)
442 {
443 //malloc
444 const CalibDb_Awb_Calib_Para_V200_t *awb_calib_v20 = NULL;
445
446 list_head *awb_calib_para_list =
447 (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_calib_para_v200);
448
449 #ifdef RKAIQ_ENABLE_PARSER_V1
450 if (awb_calib_para_list)
451 GetAwbProfileFromAwbCalibV200ListByIdx(awb_calib_para_list, 0, &awb_calib_v20);
452 #else
453 return;
454 #endif
455
456 const CalibDb_Awb_Adjust_Para_t *awb_adjust = NULL;
457
458 list_head *awb_adjust_list =
459 (list_head*)CALIBDB_GET_MODULE_PTR((void*)calib, awb_adjust_para);
460
461 if (awb_adjust_list)
462 GetAwbProfileFromAwbAdjustListByIdx(awb_adjust_list, 0, &awb_adjust);
463 else
464 return;
465
466 CalibDbV2_Wb_Para_V20_t* wb_v20 =
467 (CalibDbV2_Wb_Para_V20_t*)(CALIBDBV2_GET_MODULE_PTR(calibV2, wb_v20));
468 memset(wb_v20, 0, sizeof(CalibDbV2_Wb_Para_V20_t));
469 CalibDbV2_Wb_Awb_Ext_Com_Para_t *commV20 = &wb_v20->autoExtPara;
470 CalibDbV2_Wb_Awb_Para_V20_t* autoParaV20 = &wb_v20->autoPara;
471 commV20->lightSourceForFirstFrame= (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
472 commV20->wbGainClip.cct_len = awb_calib_v20->cct_clip_cfg.grid_num;
473 commV20->wbGainClip.cri_bound_up_len = awb_calib_v20->cct_clip_cfg.grid_num;
474 commV20->wbGainClip.cri_bound_low_len = awb_calib_v20->cct_clip_cfg.grid_num;
475 commV20->wbGainClip.cct = (float*)malloc(sizeof(float) * commV20->wbGainClip.cct_len);
476 commV20->wbGainClip.cri_bound_up = (float*)malloc(sizeof(float) * commV20->wbGainClip.cct_len);
477 commV20->wbGainClip.cri_bound_low = (float*)malloc(sizeof(float) * commV20->wbGainClip.cct_len);
478 commV20->singleColorProces.colorBlock_len = awb_calib_v20->sSelColorNUM;
479 commV20->singleColorProces.lsUsedForEstimation_len = awb_calib_v20->sIllEstNum;
480 commV20->singleColorProces.colorBlock = (CalibDbV2_Awb_Sgc_Cblk_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Cblk_t)*commV20->singleColorProces.colorBlock_len);
481 commV20->singleColorProces.lsUsedForEstimation = (CalibDbV2_Awb_Sgc_Ls_t*)malloc(sizeof(CalibDbV2_Awb_Sgc_Ls_t)*commV20->singleColorProces.lsUsedForEstimation_len);
482 for(int i=0;i<commV20->singleColorProces.lsUsedForEstimation_len;i++){
483 commV20->singleColorProces.lsUsedForEstimation[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
484 }
485 commV20->tolerance.lumaValue_len = awb_adjust->tolerance.num;
486 commV20->tolerance.toleranceValue_len = awb_adjust->tolerance.num;
487 commV20->tolerance.toleranceValue = (float*)malloc(sizeof(float)*commV20->tolerance.toleranceValue_len);
488 commV20->tolerance.lumaValue= (float*)malloc(sizeof(float)*commV20->tolerance.lumaValue_len);
489 commV20->runInterval.lumaValue_len = awb_adjust->runInterval.num;
490 commV20->runInterval.intervalValue_len= awb_adjust->runInterval.num;
491 commV20->runInterval.intervalValue = (float*)malloc(sizeof(float)*commV20->runInterval.intervalValue_len);
492 commV20->runInterval.lumaValue= (float*)malloc(sizeof(float)*commV20->runInterval.lumaValue_len);
493 commV20->wbGainAdjust.lutAll_len = awb_adjust->cct_lut_cfg_num;
494 commV20->wbGainAdjust.lutAll = (CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t*)malloc(sizeof(CalibDbV2_Awb_Cct_Lut_Cfg_Lv_t)*commV20->wbGainAdjust.lutAll_len);
495 for(int i=0;i<commV20->wbGainAdjust.lutAll_len;i++){
496 commV20->wbGainAdjust.lutAll[i].ct_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num * awb_adjust->cct_lut_cfg[0].cri_grid_num;
497 commV20->wbGainAdjust.lutAll[i].ct_lut_out = (float*)malloc(sizeof(float)*commV20->wbGainAdjust.lutAll[i].ct_lut_out_len);
498 commV20->wbGainAdjust.lutAll[i].cri_lut_out_len = awb_adjust->cct_lut_cfg[0].ct_grid_num * awb_adjust->cct_lut_cfg[0].cri_grid_num;
499 commV20->wbGainAdjust.lutAll[i].cri_lut_out = (float*)malloc(sizeof(float)*commV20->wbGainAdjust.lutAll[i].cri_lut_out_len);
500 }
501 commV20->weightForNightGainCalc_len = 4;
502 commV20->weightForNightGainCalc = (unsigned char*)malloc(sizeof(unsigned char)*commV20->weightForNightGainCalc_len);
503 autoParaV20->lsUsedForYuvDet_len = 7;
504 autoParaV20->lsUsedForYuvDet = (char**)malloc(sizeof(char*)*autoParaV20->lsUsedForYuvDet_len);
505 for(int i=0;i<autoParaV20->lsUsedForYuvDet_len;i++){
506 autoParaV20->lsUsedForYuvDet[i] = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
507 }
508 autoParaV20->lightSources_len = 7;
509 autoParaV20->lightSources = (CalibDbV2_Awb_Light_V20_t*)malloc(sizeof(CalibDbV2_Awb_Light_V20_t)*autoParaV20->lightSources_len);
510 for(int i=0;i<autoParaV20->lightSources_len;i++){
511 autoParaV20->lightSources[i].name = (char*)malloc(sizeof(char)*CALD_AWB_ILLUMINATION_NAME);
512 }
513 autoParaV20->limitRange.lumaValue = (float*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(float));
514 autoParaV20->limitRange.maxB= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
515 autoParaV20->limitRange.maxR= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
516 autoParaV20->limitRange.maxG= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
517 autoParaV20->limitRange.maxY= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
518 autoParaV20->limitRange.minB= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
519 autoParaV20->limitRange.minR= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
520 autoParaV20->limitRange.minG= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
521 autoParaV20->limitRange.minY= (unsigned short*)malloc(awb_calib_v20->limitRange.lumaNum *sizeof(unsigned short));
522 commV20->division.wpNumTh.high = (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
523 commV20->division.wpNumTh.low= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
524 commV20->division.wpNumTh.lumaValue= (float *)malloc(awb_adjust->WP_TH.num*sizeof(float));
525 commV20->xyRegionStableSelection.wpNumTh.lumaValue = (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
526 commV20->xyRegionStableSelection.wpNumTh.forBigType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
527 commV20->xyRegionStableSelection.wpNumTh.forExtraType= (float *)malloc(awb_adjust->wpNumTh.num*sizeof(float));
528 //coppy value
529 CalibDbV2_Wb_Para_t *control = &wb_v20->control;
530 control->byPass = 0;
531 control->mode = CALIB_WB_MODE_AUTO;
532 CalibDbV2_Wb_Mwb_Para_t *manualPara = &wb_v20->manualPara;
533 manualPara->mode = CALIB_MWB_MODE_SCENE;
534 manualPara->cfg.scene = CALIB_WB_SCENE_CLOUDY_DAYLIGHT;
535 manualPara->cfg.cct.CCT = 5000;
536 manualPara->cfg.cct.CCRI = 0;
537 memcpy(manualPara->cfg.mwbGain, awb_calib_v20->standardGainValue[0],sizeof(manualPara->cfg.mwbGain));
538 autoParaV20->hdrPara.frameChoose = awb_calib_v20->hdrFrameChoose;
539 autoParaV20->hdrPara.frameChooseMode= (CalibDbV2_Awb_Hdr_Fr_Ch_Mode_t)awb_calib_v20->hdrFrameChooseMode;
540 autoParaV20->lscBypassEnable = awb_calib_v20->lscBypEnable;
541 autoParaV20->uvDetectionEnable = awb_calib_v20->uvDetectionEnable;
542 autoParaV20->xyDetectionEnable= awb_calib_v20->xyDetectionEnable;
543 autoParaV20->yuvDetectionEnable = awb_calib_v20->yuvDetectionEnable;
544 for(int i=0;i<autoParaV20->lsUsedForYuvDet_len;i++){
545 strcpy(autoParaV20->lsUsedForYuvDet[i],awb_calib_v20->lsUsedForYuvDet[i]);
546 }
547 autoParaV20->yuvDetRef_u = awb_calib_v20->yuv3DRange_param[0].ref_u;
548 autoParaV20->downScaleMode = (CalibDbV2_Awb_Down_Scale_Mode_t)awb_calib_v20->dsMode;
549 autoParaV20->blkMeasureMode = (CalibDbV2_Awb_Blk_Stat_V20_t)awb_calib_v20->blkMeasureMode;
550 autoParaV20->mainWindow.mode = (CalibDb_Window_Mode_t)awb_calib_v20->measeureWindow.mode;
551 float window[4] ={0,0,1,1};
552 memcpy(autoParaV20->mainWindow.window, window,sizeof(window));
553 bool flag = false;
554 if(autoParaV20->mainWindow.mode != CALIB_AWB_WINDOW_CFG_AUTO){
555 char resName[CALD_AWB_RES_NAME];
556 for(int i=0;i<awb_calib_v20->measeureWindow.resNum;i++){
557 char* p;
558 float width = 0;
559 float height =0;
560 strcpy(resName,awb_calib_v20->measeureWindow.resName[i]);
561 p = strtok(resName, "x");
562 if(p==NULL){
563 printf("parse resName %s error0,\n",awb_calib_v20->measeureWindow.resName[i]);
564 continue;
565 }
566 width = atoi(p);
567 p = strtok(NULL, " ");
568 if(p==NULL){
569 printf("parse resName %s error1,\n",awb_calib_v20->measeureWindow.resName[i]);
570 continue;
571 }
572 height = atoi(p);
573 if (height*width>0.001){
574 if((float)awb_calib_v20->measeureWindow.window[i][0]/width > window[0]){
575 window[0] = awb_calib_v20->measeureWindow.window[i][0]/width;
576 flag = true;
577 }
578 if((float)awb_calib_v20->measeureWindow.window[i][1]/height > window[1]){
579 window[1] = awb_calib_v20->measeureWindow.window[i][1]/height;
580 flag = true;
581 }
582 if((float)awb_calib_v20->measeureWindow.window[i][2]/width < window[2]){
583 window[2] = awb_calib_v20->measeureWindow.window[i][2]/width;
584 flag = true;
585 }
586 if((float)awb_calib_v20->measeureWindow.window[i][3]/height < window[3]){
587 window[3] = awb_calib_v20->measeureWindow.window[i][3]/height;
588 flag = true;
589 }
590 }else{
591 printf("parse resName %s error2,\n",awb_calib_v20->measeureWindow.resName[i]);
592 }
593 }
594 }
595 if (flag){
596 printf("please check parse mainWindow.window (ratio) is %f,%f,%f,%f\n",window[0],window[1],window[2],window[3]);
597
598 }
599 autoParaV20->limitRange.lumaValue_len= awb_calib_v20->limitRange.lumaNum;
600 memcpy(autoParaV20->limitRange.lumaValue,awb_calib_v20->limitRange.lumaValue,autoParaV20->limitRange.lumaValue_len*sizeof(float));
601 autoParaV20->limitRange.maxB_len= awb_calib_v20->limitRange.lumaNum;
602 memcpy(autoParaV20->limitRange.maxB,awb_calib_v20->limitRange.maxB,autoParaV20->limitRange.maxB_len*sizeof(unsigned short));
603 autoParaV20->limitRange.maxR_len= awb_calib_v20->limitRange.lumaNum;
604 memcpy(autoParaV20->limitRange.maxR,awb_calib_v20->limitRange.maxR,autoParaV20->limitRange.maxR_len*sizeof(unsigned short));
605 autoParaV20->limitRange.maxG_len= awb_calib_v20->limitRange.lumaNum;
606 memcpy(autoParaV20->limitRange.maxG,awb_calib_v20->limitRange.maxG,autoParaV20->limitRange.maxG_len*sizeof(unsigned short));
607 autoParaV20->limitRange.maxY_len= awb_calib_v20->limitRange.lumaNum;
608 memcpy(autoParaV20->limitRange.maxY,awb_calib_v20->limitRange.maxY,autoParaV20->limitRange.maxY_len*sizeof(unsigned short));
609 autoParaV20->limitRange.minB_len= awb_calib_v20->limitRange.lumaNum;
610 memcpy(autoParaV20->limitRange.minB,awb_calib_v20->limitRange.minB,autoParaV20->limitRange.minB_len*sizeof(unsigned short));
611 autoParaV20->limitRange.minR_len= awb_calib_v20->limitRange.lumaNum;
612 memcpy(autoParaV20->limitRange.minR,awb_calib_v20->limitRange.minR,autoParaV20->limitRange.minR_len*sizeof(unsigned short));
613 autoParaV20->limitRange.minG_len= awb_calib_v20->limitRange.lumaNum;
614 memcpy(autoParaV20->limitRange.minG,awb_calib_v20->limitRange.minG,autoParaV20->limitRange.minG_len*sizeof(unsigned short));
615 autoParaV20->limitRange.minY_len= awb_calib_v20->limitRange.lumaNum;
616 memcpy(autoParaV20->limitRange.minY,awb_calib_v20->limitRange.minY,autoParaV20->limitRange.minY_len*sizeof(unsigned short));
617 memcpy(autoParaV20->rgb2TcsPara.rotationMat, awb_calib_v20->rgb2tcs_param.rotationMat, sizeof(autoParaV20->rgb2TcsPara.rotationMat));
618 memcpy(autoParaV20->rgb2TcsPara.pseudoLuminanceWeight, awb_calib_v20->rgb2tcs_param.pseudoLuminanceWeight, sizeof(autoParaV20->rgb2TcsPara.pseudoLuminanceWeight));
619 autoParaV20->multiWindow.enable = awb_calib_v20->multiwindow_en;
620 autoParaV20->multiWindow.multiwindowMode = (CalibDbV2_Awb_Mul_Win_Mode_t)awb_adjust->multiwindowMode;
621 for(int i=0;i<CALD_AWB_WINDOW_NUM_MAX;i++){
622 for(int j=0;j<4;j++){
623 autoParaV20->multiWindow.window[i][j]= awb_calib_v20->multiwindow[i][j];
624 }
625 }
626 for(int i=0;i<CALD_AWB_EXCRANGE_NUM_MAX;i++){
627 autoParaV20->extraWpRange[i].domain = (CalibDbV2_Awb_Ext_Range_Dom_t)awb_calib_v20->excludeWpRange[i].domain;
628 if(awb_calib_v20->excludeWpRange[i].mode != CALIB_AWB_EXCLUDE_WP_MODE
629 && awb_calib_v20->excludeWpRange[i].mode != CALIB_AWB_ETR_LIGHT_SOUR_MODE ){
630 autoParaV20->extraWpRange[i].mode = CALIB_AWB_EXCLUDE_WP_MODE;
631 }else{
632 autoParaV20->extraWpRange[i].mode = (CalibDbV2_Awb_Ext_Range_Mode_t)awb_calib_v20->excludeWpRange[i].mode;
633 }
634 autoParaV20->extraWpRange[i].region[0] = awb_calib_v20->excludeWpRange[i].xu[0];
635 autoParaV20->extraWpRange[i].region[1] = awb_calib_v20->excludeWpRange[i].xu[1];
636 autoParaV20->extraWpRange[i].region[2] = awb_calib_v20->excludeWpRange[i].yv[0];
637 autoParaV20->extraWpRange[i].region[3] = awb_calib_v20->excludeWpRange[i].yv[1];
638 }
639 for(int i=0;i<autoParaV20->lightSources_len;i++){
640 strcpy(autoParaV20->lightSources[i].name, awb_calib_v20->lightName[i]);
641 autoParaV20->lightSources[i].doorType = (CalibDbV2_Awb_DoorType_t)awb_calib_v20->doorType[i];
642 memcpy(autoParaV20->lightSources[i].standardGainValue, awb_calib_v20->standardGainValue[i],sizeof(autoParaV20->lightSources[i].standardGainValue));
643 memcpy(autoParaV20->lightSources[i].uvRegion.u, awb_calib_v20->uvRange_param[i].pu_region,sizeof(autoParaV20->lightSources[i].uvRegion.u));
644 memcpy(autoParaV20->lightSources[i].uvRegion.v, awb_calib_v20->uvRange_param[i].pv_region,sizeof(autoParaV20->lightSources[i].uvRegion.v));
645 autoParaV20->lightSources[i].xyRegion.normal[0] = awb_calib_v20->xyRangeLight[i].NorrangeX[0];
646 autoParaV20->lightSources[i].xyRegion.normal[1] = awb_calib_v20->xyRangeLight[i].NorrangeX[1];
647 autoParaV20->lightSources[i].xyRegion.normal[2] = awb_calib_v20->xyRangeLight[i].NorrangeY[0];
648 autoParaV20->lightSources[i].xyRegion.normal[3] = awb_calib_v20->xyRangeLight[i].NorrangeY[1];
649 autoParaV20->lightSources[i].xyRegion.big[0] = awb_calib_v20->xyRangeLight[i].SperangeX[0];
650 autoParaV20->lightSources[i].xyRegion.big[1] = awb_calib_v20->xyRangeLight[i].SperangeX[1];
651 autoParaV20->lightSources[i].xyRegion.big[2] = awb_calib_v20->xyRangeLight[i].SperangeY[0];
652 autoParaV20->lightSources[i].xyRegion.big[3] = awb_calib_v20->xyRangeLight[i].SperangeY[1];
653 autoParaV20->lightSources[i].xyRegion.small[0] = awb_calib_v20->xyRangeLight[i].SmalrangeX[0];
654 autoParaV20->lightSources[i].xyRegion.small[1] = awb_calib_v20->xyRangeLight[i].SmalrangeX[1];
655 autoParaV20->lightSources[i].xyRegion.small[2] = awb_calib_v20->xyRangeLight[i].SmalrangeY[0];
656 autoParaV20->lightSources[i].xyRegion.small[3] = awb_calib_v20->xyRangeLight[i].SmalrangeY[1];
657 autoParaV20->lightSources[i].yuvRegion.b_uv = awb_calib_v20->yuv3DRange_param[i].b_uv;
658 autoParaV20->lightSources[i].yuvRegion.slope_inv_neg_uv= awb_calib_v20->yuv3DRange_param[i].slope_inv_neg_uv;
659 autoParaV20->lightSources[i].yuvRegion.slope_factor_uv= awb_calib_v20->yuv3DRange_param[i].slope_factor_uv;
660 autoParaV20->lightSources[i].yuvRegion.slope_ydis= awb_calib_v20->yuv3DRange_param[i].slope_ydis;
661 autoParaV20->lightSources[i].yuvRegion.b_ydis= awb_calib_v20->yuv3DRange_param[i].b_ydis;
662 autoParaV20->lightSources[i].yuvRegion.ref_v= awb_calib_v20->yuv3DRange_param[i].ref_v;
663 memcpy(autoParaV20->lightSources[i].yuvRegion.dis, awb_calib_v20->yuv3DRange_param[i].dis, sizeof(autoParaV20->lightSources[i].yuvRegion.dis));
664 memcpy(autoParaV20->lightSources[i].yuvRegion.th, awb_calib_v20->yuv3DRange_param[i].th, sizeof(autoParaV20->lightSources[i].yuvRegion.th));
665 memcpy(autoParaV20->lightSources[i].staWeight, awb_adjust->awb_light_info[i].staWeight, sizeof(autoParaV20->lightSources[i].staWeight));
666 autoParaV20->lightSources[i].dayGainLvThSet[0] = awb_adjust->awb_light_info[i].spatialGain_LV_THL;
667 autoParaV20->lightSources[i].dayGainLvThSet[1] = awb_adjust->awb_light_info[i].spatialGain_LV_THH;
668 memcpy(autoParaV20->lightSources[i].defaultDayGainLow,awb_calib_v20->spatialGain_L, sizeof(awb_calib_v20->spatialGain_L));
669 memcpy(autoParaV20->lightSources[i].defaultDayGainHigh,awb_calib_v20->spatialGain_H, sizeof(awb_calib_v20->spatialGain_H));
670 autoParaV20->lightSources[i].xyType2Enable = awb_adjust->awb_light_info[i].xyType2Enable;
671 }
672
673 strcpy(commV20->lightSourceForFirstFrame, awb_adjust->lsForFirstFrame);
674 memcpy(commV20->tolerance.lumaValue, awb_adjust->tolerance.LV,sizeof(float)*commV20->tolerance.lumaValue_len);
675 memcpy(commV20->tolerance.toleranceValue, awb_adjust->tolerance.value,sizeof(float)*commV20->tolerance.toleranceValue_len);
676 memcpy(commV20->runInterval.lumaValue, awb_adjust->runInterval.LV,sizeof(float)*commV20->runInterval.lumaValue_len);
677 memcpy(commV20->runInterval.intervalValue, awb_adjust->runInterval.value,sizeof(float)*commV20->runInterval.intervalValue_len);
678 commV20->dampFactor.dFStep = awb_adjust->dFStep;
679 commV20->dampFactor.dFMin = awb_adjust->dFMin;
680 commV20->dampFactor.dFMax = awb_adjust->dFMax;
681 commV20->dampFactor.lvIIRsize = awb_adjust->LvIIRsize;
682 commV20->dampFactor.lvVarTh = awb_adjust->LvVarTh;
683 commV20->wbGainAdjust.enable = awb_adjust->wbGainAdjustEn;
684 for(int i=0; i<commV20->wbGainAdjust.lutAll_len;i++){
685 commV20->wbGainAdjust.lutAll[i].lumaValue = awb_adjust->cct_lut_cfg[i].lv;
686 commV20->wbGainAdjust.lutAll[i].ct_grid_num = awb_adjust->cct_lut_cfg[0].ct_grid_num;
687 commV20->wbGainAdjust.lutAll[i].cri_grid_num = awb_adjust->cct_lut_cfg[0].cri_grid_num;
688 memcpy(commV20->wbGainAdjust.lutAll[i].ct_in_range, awb_adjust->cct_lut_cfg[0].ct_range,sizeof(commV20->wbGainAdjust.lutAll[i].ct_in_range));
689 memcpy(commV20->wbGainAdjust.lutAll[i].cri_in_range, awb_adjust->cct_lut_cfg[0].cri_range,sizeof(commV20->wbGainAdjust.lutAll[i].cri_in_range));
690 memcpy(commV20->wbGainAdjust.lutAll[i].ct_lut_out,awb_adjust->cct_lut_cfg[i].ct_lut_out,sizeof(float)*commV20->wbGainAdjust.lutAll[i].ct_lut_out_len);
691 memcpy(commV20->wbGainAdjust.lutAll[i].cri_lut_out,awb_adjust->cct_lut_cfg[i].cri_lut_out,sizeof(float)*commV20->wbGainAdjust.lutAll[i].cri_lut_out_len);
692 }
693 commV20->wbGainDaylightClip.enable= awb_calib_v20->wbGainDaylightClipEn;
694 commV20->wbGainDaylightClip.outdoor_cct_min = awb_calib_v20->cct_clip_cfg.outdoor_cct_min;
695 commV20->wbGainClip.enable= awb_calib_v20->wbGainClipEn;
696 memcpy(commV20->wbGainClip.cct, awb_calib_v20->cct_clip_cfg.cct,sizeof(float)*commV20->wbGainClip.cct_len);
697 memcpy(commV20->wbGainClip.cri_bound_low, awb_calib_v20->cct_clip_cfg.cri_bound_low,sizeof(float)*commV20->wbGainClip.cri_bound_low_len);
698 memcpy(commV20->wbGainClip.cri_bound_up, awb_calib_v20->cct_clip_cfg.cri_bound_up,sizeof(float)*commV20->wbGainClip.cri_bound_up_len);
699 commV20->division.lumaValThLow= awb_adjust->LV_THL;
700 commV20->division.lumaValThLow2= awb_adjust->LV_THL2;
701 commV20->division.lumaValThHigh= awb_adjust->LV_THH;
702 commV20->division.lumaValThHigh2= awb_adjust->LV_THH2;
703 commV20->division.wpNumTh.lumaValue_len = awb_adjust->WP_TH.num;
704 memcpy(commV20->division.wpNumTh.lumaValue, awb_adjust->WP_TH.lumaValue,sizeof(float)*commV20->division.wpNumTh.lumaValue_len);
705 commV20->division.wpNumTh.high_len = awb_adjust->WP_TH.num;
706 memcpy(commV20->division.wpNumTh.high, awb_adjust->WP_TH.WP_THH,sizeof(float)*commV20->division.wpNumTh.lumaValue_len);
707 commV20->division.wpNumTh.low_len = awb_adjust->WP_TH.num;
708 memcpy(commV20->division.wpNumTh.low, awb_adjust->WP_TH.WP_THL,sizeof(float)*commV20->division.wpNumTh.lumaValue_len);
709 memcpy(commV20->defaultNightGain,awb_calib_v20->temporalDefaultGain, sizeof(commV20->defaultNightGain));
710 memcpy(commV20->lumaValueMatrix,awb_adjust->LVMatrix, sizeof(commV20->lumaValueMatrix));
711 memcpy(commV20->defaultNightGainWeight,awb_adjust->tempWeight, sizeof(commV20->defaultNightGainWeight));
712 commV20->probCalcDis.proDis_THH = awb_adjust->proDis_THH;
713 commV20->probCalcDis.proDis_THL = awb_adjust->proDis_THL;
714 commV20->probCalcLv.outdoorLumaValThHigh = awb_adjust->proLV_Outdoor_THH;
715 commV20->probCalcLv.outdoorLumaValThLow = awb_adjust->proLV_Outdoor_THL;
716 commV20->probCalcWp.wpNumPercTh= awb_adjust->wpNumPercTh;
717 commV20->probCalcWp.wpNumPercTh2= 0.2;
718 commV20->converged.varThforDamp = awb_adjust->convergedVarTh;
719 commV20->converged.varThforUnDamp= awb_adjust->convergedVarTh;
720 commV20->xyRegionStableSelection.enable = true;
721 commV20->xyRegionStableSelection.wpNumTh.lumaValue_len= awb_adjust->wpNumTh.num;
722 memcpy(commV20->xyRegionStableSelection.wpNumTh.lumaValue,awb_adjust->wpNumTh.lumaValue,sizeof(float)*awb_adjust->wpNumTh.num);
723 commV20->xyRegionStableSelection.wpNumTh.forBigType_len= awb_adjust->wpNumTh.num;
724 memcpy(commV20->xyRegionStableSelection.wpNumTh.forBigType,awb_adjust->wpNumTh.wpNumThForBigType,sizeof(float)*awb_adjust->wpNumTh.num);
725 commV20->xyRegionStableSelection.wpNumTh.forExtraType_len= awb_adjust->wpNumTh.num;
726 memcpy(commV20->xyRegionStableSelection.wpNumTh.forExtraType,awb_adjust->wpNumTh.wpNumThForExtraType,sizeof(float)*awb_adjust->wpNumTh.num);
727 commV20->xyRegionStableSelection.xyTypeListSize = awb_adjust->xyTypeListSize;
728 commV20->xyRegionStableSelection.varianceLumaTh = awb_adjust->varianceLumaTh;
729 memcpy(commV20->weightForNightGainCalc, awb_adjust->temporalGainSetWeight, commV20->weightForNightGainCalc_len*sizeof(unsigned char));
730 commV20->singleColorProces.enable = true;
731 for(int i=0; i<commV20->singleColorProces.colorBlock_len; i++){
732 commV20->singleColorProces.colorBlock[i].index = awb_calib_v20->sIndSelColor[i];
733 commV20->singleColorProces.colorBlock[i].meanC= awb_calib_v20->sMeanCh[0][i];
734 commV20->singleColorProces.colorBlock[i].meanH= awb_calib_v20->sMeanCh[1][i];
735 }
736 for(int i=0; i<commV20->singleColorProces.lsUsedForEstimation_len; i++){
737 strcpy(commV20->singleColorProces.lsUsedForEstimation[i].name, awb_calib_v20->sNameIllEst[i]);
738 commV20->singleColorProces.lsUsedForEstimation[i].RGain= awb_calib_v20->srGain[i];
739 commV20->singleColorProces.lsUsedForEstimation[i].BGain= awb_calib_v20->sbGain[i];
740 }
741 commV20->singleColorProces.alpha= awb_calib_v20->sAlpha;
742 memcpy(commV20->lineRgBg,awb_calib_v20->lineRgBg,sizeof(commV20->lineRgBg));
743 memcpy(commV20->lineRgProjCCT,awb_calib_v20->lineRgProjCCT,sizeof(commV20->lineRgProjCCT));
744 commV20->chrAdpttAdj.enable = awb_adjust->ca_enable;
745 commV20->chrAdpttAdj.laCalcFactor = awb_adjust->ca_LACalcFactor;
746 memcpy(commV20->chrAdpttAdj.targetGain, awb_calib_v20->ca_targetGain, sizeof(commV20->chrAdpttAdj.targetGain));
747 commV20->remosaicCfg.enable = awb_adjust->remosaic_cfg.enable;
748 commV20->remosaicCfg.applyInvWbGainEnable= false;
749 memcpy(commV20->remosaicCfg.sensorWbGain, awb_adjust->remosaic_cfg.sensor_awb_gain, sizeof(commV20->remosaicCfg.sensorWbGain));
750 memcpy(&commV20->wbGainOffset, &awb_adjust->wbGainOffset, sizeof(commV20->wbGainOffset));
751
752 }
convertCalib2calibV2(const CamCalibDbContext_t * calib,CamCalibDbV2Context_t * calibV2)753 void convertCalib2calibV2(const CamCalibDbContext_t *calib,CamCalibDbV2Context_t *calibV2)
754 {
755
756 convertCalib2calibV20(calib, calibV2);
757 convertCalib2calibV21(calib, calibV2);
758
759 }
760
761
762
763