1
2 #include "rk_aiq_anr_algo_ynr.h"
3
4 RKAIQ_BEGIN_DECLARE
5
ynr_get_mode_cell_idx_by_name(CalibDb_YNR_2_t * pCalibdb,char * name,int * mode_idx)6 ANRresult_t ynr_get_mode_cell_idx_by_name(CalibDb_YNR_2_t *pCalibdb, char *name, int *mode_idx)
7 {
8 int i = 0;
9 ANRresult_t res = ANR_RET_SUCCESS;
10
11 if(pCalibdb == NULL) {
12 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
13 return ANR_RET_NULL_POINTER;
14 }
15
16 if(name == NULL) {
17 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
18 return ANR_RET_NULL_POINTER;
19 }
20
21 if(mode_idx == NULL) {
22 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
23 return ANR_RET_NULL_POINTER;
24 }
25
26 if(pCalibdb->mode_num < 1) {
27 LOGE_ANR("%s(%d): mfnr mode cell num is zero\n", __FUNCTION__, __LINE__);
28 return ANR_RET_NULL_POINTER;
29 }
30
31 for(i = 0; i < pCalibdb->mode_num; i++) {
32 if(strncmp(name, pCalibdb->mode_cell[i].name, sizeof(pCalibdb->mode_cell[i].name)) == 0) {
33 break;
34 }
35 }
36
37 if(i < pCalibdb->mode_num) {
38 *mode_idx = i;
39 res = ANR_RET_SUCCESS;
40 } else {
41 *mode_idx = 0;
42 res = ANR_RET_FAILURE;
43 }
44
45 LOGD_ANR("%s:%d mode_name:%s mode_idx:%d i:%d \n", __FUNCTION__, __LINE__, name, *mode_idx, i);
46 return res;
47
48 }
49
50
ynr_get_setting_idx_by_name(CalibDb_YNR_2_t * pCalibdb,char * name,int mode_idx,int * setting_idx)51 ANRresult_t ynr_get_setting_idx_by_name(CalibDb_YNR_2_t *pCalibdb, char *name, int mode_idx, int *setting_idx)
52 {
53 int i = 0;
54 ANRresult_t res = ANR_RET_SUCCESS;
55
56 if(pCalibdb == NULL) {
57 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
58 return ANR_RET_NULL_POINTER;
59 }
60
61 if(name == NULL) {
62 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
63 return ANR_RET_NULL_POINTER;
64 }
65
66 if(setting_idx == NULL) {
67 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
68 return ANR_RET_NULL_POINTER;
69 }
70
71 for(i = 0; i < CALIBDB_NR_SHARP_SETTING_LEVEL; i++) {
72 if(strncmp(name, pCalibdb->mode_cell[mode_idx].setting[i].snr_mode, sizeof(pCalibdb->mode_cell[mode_idx].setting[i].snr_mode)) == 0) {
73 break;
74 }
75 }
76
77 if(i < CALIBDB_NR_SHARP_SETTING_LEVEL) {
78 *setting_idx = i;
79 res = ANR_RET_SUCCESS;
80 } else {
81 *setting_idx = 0;
82 res = ANR_RET_FAILURE;
83 }
84
85 LOGD_ANR("%s:%d snr_name:%s snr_idx:%d i:%d \n", __FUNCTION__, __LINE__, name, *setting_idx, i);
86 return res;
87
88 }
89
ynr_config_setting_param(RKAnr_Ynr_Params_s * pParams,CalibDb_YNR_2_t * pCalibdb,char * param_mode,char * snr_name)90 ANRresult_t ynr_config_setting_param(RKAnr_Ynr_Params_s *pParams, CalibDb_YNR_2_t *pCalibdb, char* param_mode, char* snr_name)
91 {
92 ANRresult_t res = ANR_RET_SUCCESS;
93 int mode_idx = 0;
94 int setting_idx = 0;
95
96 if(pParams == NULL) {
97 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
98 return ANR_RET_NULL_POINTER;
99 }
100
101 if(pCalibdb == NULL) {
102 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
103 return ANR_RET_NULL_POINTER;
104 }
105
106 res = ynr_get_mode_cell_idx_by_name(pCalibdb, param_mode, &mode_idx);
107 if(res != ANR_RET_SUCCESS) {
108 LOGW_ANR("%s(%d): error!!! can't find mode name in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
109 }
110
111 res = ynr_get_setting_idx_by_name(pCalibdb, snr_name, mode_idx, &setting_idx);
112 if(res != ANR_RET_SUCCESS) {
113 LOGW_ANR("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
114 }
115
116 res = init_ynr_params(pParams, pCalibdb, mode_idx, setting_idx);
117
118 return res;
119
120 }
init_ynr_params(RKAnr_Ynr_Params_s * pYnrParams,CalibDb_YNR_2_t * pYnrCalib,int mode_idx,int setting_idx)121 ANRresult_t init_ynr_params(RKAnr_Ynr_Params_s *pYnrParams, CalibDb_YNR_2_t* pYnrCalib, int mode_idx, int setting_idx)
122 {
123 ANRresult_t res = ANR_RET_SUCCESS;
124 int i = 0;
125 int j = 0;
126
127 if(pYnrParams == NULL) {
128 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
129 return ANR_RET_NULL_POINTER;
130 }
131
132 if(pYnrCalib == NULL) {
133 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
134 return ANR_RET_NULL_POINTER;
135 }
136
137 RKAnr_Ynr_Params_Select_t *pParams = pYnrParams->aYnrParamsISO;
138 CalibDb_YNR_ISO_t *pCalibdb = pYnrCalib->mode_cell[mode_idx].setting[setting_idx].ynr_iso;
139
140 short isoCurveSectValue;
141 short isoCurveSectValue1;
142 int bit_shift;
143 int bit_proc;
144 int bit_calib;
145
146 bit_calib = 12;
147 bit_proc = YNR_SIGMA_BITS;
148 bit_shift = bit_calib - bit_proc;
149 isoCurveSectValue = (1 << (bit_calib - ISO_CURVE_POINT_BIT));//rawBit必须大于ISO_CURVE_POINT_BIT
150 isoCurveSectValue1 = (1 << bit_calib);// - 1;//rawBit必须大于ISO_CURVE_POINT_BIT, max use (1 << bit_calib);
151
152 #ifndef RK_SIMULATOR_HW
153 for(j = 0; j < MAX_ISO_STEP; j++) {
154 pParams[j].iso = pCalibdb[j].iso;
155 }
156 #endif
157
158 for(j = 0; j < MAX_ISO_STEP; j++) {
159 for(i = 0; i < WAVELET_LEVEL_NUM; i++) {
160 pParams[j].loFreqNoiseCi[i] = pCalibdb[j].ynr_lci[i];
161 pParams[j].ciISO[i * 3 + 0] = pCalibdb[j].ynr_lhci[i];
162 pParams[j].ciISO[i * 3 + 1] = pCalibdb[j].ynr_hlci[i];
163 pParams[j].ciISO[i * 3 + 2] = pCalibdb[j].ynr_hhci[i];
164 }
165
166 for(i = 0; i < ISO_CURVE_POINT_NUM; i++) {
167 float ave1, ave2, ave3, ave4;
168 if(i == (ISO_CURVE_POINT_NUM - 1)) {
169 ave1 = (float)isoCurveSectValue1;
170 }
171 else {
172 ave1 = (float)(i * isoCurveSectValue);
173 }
174 pParams[j].lumaPoints[i] = (short)ave1;
175 ave2 = ave1 * ave1;
176 ave3 = ave2 * ave1;
177 ave4 = ave3 * ave1;
178 pParams[j].noiseSigma[i] = pCalibdb[j].sigma_curve[0] * ave4
179 + pCalibdb[j].sigma_curve[1] * ave3
180 + pCalibdb[j].sigma_curve[2] * ave2
181 + pCalibdb[j].sigma_curve[3] * ave1
182 + pCalibdb[j].sigma_curve[4];
183 if(pParams[j].noiseSigma[i] < 0) {
184 pParams[j].noiseSigma[i] = 0;
185 }
186 }
187
188 for (i = 0; i < ISO_CURVE_POINT_NUM; i++) {
189 if(bit_shift > 0) {
190 pParams[j].lumaPoints[i] >>= bit_shift;
191 }
192 else {
193 pParams[j].lumaPoints[i] <<= ABS(bit_shift);
194 }
195 }
196
197 for(i = 0; i < WAVELET_LEVEL_NUM; i++) {
198 pParams[j].loFreqDenoiseWeight[i] = pCalibdb[j].denoise_weight[i];
199 pParams[j].loFreqBfScale[i] = pCalibdb[j].lo_bfScale[i];
200 }
201
202 for(i = 0; i < 6; i++) {
203 pParams[j].loFreqLumaNrCurvePoint[i] = pCalibdb[j].lo_lumaPoint[i];
204 pParams[j].loFreqLumaNrCurveRatio[i] = pCalibdb[j].lo_lumaRatio[i];
205 }
206
207 pParams[j].loFreqDenoiseStrength[0] = pCalibdb[j].imerge_ratio;
208 pParams[j].loFreqDenoiseStrength[1] = pCalibdb[j].imerge_bound;
209 pParams[j].loFreqDirectionStrength = pCalibdb[j].lo_directionStrength;
210
211 for(i = 0; i < WAVELET_LEVEL_NUM; i++) {
212 pParams[j].hiFreqDenoiseWeight[i] = pCalibdb[j].hi_denoiseWeight[i];
213 pParams[j].hiFreqBfScale[i] = pCalibdb[j].hi_bfScale[i];
214 pParams[j].hiFreqEdgeSoftness[i] = pCalibdb[j].hwith_d[i];
215 pParams[j].hiFreqSoftThresholdScale[i] = pCalibdb[j].hi_soft_thresh_scale[i];
216 pParams[j].lscGainRatioAdjust[i] = 1.0;
217
218 }
219
220 for(i = 0; i < 6; i++) {
221 pParams[j].hiFreqLumaNrCurvePoint[i] = pCalibdb[j].hi_lumaPoint[i];
222 pParams[j].hiFreqLumaNrCurveRatio[i] = pCalibdb[j].hi_lumaRatio[i];
223 }
224 pParams[j].hiFreqDenoiseStrength = pCalibdb[j].hi_denoiseStrength;
225
226 for(i = 0; i < 7; i++) {
227 pParams[j].radialNoiseCtrPoint[i] = 0;
228 pParams[j].radialNoiseCtrRatio[i] = 1.0;
229 }
230
231 for(i = 0; i < 6; i++) {
232 float tmp = pCalibdb[j].y_luma_point[i];
233 if(bit_shift > 0)
234 tmp /= (1 << bit_shift);
235 else
236 tmp *= (1 << ABS(bit_shift));
237
238 pParams[j].detailThre[i] = tmp;
239 pParams[j].detailThreRatioLevel[0][i] = pCalibdb[j].hgrad_y_level1[i];
240 pParams[j].detailThreRatioLevel[1][i] = pCalibdb[j].hgrad_y_level2[i];
241 pParams[j].detailThreRatioLevel[2][i] = pCalibdb[j].hgrad_y_level3[i];
242 pParams[j].detailThreLevel4[i] = tmp;
243 pParams[j].detailThreRatioLevel4[i] = pCalibdb[j].hgrad_y_level4[i];
244 }
245
246 pParams[j].detailMinAdjDnW = pCalibdb[j].hi_detailMinAdjDnW;
247 pParams[j].waveLetCoeffDeltaHi = 0;
248 pParams[j].waveLetCoeffDeltaLo = 0;
249 pParams[j].hiValueThre = 0;
250 pParams[j].loValueThre = 0;
251 }
252
253 memcpy(pYnrParams->ynr_ver_char, pYnrCalib->version, sizeof(pYnrParams->ynr_ver_char));
254
255 return res;
256 }
257
258
259
ynr_get_setting_idx_by_name_json(CalibDbV2_YnrV1_t * pCalibdb,char * name,int * calib_idx,int * tuning_idx)260 ANRresult_t ynr_get_setting_idx_by_name_json(CalibDbV2_YnrV1_t *pCalibdb, char *name, int *calib_idx, int *tuning_idx)
261 {
262 int i = 0;
263 ANRresult_t res = ANR_RET_SUCCESS;
264
265 if(pCalibdb == NULL) {
266 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
267 return ANR_RET_NULL_POINTER;
268 }
269
270 if(name == NULL) {
271 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
272 return ANR_RET_NULL_POINTER;
273 }
274
275 if(calib_idx == NULL) {
276 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
277 return ANR_RET_NULL_POINTER;
278 }
279
280 if(tuning_idx == NULL) {
281 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
282 return ANR_RET_NULL_POINTER;
283 }
284
285 for(i = 0; i < pCalibdb->TuningPara.Setting_len; i++) {
286 if(strncmp(name, pCalibdb->TuningPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
287 break;
288 }
289 }
290
291 if(i < pCalibdb->TuningPara.Setting_len) {
292 *tuning_idx = i;
293 } else {
294 *tuning_idx = 0;
295 }
296
297 for(i = 0; i < pCalibdb->CalibPara.Setting_len; i++) {
298 if(strncmp(name, pCalibdb->CalibPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
299 break;
300 }
301 }
302
303 if(i < pCalibdb->CalibPara.Setting_len) {
304 *calib_idx = i;
305 } else {
306 *calib_idx = 0;
307 }
308
309 LOGD_ANR("%s:%d snr_name:%s snr_idx:%d i:%d \n", __FUNCTION__, __LINE__, name, *calib_idx, i);
310 return res;
311 }
312
init_ynr_params_json(RKAnr_Ynr_Params_s * pYnrParams,CalibDbV2_YnrV1_t * pYnrCalib,int calib_idx,int tuning_idx)313 ANRresult_t init_ynr_params_json(RKAnr_Ynr_Params_s *pYnrParams, CalibDbV2_YnrV1_t* pYnrCalib, int calib_idx, int tuning_idx)
314 {
315 ANRresult_t res = ANR_RET_SUCCESS;
316 int i = 0;
317 int j = 0;
318
319 if(pYnrParams == NULL) {
320 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
321 return ANR_RET_NULL_POINTER;
322 }
323
324 if(pYnrCalib == NULL) {
325 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
326 return ANR_RET_NULL_POINTER;
327 }
328
329 RKAnr_Ynr_Params_Select_t *pParams = pYnrParams->aYnrParamsISO;
330 CalibDbV2_YnrV1_C_Set_t *pCalibSetting = &pYnrCalib->CalibPara.Setting[calib_idx];
331 CalibDbV2_YnrV1_T_Set_t *pTuningSetting = &pYnrCalib->TuningPara.Setting[tuning_idx];
332 CalibDbV2_YnrV1_C_ISO_t *pCalib_ISO = NULL;
333 CalibDbV2_YnrV1_T_ISO_t *pTuning_ISO = NULL;
334
335 short isoCurveSectValue;
336 short isoCurveSectValue1;
337 int bit_shift;
338 int bit_proc;
339 int bit_calib;
340
341 bit_calib = 12;
342 bit_proc = YNR_SIGMA_BITS;
343 bit_shift = bit_calib - bit_proc;
344 isoCurveSectValue = (1 << (bit_calib - ISO_CURVE_POINT_BIT));//rawBit必须大于ISO_CURVE_POINT_BIT
345 isoCurveSectValue1 = (1 << bit_calib);// - 1;//rawBit必须大于ISO_CURVE_POINT_BIT, max use (1 << bit_calib);
346
347 #ifndef RK_SIMULATOR_HW
348 for(j = 0; j < pTuningSetting->Tuning_ISO_len; j++) {
349 pParams[j].iso = pTuningSetting->Tuning_ISO[j].iso;
350 }
351 #endif
352
353 for(j = 0; j < pCalibSetting->Calib_ISO_len; j++) {
354 pCalib_ISO = &pCalibSetting->Calib_ISO[j];
355 for(i = 0; i < WAVELET_LEVEL_NUM; i++) {
356 pParams[j].loFreqNoiseCi[i] = pCalib_ISO->ynr_lci[i];
357 pParams[j].ciISO[i * 3 + 0] = pCalib_ISO->ynr_lhci[i];
358 pParams[j].ciISO[i * 3 + 1] = pCalib_ISO->ynr_hlci[i];
359 pParams[j].ciISO[i * 3 + 2] = pCalib_ISO->ynr_hhci[i];
360 }
361
362 for(i = 0; i < ISO_CURVE_POINT_NUM; i++) {
363 float ave1, ave2, ave3, ave4;
364 if(i == (ISO_CURVE_POINT_NUM - 1)) {
365 ave1 = (float)isoCurveSectValue1;
366 }
367 else {
368 ave1 = (float)(i * isoCurveSectValue);
369 }
370 pParams[j].lumaPoints[i] = (short)ave1;
371 ave2 = ave1 * ave1;
372 ave3 = ave2 * ave1;
373 ave4 = ave3 * ave1;
374 pParams[j].noiseSigma[i] = pCalib_ISO->sigma_curve[0] * ave4
375 + pCalib_ISO->sigma_curve[1] * ave3
376 + pCalib_ISO->sigma_curve[2] * ave2
377 + pCalib_ISO->sigma_curve[3] * ave1
378 + pCalib_ISO->sigma_curve[4];
379 if(pParams[j].noiseSigma[i] < 0) {
380 pParams[j].noiseSigma[i] = 0;
381 }
382 }
383
384 for (i = 0; i < ISO_CURVE_POINT_NUM; i++) {
385 if(bit_shift > 0) {
386 pParams[j].lumaPoints[i] >>= bit_shift;
387 }
388 else {
389 pParams[j].lumaPoints[i] <<= ABS(bit_shift);
390 }
391 }
392 }
393
394 for(j = 0; j < pTuningSetting->Tuning_ISO_len; j++) {
395 pTuning_ISO = &pTuningSetting->Tuning_ISO[j];
396 pParams[j].loFreqDenoiseWeight[0] = pTuning_ISO->denoise_weight_1;
397 pParams[j].loFreqDenoiseWeight[1] = pTuning_ISO->denoise_weight_2;
398 pParams[j].loFreqDenoiseWeight[2] = pTuning_ISO->denoise_weight_3;
399 pParams[j].loFreqDenoiseWeight[3] = pTuning_ISO->denoise_weight_4;
400
401 pParams[j].loFreqBfScale[0] = pTuning_ISO->lo_bfScale_1;
402 pParams[j].loFreqBfScale[1] = pTuning_ISO->lo_bfScale_2;
403 pParams[j].loFreqBfScale[2] = pTuning_ISO->lo_bfScale_3;
404 pParams[j].loFreqBfScale[3] = pTuning_ISO->lo_bfScale_4;
405
406 for(i = 0; i < 6; i++) {
407 pParams[j].loFreqLumaNrCurvePoint[i] = pTuning_ISO->luma_para.lo_lumaPoint[i];
408 pParams[j].loFreqLumaNrCurveRatio[i] = pTuning_ISO->luma_para.lo_lumaRatio[i];
409 }
410
411 pParams[j].loFreqDenoiseStrength[0] = pTuning_ISO->imerge_ratio;
412 pParams[j].loFreqDenoiseStrength[1] = pTuning_ISO->imerge_bound;
413 pParams[j].loFreqDirectionStrength = pTuning_ISO->lo_directionStrength;
414
415
416 pParams[j].hiFreqDenoiseWeight[0] = pTuning_ISO->hi_denoiseWeight_1;
417 pParams[j].hiFreqDenoiseWeight[1] = pTuning_ISO->hi_denoiseWeight_2;
418 pParams[j].hiFreqDenoiseWeight[2] = pTuning_ISO->hi_denoiseWeight_3;
419 pParams[j].hiFreqDenoiseWeight[3] = pTuning_ISO->hi_denoiseWeight_4;
420
421 pParams[j].hiFreqBfScale[0] = pTuning_ISO->hi_bfScale_1;
422 pParams[j].hiFreqBfScale[1] = pTuning_ISO->hi_bfScale_2;
423 pParams[j].hiFreqBfScale[2] = pTuning_ISO->hi_bfScale_3;
424 pParams[j].hiFreqBfScale[3] = pTuning_ISO->hi_bfScale_4;
425
426 for(int i = 0; i < 4; i++) {
427 pParams[j].hiFreqEdgeSoftness[i] = pTuning_ISO->hwith_d[i];
428 }
429
430 pParams[j].hiFreqSoftThresholdScale[0] = pTuning_ISO->hi_soft_thresh_scale_1;
431 pParams[j].hiFreqSoftThresholdScale[1] = pTuning_ISO->hi_soft_thresh_scale_2;
432 pParams[j].hiFreqSoftThresholdScale[2] = pTuning_ISO->hi_soft_thresh_scale_3;
433 pParams[j].hiFreqSoftThresholdScale[3] = pTuning_ISO->hi_soft_thresh_scale_4;
434
435 for(int i = 0; i < WAVELET_LEVEL_NUM; i++) {
436 pParams[j].lscGainRatioAdjust[i] = 1.0;
437 }
438
439
440 for(i = 0; i < 6; i++) {
441 pParams[j].hiFreqLumaNrCurvePoint[i] = pTuning_ISO->luma_para.hi_lumaPoint[i];
442 pParams[j].hiFreqLumaNrCurveRatio[i] = pTuning_ISO->luma_para.hi_lumaRatio[i];
443 }
444 pParams[j].hiFreqDenoiseStrength = pTuning_ISO->hi_denoiseStrength;
445
446 for(i = 0; i < 7; i++) {
447 pParams[j].radialNoiseCtrPoint[i] = 0;
448 pParams[j].radialNoiseCtrRatio[i] = 1.0;
449 }
450
451 for(i = 0; i < 6; i++) {
452 float tmp = pTuning_ISO->hgrad_para.y_luma_point[i];
453 if(bit_shift > 0)
454 tmp /= (1 << bit_shift);
455 else
456 tmp *= (1 << ABS(bit_shift));
457
458 pParams[j].detailThre[i] = tmp;
459 pParams[j].detailThreRatioLevel[0][i] = pTuning_ISO->hgrad_para.hgrad_y_level1[i];
460 pParams[j].detailThreRatioLevel[1][i] = pTuning_ISO->hgrad_para.hgrad_y_level2[i];
461 pParams[j].detailThreRatioLevel[2][i] = pTuning_ISO->hgrad_para.hgrad_y_level3[i];
462 pParams[j].detailThreLevel4[i] = tmp;
463 pParams[j].detailThreRatioLevel4[i] = pTuning_ISO->hgrad_para.hgrad_y_level4[i];
464 }
465
466 pParams[j].detailMinAdjDnW = pTuning_ISO->hi_detailMinAdjDnW;
467 pParams[j].waveLetCoeffDeltaHi = 0;
468 pParams[j].waveLetCoeffDeltaLo = 0;
469 pParams[j].hiValueThre = 0;
470 pParams[j].loValueThre = 0;
471 }
472
473 strncpy(pYnrParams->ynr_ver_char, pYnrCalib->Version, sizeof(pYnrParams->ynr_ver_char));
474
475 ynr_algo_param_printf(pYnrParams);
476 return res;
477 }
478
ynr_algo_param_printf(RKAnr_Ynr_Params_s * pYnrParams)479 ANRresult_t ynr_algo_param_printf(RKAnr_Ynr_Params_s *pYnrParams)
480 {
481 int i, j;
482 RKAnr_Ynr_Params_Select_t *pParams;
483
484 if(pYnrParams != NULL) {
485 pParams = pYnrParams->aYnrParamsISO;
486
487 for(j = 0; j < MAX_ISO_STEP; j++) {
488 #ifndef RK_SIMULATOR_HW
489 LOGD_ANR("iso:%f\n", pParams[j].iso);
490 #endif
491
492 for(i = 0; i < WAVELET_LEVEL_NUM; i++) {
493 LOGD_ANR("wave_level:%d lci:%f lhci:%f hlci:%f hhci:%f\n",
494 i,
495 pParams[j].loFreqNoiseCi[i],
496 pParams[j].ciISO[i * 3 + 0],
497 pParams[j].ciISO[i * 3 + 1],
498 pParams[j].ciISO[i * 3 + 2]);
499 }
500
501 LOGD_ANR("lo_bfscale:%f %f %f %f\n",
502 pParams[j].loFreqBfScale[0],
503 pParams[j].loFreqBfScale[1],
504 pParams[j].loFreqBfScale[2],
505 pParams[j].loFreqBfScale[3]);
506
507 LOGD_ANR("denoise_weight:%f %f %f %f\n",
508 pParams[j].loFreqDenoiseWeight[0],
509 pParams[j].loFreqDenoiseWeight[1],
510 pParams[j].loFreqDenoiseWeight[2],
511 pParams[j].loFreqDenoiseWeight[3]);
512
513 LOGD_ANR("imerge_ratio:%f imerge_bound:%f lo_directionStrength:%f\n",
514 pParams[j].loFreqDenoiseStrength[0],
515 pParams[j].loFreqDenoiseStrength[1],
516 pParams[j].loFreqDirectionStrength);
517
518 for(i = 0; i < 6; i++) {
519 LOGD_ANR("lo luma:%f ratio:%f\n",
520 pParams[j].loFreqLumaNrCurvePoint[i],
521 pParams[j].loFreqLumaNrCurveRatio[i]);
522 }
523
524
525 LOGD_ANR("hi_bfscale:%f %f %f %f\n",
526 pParams[j].hiFreqBfScale[0],
527 pParams[j].hiFreqBfScale[1],
528 pParams[j].hiFreqBfScale[2],
529 pParams[j].hiFreqBfScale[3]);
530
531
532 LOGD_ANR("hi_denoise_weight:%f %f %f %f\n",
533 pParams[j].hiFreqDenoiseWeight[0],
534 pParams[j].hiFreqDenoiseWeight[1],
535 pParams[j].hiFreqDenoiseWeight[2],
536 pParams[j].hiFreqDenoiseWeight[3]);
537
538 LOGD_ANR("hi_ThresholdScale:%f %f %f %f\n",
539 pParams[j].hiFreqSoftThresholdScale[0],
540 pParams[j].hiFreqSoftThresholdScale[1],
541 pParams[j].hiFreqSoftThresholdScale[2],
542 pParams[j].hiFreqSoftThresholdScale[3]);
543
544 LOGD_ANR("hwith_d:%f %f %f %f\n",
545 pParams[j].hiFreqEdgeSoftness[0],
546 pParams[j].hiFreqEdgeSoftness[1],
547 pParams[j].hiFreqEdgeSoftness[2],
548 pParams[j].hiFreqEdgeSoftness[3]);
549
550 LOGD_ANR("hi_denoiseStrength:%f detailMinAdjDnW:%f\n",
551 pParams[j].hiFreqDenoiseStrength,
552 pParams[j].detailMinAdjDnW);
553
554 for(i = 0; i < 6; i++) {
555 LOGD_ANR("hi luma:%f ratio:%f\n",
556 pParams[j].hiFreqLumaNrCurvePoint[i],
557 pParams[j].hiFreqLumaNrCurveRatio[i]);
558 }
559
560 }
561 }
562
563 return ANR_RET_SUCCESS;
564 }
565
566
ynr_config_setting_param_json(RKAnr_Ynr_Params_s * pParams,CalibDbV2_YnrV1_t * pCalibdb,char * param_mode,char * snr_name)567 ANRresult_t ynr_config_setting_param_json(RKAnr_Ynr_Params_s *pParams, CalibDbV2_YnrV1_t*pCalibdb, char* param_mode, char* snr_name)
568 {
569 ANRresult_t res = ANR_RET_SUCCESS;
570 int tuning_idx = 0;
571 int calib_idx = 0;
572
573 if(pParams == NULL) {
574 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
575 return ANR_RET_NULL_POINTER;
576 }
577
578 if(pCalibdb == NULL) {
579 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
580 return ANR_RET_NULL_POINTER;
581 }
582
583 res = ynr_get_setting_idx_by_name_json(pCalibdb, snr_name, &calib_idx, &tuning_idx);
584 if(res != ANR_RET_SUCCESS) {
585 LOGW_ANR("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
586 }
587
588 res = init_ynr_params_json(pParams, pCalibdb, calib_idx, tuning_idx);
589
590 return res;
591
592 }
593
select_ynr_params_by_ISO(RKAnr_Ynr_Params_t * stYnrParam,RKAnr_Ynr_Params_Select_t * stYnrParamSelected,ANRExpInfo_t * pExpInfo,short bitValue)594 ANRresult_t select_ynr_params_by_ISO(RKAnr_Ynr_Params_t *stYnrParam, RKAnr_Ynr_Params_Select_t *stYnrParamSelected, ANRExpInfo_t *pExpInfo, short bitValue)
595 {
596 short multBit;
597 float ratio = 0.0f;
598 int isoValue = 50;
599 RKAnr_Ynr_Params_Select_t *pstYNrTuneParamHi = NULL;
600 RKAnr_Ynr_Params_Select_t *pstYNrTuneParamLo = NULL;
601
602
603 ANRresult_t res = ANR_RET_SUCCESS;
604
605 if(stYnrParam == NULL) {
606 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
607 return ANR_RET_NULL_POINTER;
608 }
609
610 if(stYnrParamSelected == NULL) {
611 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
612 return ANR_RET_NULL_POINTER;
613 }
614
615 if(pExpInfo == NULL) {
616 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
617 return ANR_RET_NULL_POINTER;
618 }
619
620 /**************change bits*****************/
621
622 memcpy(stYnrParamSelected->ynr_ver_char, stYnrParam->ynr_ver_char, sizeof(stYnrParamSelected->ynr_ver_char));
623
624 /*********************************/
625 bitValue = RKAIQ_YNR_SIGMA_BITS;
626 multBit = 1;
627 if(bitValue >= 8)
628 {
629 multBit = 1 << (bitValue - 8);
630 }
631
632 #if 0
633 if(isoValue > 50 && isoValue <= 100)
634 {
635 ratio = (isoValue - 50) / (float)(100 - 50);
636
637 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO100;
638 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO50;
639 }
640 else if(isoValue > 100 && isoValue <= 200)
641 {
642 ratio = (isoValue - 100) / (float)(200 - 100);
643
644 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO200;
645 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO100;
646 }
647 else if(isoValue > 200 && isoValue <= 400)
648 {
649 ratio = (isoValue - 200) / (float)(400 - 200);
650
651 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO400;
652 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO200;
653 }
654 else if(isoValue > 400 && isoValue <= 800)
655 {
656 ratio = (isoValue - 400) / (float)(800 - 400);
657
658 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO800;
659 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO400;
660 }
661 else if(isoValue > 800 && isoValue <= 1600)
662 {
663 ratio = (isoValue - 800) / (float)(1600 - 800);
664
665 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO1600;
666 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO800;
667 }
668 else if(isoValue > 1600 && isoValue <= 3200)
669 {
670 ratio = (isoValue - 1600) / (float)(3200 - 1600);
671
672 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO3200;
673 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO1600;
674 }
675 else if(isoValue > 3200 && isoValue <= 6400)
676 {
677 ratio = (isoValue - 3200) / (float)(6400 - 3200);
678
679 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO6400;
680 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO3200;
681 }
682 else if(isoValue > 6400 && isoValue <= 12800)
683 {
684 ratio = (isoValue - 6400) / (float)(12800 - 6400);
685
686 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO12800;
687 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO6400;
688 }
689 else if(isoValue > 12800)
690 {
691 ratio = 1;
692
693 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO12800;
694 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO6400;
695 }
696 else if(isoValue <= 50)
697 {
698 ratio = 0;
699
700 pstYNrTuneParamHi = &stYnrParam->stYNrParamsISO100;
701 pstYNrTuneParamLo = &stYnrParam->stYNrParamsISO50;
702 }
703 #endif
704
705 if(pExpInfo->mfnr_mode_3to1) {
706 isoValue = pExpInfo->preIso[pExpInfo->hdr_mode];
707 } else {
708 isoValue = pExpInfo->arIso[pExpInfo->hdr_mode];
709 }
710
711 int iso_div = 50;
712 int lowIso = 50;
713 int highIso = 50;
714 int i = 0;
715
716 #ifndef RK_SIMULATOR_HW
717 for(i = 0; i < MAX_ISO_STEP - 1; i++) {
718 lowIso = stYnrParam->aYnrParamsISO[i].iso;
719 highIso = stYnrParam->aYnrParamsISO[i + 1].iso;
720 if(isoValue >= lowIso && isoValue <= highIso) {
721 ratio = (isoValue - lowIso ) / (float)(highIso - lowIso);
722 pstYNrTuneParamHi = &stYnrParam->aYnrParamsISO[i + 1];
723 pstYNrTuneParamLo = &stYnrParam->aYnrParamsISO[i];
724 break;
725 }
726 }
727
728 if(i == MAX_ISO_STEP - 1) {
729 if(isoValue < stYnrParam->aYnrParamsISO[0].iso) {
730 ratio = 0;
731 lowIso = stYnrParam->aYnrParamsISO[0].iso;
732 highIso = stYnrParam->aYnrParamsISO[1].iso;
733 pstYNrTuneParamHi = &stYnrParam->aYnrParamsISO[1];
734 pstYNrTuneParamLo = &stYnrParam->aYnrParamsISO[0];
735 }
736 if(isoValue > stYnrParam->aYnrParamsISO[MAX_ISO_STEP - 1].iso) {
737 ratio = 1;
738 lowIso = stYnrParam->aYnrParamsISO[MAX_ISO_STEP - 2].iso;
739 highIso = stYnrParam->aYnrParamsISO[MAX_ISO_STEP - 1].iso;
740 pstYNrTuneParamHi = &stYnrParam->aYnrParamsISO[MAX_ISO_STEP - 2];
741 pstYNrTuneParamLo = &stYnrParam->aYnrParamsISO[MAX_ISO_STEP - 1];
742 }
743 }
744 #else
745 for(i = 0; i < MAX_ISO_STEP - 1; i++) {
746 int lowIso = iso_div * (1 << i);
747 int highIso = iso_div * (1 << (i + 1));
748 if(isoValue >= lowIso && isoValue <= highIso) {
749 ratio = (isoValue - lowIso ) / (float)(highIso - lowIso);
750 pstYNrTuneParamHi = &stYnrParam->aYnrParamsISO[i + 1];
751 pstYNrTuneParamLo = &stYnrParam->aYnrParamsISO[i];
752 break;
753 }
754 }
755
756 if(i == MAX_ISO_STEP - 1) {
757 if(isoValue < iso_div) {
758 ratio = 0;
759 pstYNrTuneParamHi = &stYnrParam->aYnrParamsISO[1];
760 pstYNrTuneParamLo = &stYnrParam->aYnrParamsISO[0];
761 }
762
763 if(isoValue > iso_div * (2 << MAX_ISO_STEP)) {
764 ratio = 1;
765 pstYNrTuneParamHi = &stYnrParam->aYnrParamsISO[MAX_ISO_STEP - 2];
766 pstYNrTuneParamLo = &stYnrParam->aYnrParamsISO[MAX_ISO_STEP - 1];
767 }
768 }
769 #endif
770
771 LOGD_ANR("oyyf %s:%d iso:%d low:%d hight:%d ratio:%f\n", __FUNCTION__, __LINE__,
772 isoValue, lowIso, highIso, ratio);
773
774 //高频Ci值和亮度噪声曲线
775 for(int i = 0; i < 12; i++)
776 {
777 stYnrParamSelected->ciISO[i] = ratio * (pstYNrTuneParamHi->ciISO[i] - pstYNrTuneParamLo->ciISO[i]) + pstYNrTuneParamLo->ciISO[i];
778 }
779
780 for(int i = 0; i < ISO_CURVE_POINT_NUM; i++)
781 {
782 stYnrParamSelected->noiseSigma[i] = ratio * (pstYNrTuneParamHi->noiseSigma[i] - pstYNrTuneParamLo->noiseSigma[i]) + pstYNrTuneParamLo->noiseSigma[i];
783 stYnrParamSelected->lumaPoints[i] = (short)(ratio * (pstYNrTuneParamHi->lumaPoints[i] - pstYNrTuneParamLo->lumaPoints[i]) + pstYNrTuneParamLo->lumaPoints[i]);
784 }
785
786 //小波低频层去噪tuning参数
787 for(int i = 0; i < WAVELET_LEVEL_NUM; i++)
788 {
789 stYnrParamSelected->loFreqNoiseCi[i] = ratio * (pstYNrTuneParamHi->loFreqNoiseCi[i] - pstYNrTuneParamLo->loFreqNoiseCi[i]) + pstYNrTuneParamLo->loFreqNoiseCi[i];
790 stYnrParamSelected->loFreqDenoiseWeight[i] = ratio * (pstYNrTuneParamHi->loFreqDenoiseWeight[i] - pstYNrTuneParamLo->loFreqDenoiseWeight[i]) + pstYNrTuneParamLo->loFreqDenoiseWeight[i];
791 stYnrParamSelected->loFreqBfScale[i] = ratio * (pstYNrTuneParamHi->loFreqBfScale[i] - pstYNrTuneParamLo->loFreqBfScale[i]) + pstYNrTuneParamLo->loFreqBfScale[i];
792 }
793
794 // fix gain table bug
795 //float adj = 16 / sqrt(32.0f) / int(16 / sqrt(32.0f));
796 #ifndef RK_SIMULATOR_HW
797 float isoValue_clip = MIN(isoValue, iso_div * (2 << MAX_ISO_STEP));
798 float gain_f = sqrt(50.0f / isoValue_clip);
799 if (gain_f < 0.5f)
800 {
801 for (int i = 0; i < 12; i++)
802 {
803 stYnrParamSelected->ciISO[i] /= 2.0f;
804 }
805
806 for (int i = 0; i < WAVELET_LEVEL_NUM; i++)
807 {
808 stYnrParamSelected->loFreqNoiseCi[i] /= 2.0f;
809 }
810
811 gain_f *= 2.0f;
812 }
813 for (int i = 0; i < ISO_CURVE_POINT_NUM; i++)
814 {
815 stYnrParamSelected->noiseSigma[i] *= gain_f;
816 }
817 #endif
818
819 for(int i = 0; i < 6; i++)
820 {
821 stYnrParamSelected->loFreqLumaNrCurvePoint[i] = ratio * (pstYNrTuneParamHi->loFreqLumaNrCurvePoint[i] - pstYNrTuneParamLo->loFreqLumaNrCurvePoint[i]) + pstYNrTuneParamLo->loFreqLumaNrCurvePoint[i];
822 stYnrParamSelected->loFreqLumaNrCurveRatio[i] = ratio * (pstYNrTuneParamHi->loFreqLumaNrCurveRatio[i] - pstYNrTuneParamLo->loFreqLumaNrCurveRatio[i]) + pstYNrTuneParamLo->loFreqLumaNrCurveRatio[i];
823
824 stYnrParamSelected->loFreqLumaNrCurvePoint[i] *= multBit;
825 }
826
827 //stYnrParamSelected->loFreqDenoiseStrength = ratio * (pstYNrTuneParamHi->loFreqDenoiseStrength - pstYNrTuneParamLo->loFreqDenoiseStrength) + pstYNrTuneParamLo->loFreqDenoiseStrength;
828 stYnrParamSelected->loFreqDenoiseStrength[0] = ratio * (pstYNrTuneParamHi->loFreqDenoiseStrength[0] - pstYNrTuneParamLo->loFreqDenoiseStrength[0]) + pstYNrTuneParamLo->loFreqDenoiseStrength[0];
829 stYnrParamSelected->loFreqDenoiseStrength[1] = 1.0f / stYnrParamSelected->loFreqDenoiseStrength[0] / 2;
830
831 stYnrParamSelected->loFreqDirectionStrength = ratio * (pstYNrTuneParamHi->loFreqDirectionStrength - pstYNrTuneParamLo->loFreqDirectionStrength) + pstYNrTuneParamLo->loFreqDirectionStrength;
832
833 //小波高频层去噪tuning参数
834 for(int i = 0; i < WAVELET_LEVEL_NUM; i++)
835 {
836 stYnrParamSelected->hiFreqDenoiseWeight[i] = ratio * (pstYNrTuneParamHi->hiFreqDenoiseWeight[i] - pstYNrTuneParamLo->hiFreqDenoiseWeight[i]) + pstYNrTuneParamLo->hiFreqDenoiseWeight[i];
837 stYnrParamSelected->hiFreqSoftThresholdScale[i] = ratio * (pstYNrTuneParamHi->hiFreqSoftThresholdScale[i] - pstYNrTuneParamLo->hiFreqSoftThresholdScale[i]) + pstYNrTuneParamLo->hiFreqSoftThresholdScale[i];
838 stYnrParamSelected->hiFreqBfScale[i] = ratio * (pstYNrTuneParamHi->hiFreqBfScale[i] - pstYNrTuneParamLo->hiFreqBfScale[i]) + pstYNrTuneParamLo->hiFreqBfScale[i];
839 stYnrParamSelected->hiFreqEdgeSoftness[i] = ratio * (pstYNrTuneParamHi->hiFreqEdgeSoftness[i] - pstYNrTuneParamLo->hiFreqEdgeSoftness[i]) + pstYNrTuneParamLo->hiFreqEdgeSoftness[i];
840 stYnrParamSelected->lscGainRatioAdjust[i] = ratio * (pstYNrTuneParamHi->lscGainRatioAdjust[i] - pstYNrTuneParamLo->lscGainRatioAdjust[i]) + pstYNrTuneParamLo->lscGainRatioAdjust[i];
841 }
842
843 for(int i = 0; i < 6; i++)
844 {
845 stYnrParamSelected->hiFreqLumaNrCurvePoint[i] = ratio * (pstYNrTuneParamHi->hiFreqLumaNrCurvePoint[i] - pstYNrTuneParamLo->hiFreqLumaNrCurvePoint[i]) + pstYNrTuneParamLo->hiFreqLumaNrCurvePoint[i];
846 stYnrParamSelected->hiFreqLumaNrCurveRatio[i] = ratio * (pstYNrTuneParamHi->hiFreqLumaNrCurveRatio[i] - pstYNrTuneParamLo->hiFreqLumaNrCurveRatio[i]) + pstYNrTuneParamLo->hiFreqLumaNrCurveRatio[i];
847
848 stYnrParamSelected->hiFreqLumaNrCurvePoint[i] *= multBit;
849 }
850
851 stYnrParamSelected->hiFreqDenoiseStrength = ratio * (pstYNrTuneParamHi->hiFreqDenoiseStrength - pstYNrTuneParamLo->hiFreqDenoiseStrength) + pstYNrTuneParamLo->hiFreqDenoiseStrength;
852
853 //
854 for(int i = 0; i < 6; i++)
855 {
856 stYnrParamSelected->detailThre[i] = ratio * (pstYNrTuneParamHi->detailThre[i] - pstYNrTuneParamLo->detailThre[i]) + pstYNrTuneParamLo->detailThre[i];
857 stYnrParamSelected->detailThreRatioLevel[0][i] = ratio * (pstYNrTuneParamHi->detailThreRatioLevel[0][i] - pstYNrTuneParamLo->detailThreRatioLevel[0][i]) + pstYNrTuneParamLo->detailThreRatioLevel[0][i];
858 stYnrParamSelected->detailThreRatioLevel[1][i] = ratio * (pstYNrTuneParamHi->detailThreRatioLevel[1][i] - pstYNrTuneParamLo->detailThreRatioLevel[1][i]) + pstYNrTuneParamLo->detailThreRatioLevel[1][i];
859 stYnrParamSelected->detailThreRatioLevel[2][i] = ratio * (pstYNrTuneParamHi->detailThreRatioLevel[2][i] - pstYNrTuneParamLo->detailThreRatioLevel[2][i]) + pstYNrTuneParamLo->detailThreRatioLevel[2][i];
860
861 stYnrParamSelected->detailThreLevel4[i] = ratio * (pstYNrTuneParamHi->detailThreLevel4[i] - pstYNrTuneParamLo->detailThreLevel4[i]) + pstYNrTuneParamLo->detailThreLevel4[i];
862 stYnrParamSelected->detailThreRatioLevel4[i] = ratio * (pstYNrTuneParamHi->detailThreRatioLevel4[i] - pstYNrTuneParamLo->detailThreRatioLevel4[i]) + pstYNrTuneParamLo->detailThreRatioLevel4[i];
863 }
864 stYnrParamSelected->detailMinAdjDnW = ratio * (pstYNrTuneParamHi->detailMinAdjDnW - pstYNrTuneParamLo->detailMinAdjDnW) + pstYNrTuneParamLo->detailMinAdjDnW;
865
866 //stYnrParamSelected->detailHiHiTh = ratio * (pstYNrTuneParamHi->detailHiHiTh - pstYNrTuneParamLo->detailHiHiTh) + pstYNrTuneParamLo->detailHiHiTh;//
867 //stYnrParamSelected->detailHiLoTh = ratio * (pstYNrTuneParamHi->detailHiLoTh - pstYNrTuneParamLo->detailHiLoTh) + pstYNrTuneParamLo->detailHiLoTh;
868 //stYnrParamSelected->detailLoHiTh = ratio * (pstYNrTuneParamHi->detailLoHiTh - pstYNrTuneParamLo->detailLoHiTh) + pstYNrTuneParamLo->detailLoHiTh;
869 //stYnrParamSelected->detailLoLoTh = ratio * (pstYNrTuneParamHi->detailLoLoTh - pstYNrTuneParamLo->detailLoLoTh) + pstYNrTuneParamLo->detailLoLoTh;
870 //stYnrParamSelected->detailHiHiRatio = ratio * (pstYNrTuneParamHi->detailHiHiRatio - pstYNrTuneParamLo->detailHiHiRatio) + pstYNrTuneParamLo->detailHiHiRatio;
871 //stYnrParamSelected->detailHiLoRatio = ratio * (pstYNrTuneParamHi->detailHiLoRatio - pstYNrTuneParamLo->detailHiLoRatio) + pstYNrTuneParamLo->detailHiLoRatio;
872 //stYnrParamSelected->detailLoHiRatio = ratio * (pstYNrTuneParamHi->detailLoHiRatio - pstYNrTuneParamLo->detailLoHiRatio) + pstYNrTuneParamLo->detailLoHiRatio;
873 //stYnrParamSelected->detailLoLoRatio = ratio * (pstYNrTuneParamHi->detailLoLoRatio - pstYNrTuneParamLo->detailLoLoRatio) + pstYNrTuneParamLo->detailLoLoRatio;
874 //stYnrParamSelected->detailMaxAdjDnW = ratio * (pstYNrTuneParamHi->detailMaxAdjDnW - pstYNrTuneParamLo->detailMaxAdjDnW) + pstYNrTuneParamLo->detailMaxAdjDnW;
875
876 //stYnrParamSelected->detailHiHiThLevel4H = ratio * (pstYNrTuneParamHi->detailHiHiThLevel4H - pstYNrTuneParamLo->detailHiHiThLevel4H) + pstYNrTuneParamLo->detailHiHiThLevel4H;
877 //stYnrParamSelected->detailHiLoThLevel4H = ratio * (pstYNrTuneParamHi->detailHiLoThLevel4H - pstYNrTuneParamLo->detailHiLoThLevel4H) + pstYNrTuneParamLo->detailHiLoThLevel4H;
878 //stYnrParamSelected->detailLoHiThLevel4H = ratio * (pstYNrTuneParamHi->detailLoHiThLevel4H - pstYNrTuneParamLo->detailLoHiThLevel4H) + pstYNrTuneParamLo->detailLoHiThLevel4H;
879 //stYnrParamSelected->detailLoLoThLevel4H = ratio * (pstYNrTuneParamHi->detailLoLoThLevel4H - pstYNrTuneParamLo->detailLoLoThLevel4H) + pstYNrTuneParamLo->detailLoLoThLevel4H;
880 //stYnrParamSelected->detailHiHiRatioLevel4H = ratio * (pstYNrTuneParamHi->detailHiHiRatioLevel4H - pstYNrTuneParamLo->detailHiHiRatioLevel4H) + pstYNrTuneParamLo->detailHiHiRatioLevel4H;
881 //stYnrParamSelected->detailHiLoRatioLevel4H = ratio * (pstYNrTuneParamHi->detailHiLoRatioLevel4H - pstYNrTuneParamLo->detailHiLoRatioLevel4H) + pstYNrTuneParamLo->detailHiLoRatioLevel4H;
882 //stYnrParamSelected->detailLoHiRatioLevel4H = ratio * (pstYNrTuneParamHi->detailLoHiRatioLevel4H - pstYNrTuneParamLo->detailLoHiRatioLevel4H) + pstYNrTuneParamLo->detailLoHiRatioLevel4H;
883 //stYnrParamSelected->detailLoLoRatioLevel4H = ratio * (pstYNrTuneParamHi->detailLoLoRatioLevel4H - pstYNrTuneParamLo->detailLoLoRatioLevel4H) + pstYNrTuneParamLo->detailLoLoRatioLevel4H;
884 //
885 //径向去噪tuning参数
886 for(int i = 0; i < 7; i++)
887 {
888 stYnrParamSelected->radialNoiseCtrPoint[i] = (short)(ratio * (pstYNrTuneParamHi->radialNoiseCtrPoint[i] - pstYNrTuneParamLo->radialNoiseCtrPoint[i]) + pstYNrTuneParamLo->radialNoiseCtrPoint[i]);
889 stYnrParamSelected->radialNoiseCtrRatio[i] = ratio * (pstYNrTuneParamHi->radialNoiseCtrRatio[i] - pstYNrTuneParamLo->radialNoiseCtrRatio[i]) + pstYNrTuneParamLo->radialNoiseCtrRatio[i];
890 }
891
892 //小波第四层LL递归参数
893 stYnrParamSelected->waveLetCoeffDeltaHi = (short)(ratio * (pstYNrTuneParamHi->waveLetCoeffDeltaHi - pstYNrTuneParamLo->waveLetCoeffDeltaHi) + pstYNrTuneParamLo->waveLetCoeffDeltaHi);
894 stYnrParamSelected->waveLetCoeffDeltaLo = (short)(ratio * (pstYNrTuneParamHi->waveLetCoeffDeltaLo - pstYNrTuneParamLo->waveLetCoeffDeltaLo) + pstYNrTuneParamLo->waveLetCoeffDeltaLo);
895 stYnrParamSelected->hiValueThre = (short)(ratio * (pstYNrTuneParamHi->hiValueThre - pstYNrTuneParamLo->hiValueThre) + pstYNrTuneParamLo->hiValueThre);
896 stYnrParamSelected->loValueThre = (short)(ratio * (pstYNrTuneParamHi->loValueThre - pstYNrTuneParamLo->loValueThre) + pstYNrTuneParamLo->loValueThre);
897 stYnrParamSelected->ynr_level4_max_gain = ROUND_F(sqrt((float)isoValue / 50) * (1 << GAIN_YNR_FIX_BITS_DECI));
898
899 return res;
900 }
901
902
find_top_one_pos(int data)903 int find_top_one_pos(int data)
904 {
905 int i, j = 1;
906 int pos = 0;
907 for(i = 0; i < 32; i++)
908 {
909 if(data & j)
910 {
911 pos = i + 1;
912 }
913 j = j << 1;
914 }
915 return pos;
916 }
917
ynr_fix_transfer(RKAnr_Ynr_Params_Select_t * ynr,RKAnr_Ynr_Fix_t * pNrCfg,float gain_ratio,float fStrength)918 ANRresult_t ynr_fix_transfer(RKAnr_Ynr_Params_Select_t* ynr, RKAnr_Ynr_Fix_t *pNrCfg, float gain_ratio, float fStrength)
919 {
920 LOGI_ANR("%s:(%d) enter \n", __FUNCTION__, __LINE__);
921
922 ANRresult_t res = ANR_RET_SUCCESS;
923
924 if(ynr == NULL) {
925 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
926 return ANR_RET_NULL_POINTER;
927 }
928
929 if(pNrCfg == NULL) {
930 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
931 return ANR_RET_NULL_POINTER;
932 }
933
934 LOGD_ANR("%s:%d strength:%f\n", __FUNCTION__, __LINE__, fStrength);
935 if(fStrength <= 0.0) {
936 fStrength = 0.000001;
937 }
938
939 int i = 0;
940 int j = 0;
941 int tmp = 0;
942 int strength_i = 2;
943
944 //0x0104 - 0x0108
945 for(i = 0; i < 16; i++) {
946 pNrCfg->ynr_sgm_dx[i] = find_top_one_pos(ynr->lumaPoints[i + 1] - ynr->lumaPoints[i]) - 2;
947 LOGI_ANR("##########ynr sgm dx[%d] :%d reg:%d\n", i, ynr->lumaPoints[i], pNrCfg->ynr_sgm_dx[i]);
948 }
949
950 //0x010c - 0x012c
951 for(i = 0; i < 17; i++) {
952 float rate;
953 for(j = 0; j < 6; j++) {
954 if(ynr->lumaPoints[i] <= ynr->loFreqLumaNrCurvePoint[j])
955 break;
956 }
957
958 if(j <= 0)
959 rate = ynr->loFreqLumaNrCurveRatio[0];
960 else if(j >= 6)
961 rate = ynr->loFreqLumaNrCurveRatio[5];
962 else {
963 rate = ((float)ynr->lumaPoints[i] - ynr->loFreqLumaNrCurvePoint[j - 1]) / (ynr->loFreqLumaNrCurvePoint[j] - ynr->loFreqLumaNrCurvePoint[j - 1]);
964 rate = ynr->loFreqLumaNrCurveRatio[j - 1] + rate * (ynr->loFreqLumaNrCurveRatio[j] - ynr->loFreqLumaNrCurveRatio[j - 1]);
965 }
966 tmp = ynr->noiseSigma[i] * (1 << FIX_BIT_NOISE_SIGMA);
967 tmp = (int)(rate * tmp);
968 //clip sigma be 10bit;
969 pNrCfg->ynr_lsgm_y[i] = MIN(tmp / ((1 << (12 - YNR_SIGMA_BITS)) * sqrt(gain_ratio)), (1 << (FIX_BIT_NOISE_SIGMA + 9)) - 1);
970 // pNrCfg->ynr_lsgm_y[i] = tmp / (1 << (12 - YNR_SIGMA_BITS));
971 // if(i==0)
972 // printf("pNrCfg->ynr_lsgm_y[i] %d, tmp %d\n", pNrCfg->ynr_lsgm_y[i], tmp);
973 }
974
975
976 //0x0130
977 for(i = 0; i < 4; i++) {
978 if(i > strength_i) {
979 tmp = (ynr->loFreqNoiseCi[i] * (1 << FIX_BIT_CI));
980 } else {
981 tmp = (ynr->loFreqNoiseCi[i] * fStrength * (1 << FIX_BIT_CI));
982 }
983 //printf("ynr ci[%d]: ci:%f reg:0x%x fstrength: %f \n", i, ynr->loFreqNoiseCi[i], tmp, fStrength);
984
985 if(tmp > 0xff) {
986 tmp = 0xff;
987 }
988 pNrCfg->ynr_lci[i] = tmp;
989 }
990
991 //0x0134
992 for(i = 0; i < 4; i++) {
993 if(i > strength_i) {
994 tmp = (ynr->loFreqBfScale[i] * (1 << FIX_BIT_BF_SCALE));
995 } else {
996 tmp = (ynr->loFreqBfScale[i] * fStrength * (1 << FIX_BIT_BF_SCALE));
997 }
998 if(tmp > 0xff) {
999 tmp = 0xff;
1000 }
1001 pNrCfg->ynr_lgain_min[i] = tmp;
1002 }
1003
1004 //0x0138
1005 pNrCfg->ynr_lgain_max = (unsigned char)(ynr->loFreqDirectionStrength * (1 << FIX_BIT_DIRECTION_STRENGTH));
1006
1007
1008 //0x013c
1009 pNrCfg->ynr_lmerge_bound = (unsigned char)((ynr->loFreqDenoiseStrength[1]) * (1 << FIX_BIT_DENOISE_STRENGTH) );
1010 pNrCfg->ynr_lmerge_ratio = (unsigned char)((ynr->loFreqDenoiseStrength[0]) * (1 << FIX_BIT_DENOISE_STRENGTH));
1011
1012 //0x0140
1013 for(i = 0; i < 4; i++) {
1014 if(i > strength_i) {
1015 pNrCfg->ynr_lweit_flt[i] = (unsigned char)(ynr->loFreqDenoiseWeight[i] * (1 << FIX_BIT_DENOISE_WEIGHT));
1016 } else {
1017 pNrCfg->ynr_lweit_flt[i] = (unsigned char)(ynr->loFreqDenoiseWeight[i] * fStrength * (1 << FIX_BIT_DENOISE_WEIGHT));
1018 }
1019 if(pNrCfg->ynr_lweit_flt[i] > 0x80) {
1020 pNrCfg->ynr_lweit_flt[i] = 0x80;
1021 }
1022 }
1023
1024 //0x0144 - 0x0164
1025 for(i = 0; i < 17; i++) {
1026 float rate;
1027 for(j = 0; j < 6; j++) {
1028 if(ynr->lumaPoints[i] <= ynr->hiFreqLumaNrCurvePoint[j])
1029 break;
1030 }
1031
1032 if(j <= 0)
1033 rate = ynr->hiFreqLumaNrCurveRatio[0];
1034 else if(j >= 6)
1035 rate = ynr->hiFreqLumaNrCurveRatio[5];
1036 else {
1037 rate = ((float)ynr->lumaPoints[i] - ynr->hiFreqLumaNrCurvePoint[j - 1])
1038 / (ynr->hiFreqLumaNrCurvePoint[j] - ynr->hiFreqLumaNrCurvePoint[j - 1]);
1039 rate = ynr->hiFreqLumaNrCurveRatio[j - 1]
1040 + rate * (ynr->hiFreqLumaNrCurveRatio[j] - ynr->hiFreqLumaNrCurveRatio[j - 1]);
1041 }
1042 tmp = ynr->noiseSigma[i] * (1 << FIX_BIT_NOISE_SIGMA);
1043 tmp = (int)(rate * tmp);
1044 //clip sigma be 10bit;
1045
1046 pNrCfg->ynr_hsgm_y[i] = MIN(tmp / ((1 << (12 - YNR_SIGMA_BITS)) * sqrt(gain_ratio)), (1 << (FIX_BIT_NOISE_SIGMA + 9)) - 1);
1047 // pNrCfg->ynr_hsgm_y[i] = tmp / (1 << (12 - YNR_SIGMA_BITS));
1048 }
1049
1050 //0x0168
1051 for(i = 0; i < 4; i++) {
1052 if(i > strength_i) {
1053 tmp = (ynr->ciISO[i * 3 + 1] * (1 << FIX_BIT_CI));
1054 } else {
1055 tmp = (ynr->ciISO[i * 3 + 1] * (1 << FIX_BIT_CI));
1056 }
1057 if(tmp > 0xff) {
1058 tmp = 0xff;
1059 }
1060 pNrCfg->ynr_hlci[i] = tmp;
1061 }
1062
1063 //0x016c
1064 for(i = 0; i < 4; i++) {
1065 if(i > strength_i) {
1066 tmp = (ynr->ciISO[i * 3 + 0] * (1 << FIX_BIT_CI));
1067 } else {
1068 tmp = (ynr->ciISO[i * 3 + 0] * (1 << FIX_BIT_CI));
1069 }
1070 if(tmp > 0xff) {
1071 tmp = 0xff;
1072 }
1073 pNrCfg->ynr_lhci[i] = tmp;
1074 }
1075
1076 //0x0170
1077 for(i = 0; i < 4; i++) {
1078 if(i > strength_i) {
1079 tmp = (ynr->ciISO[i * 3 + 2] * (1 << FIX_BIT_CI));
1080 } else {
1081 tmp = (ynr->ciISO[i * 3 + 2] * (1 << FIX_BIT_CI));
1082 }
1083 if(tmp > 0xff) {
1084 tmp = 0xff;
1085 }
1086 pNrCfg->ynr_hhci[i] = tmp;
1087 }
1088
1089 //0x0174
1090 for(i = 0; i < 4; i++) {
1091 if(i > strength_i) {
1092 tmp = (ynr->hiFreqBfScale[i] * (1 << FIX_BIT_BF_SCALE));
1093 } else {
1094 tmp = (ynr->hiFreqBfScale[i] * fStrength * (1 << FIX_BIT_BF_SCALE));
1095 }
1096 if(tmp > 0xff) {
1097 tmp = 0xff;
1098 }
1099 pNrCfg->ynr_hgain_sgm[i] = tmp;
1100 }
1101
1102 //0x0178 - 0x0188
1103 int wavelvl = 0;
1104 int EdgeSoftness = 0;
1105 for(i = 0; i < 4; i++) {
1106 if(i == 0)wavelvl = 0;
1107 if(i == 1)wavelvl = 1;
1108 if(i == 2)wavelvl = 2;
1109 if(i == 3)wavelvl = 3;
1110 EdgeSoftness = (int)(ynr->hiFreqEdgeSoftness[wavelvl] * (1 << FIX_BIT_EDGE_SOFTNESS));
1111 pNrCfg->ynr_hweit_d[0 * 4 + i] = (int)((exp(-(((0 * 0 + 1 * 1) * (1 << (FIX_BIT_EDGE_SOFTNESS + FIX_BIT_EDGE_SOFTNESS))) / (float)(2 * EdgeSoftness * EdgeSoftness)))) * (1 << YNR_exp_lut_y));
1112 pNrCfg->ynr_hweit_d[1 * 4 + i] = (int)((exp(-(((1 * 1 + 1 * 1) * (1 << (FIX_BIT_EDGE_SOFTNESS + FIX_BIT_EDGE_SOFTNESS))) / (float)(2 * EdgeSoftness * EdgeSoftness)))) * (1 << YNR_exp_lut_y));
1113 pNrCfg->ynr_hweit_d[2 * 4 + i] = (int)((exp(-(((0 * 0 + 2 * 2) * (1 << (FIX_BIT_EDGE_SOFTNESS + FIX_BIT_EDGE_SOFTNESS))) / (float)(2 * EdgeSoftness * EdgeSoftness)))) * (1 << YNR_exp_lut_y));
1114 pNrCfg->ynr_hweit_d[3 * 4 + i] = (int)((exp(-(((1 * 1 + 2 * 2) * (1 << (FIX_BIT_EDGE_SOFTNESS + FIX_BIT_EDGE_SOFTNESS))) / (float)(2 * EdgeSoftness * EdgeSoftness)))) * (1 << YNR_exp_lut_y));
1115 pNrCfg->ynr_hweit_d[4 * 4 + i] = (int)((exp(-(((2 * 2 + 2 * 2) * (1 << (FIX_BIT_EDGE_SOFTNESS + FIX_BIT_EDGE_SOFTNESS))) / (float)(2 * EdgeSoftness * EdgeSoftness)))) * (1 << YNR_exp_lut_y));
1116 LOGI_ANR("########ynr hweit wavelvl[%d]: edge:%d weit: %d %d %d %d %d \n",
1117 i, EdgeSoftness,
1118 pNrCfg->ynr_hweit_d[0 * 4 + i],
1119 pNrCfg->ynr_hweit_d[1 * 4 + i],
1120 pNrCfg->ynr_hweit_d[2 * 4 + i],
1121 pNrCfg->ynr_hweit_d[3 * 4 + i],
1122 pNrCfg->ynr_hweit_d[4 * 4 + i]);
1123 }
1124
1125
1126 //0x018c - 0x01a0
1127 for(i = 0; i < 6; i++) {
1128 pNrCfg->ynr_hgrad_y[i * 4 + 0] = (int)(ynr->detailThreRatioLevel[0][i] * (1 << FIX_BIT_GRAD_ADJUST_CURVE));
1129 pNrCfg->ynr_hgrad_y[i * 4 + 1] = (int)(ynr->detailThreRatioLevel[1][i] * (1 << FIX_BIT_GRAD_ADJUST_CURVE));
1130 pNrCfg->ynr_hgrad_y[i * 4 + 2] = (int)(ynr->detailThreRatioLevel[2][i] * (1 << FIX_BIT_GRAD_ADJUST_CURVE));
1131 pNrCfg->ynr_hgrad_y[i * 4 + 3] = (int)(ynr->detailThreRatioLevel4[i] * (1 << FIX_BIT_GRAD_ADJUST_CURVE));
1132 }
1133
1134 //0x01a4 -0x01a8
1135 for(i = 0; i < 4; i++) {
1136 if(i > strength_i) {
1137 pNrCfg->ynr_hweit[i] = (unsigned short)(ynr->hiFreqDenoiseWeight[i] * (1 << FIX_BIT_DENOISE_WEIGHT));
1138 } else {
1139 pNrCfg->ynr_hweit[i] = (unsigned short)(ynr->hiFreqDenoiseWeight[i] * fStrength * (1 << FIX_BIT_DENOISE_WEIGHT));
1140 }
1141
1142 if(pNrCfg->ynr_hweit[i] > 0x1ff) {
1143 pNrCfg->ynr_hweit[i] = 0x1ff;
1144 }
1145 }
1146
1147 //0x01b0
1148 pNrCfg->ynr_hmax_adjust = (unsigned char)(ynr->detailMinAdjDnW * (1 << FIX_BIT_GRAD_ADJUST_CURVE));
1149
1150 //0x01b4
1151 tmp = (ynr->hiFreqDenoiseStrength * fStrength * (1 << FIX_BIT_DENOISE_STRENGTH));
1152 if(tmp > 0xff) {
1153 tmp = 0xff;
1154 }
1155 pNrCfg->ynr_hstrength = tmp;
1156
1157 //0x01b8
1158 pNrCfg->ynr_lweit_cmp[0] = (int)(0.1f * (1 << YNR_exp_lut_y) + 0.5f);//13
1159 pNrCfg->ynr_lweit_cmp[1] = (int)(0.1f * (1 << YNR_exp_lut_y) + 0.5f);//13
1160
1161
1162 //0x01bc
1163 pNrCfg->ynr_lmaxgain_lv4 = ynr->ynr_level4_max_gain;
1164
1165 //0x01c0 - 0x01e0
1166 for(i = 0; i < 17; i++) {
1167 tmp = (int)(ynr->noiseSigma[i] * (1 << FIX_BIT_NOISE_SIGMA));
1168 pNrCfg->ynr_hstv_y[i] = tmp / ((1 << (12 - YNR_SIGMA_BITS)) * sqrt(gain_ratio));
1169 }
1170
1171 //0x01e4 - 0x01e8
1172 if (strcmp(ynr->ynr_ver_char, "V2") == 0) {
1173 // Lite Version
1174 for(i = 0; i < 3; i++) {
1175 pNrCfg->ynr_st_scale[i] = (unsigned short)(ynr->hiFreqSoftThresholdScale[i] * (1 << FIX_BIT_SOFT_THRESHOLD_SCALE_V2));
1176 }
1177 } else {
1178 // old v1 version
1179 for(i = 0; i < 3; i++) {
1180 pNrCfg->ynr_st_scale[i] = (unsigned short)(ynr->hiFreqSoftThresholdScale[i] * (1 << FIX_BIT_SOFT_THRESHOLD_SCALE));
1181 }
1182 }
1183
1184 #if YNR_FIX_VALUE_PRINTF
1185 ynr_fix_printf(pNrCfg);
1186 #endif
1187
1188 LOGI_ANR("%s:(%d) exit \n", __FUNCTION__, __LINE__);
1189
1190 return res;
1191 }
1192
ynr_fix_printf(RKAnr_Ynr_Fix_t * pNrCfg)1193 ANRresult_t ynr_fix_printf(RKAnr_Ynr_Fix_t * pNrCfg)
1194 {
1195 LOGD_ANR("%s:(%d) enter \n", __FUNCTION__, __LINE__);
1196
1197 ANRresult_t res = ANR_RET_SUCCESS;
1198
1199 if(pNrCfg == NULL) {
1200 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1201 return ANR_RET_NULL_POINTER;
1202 }
1203
1204 int i = 0;
1205
1206 //0x0104 - 0x0108
1207 for(i = 0; i < 16; i++) {
1208 LOGD_ANR("(0x0104 - 0x0108) ynr_sgm_dx[%d]:%d \n",
1209 i, pNrCfg->ynr_sgm_dx[i]);
1210 }
1211
1212 //0x010c - 0x012c
1213 for(i = 0; i < 17; i++) {
1214 LOGD_ANR("(0x010c - 0x012c) ynr_lsgm_y[%d]:%d \n",
1215 i, pNrCfg->ynr_lsgm_y[i]);
1216 }
1217
1218 //0x0130
1219 for(i = 0; i < 4; i++) {
1220 LOGD_ANR("(0x0130) ynr_lci[%d]:%d \n",
1221 i, pNrCfg->ynr_lci[i]);
1222 }
1223
1224 //0x0134
1225 for(i = 0; i < 4; i++) {
1226 LOGD_ANR("(0x0134) ynr_lgain_min[%d]:%d \n",
1227 i, pNrCfg->ynr_lgain_min[i]);
1228 }
1229
1230 //0x0138
1231 LOGD_ANR("(0x0138) ynr_lgain_max:%d \n",
1232 pNrCfg->ynr_lgain_max);
1233
1234
1235 //0x013c
1236 LOGD_ANR("(0x013c) ynr_lmerge_bound:%d ynr_lmerge_ratio:%d\n",
1237 pNrCfg->ynr_lmerge_bound,
1238 pNrCfg->ynr_lmerge_ratio);
1239
1240 //0x0140
1241 for(i = 0; i < 4; i++) {
1242 LOGD_ANR("(0x0140) ynr_lweit_flt[%d]:%d \n",
1243 i, pNrCfg->ynr_lweit_flt[i]);
1244 }
1245
1246 //0x0144 - 0x0164
1247 for(i = 0; i < 17; i++) {
1248 LOGD_ANR("(0x0144 - 0x0164) ynr_hsgm_y[%d]:%d \n",
1249 i, pNrCfg->ynr_hsgm_y[i]);
1250 }
1251
1252 //0x0168
1253 for(i = 0; i < 4; i++) {
1254 LOGD_ANR("(0x0168) ynr_hlci[%d]:%d \n",
1255 i, pNrCfg->ynr_hlci[i]);
1256 }
1257
1258 //0x016c
1259 for(i = 0; i < 4; i++) {
1260 LOGD_ANR("(0x016c) ynr_lhci[%d]:%d \n",
1261 i, pNrCfg->ynr_lhci[i]);
1262 }
1263
1264 //0x0170
1265 for(i = 0; i < 4; i++) {
1266 LOGD_ANR("(0x0170) ynr_hhci[%d]:%d \n",
1267 i, pNrCfg->ynr_hhci[i]);
1268 }
1269
1270 //0x0174
1271 for(i = 0; i < 4; i++) {
1272 LOGD_ANR("(0x0174) ynr_hgain_sgm[%d]:%d \n",
1273 i, pNrCfg->ynr_hgain_sgm[i]);
1274 }
1275
1276 //0x0178 - 0x0188
1277 for(i = 0; i < 5; i++) {
1278 LOGD_ANR("(0x0178 - 0x0188) ynr_hweit_d[%d - %d]:%d %d %d %d \n",
1279 i * 4 + 0, i * 4 + 3,
1280 pNrCfg->ynr_hweit_d[i * 4 + 0],
1281 pNrCfg->ynr_hweit_d[i * 4 + 1],
1282 pNrCfg->ynr_hweit_d[i * 4 + 2],
1283 pNrCfg->ynr_hweit_d[i * 4 + 3]);
1284 }
1285
1286
1287 //0x018c - 0x01a0
1288 for(i = 0; i < 6; i++) {
1289 LOGD_ANR("(0x018c - 0x01a0) ynr_hgrad_y[%d - %d]:%d %d %d %d \n",
1290 i * 4 + 0, i * 4 + 3,
1291 pNrCfg->ynr_hgrad_y[i * 4 + 0],
1292 pNrCfg->ynr_hgrad_y[i * 4 + 1],
1293 pNrCfg->ynr_hgrad_y[i * 4 + 2],
1294 pNrCfg->ynr_hgrad_y[i * 4 + 3]);
1295 }
1296
1297 //0x01a4 -0x01a8
1298 for(i = 0; i < 4; i++) {
1299 LOGD_ANR("(0x01a4 -0x01a8) ynr_hweit[%d]:%d \n",
1300 i, pNrCfg->ynr_hweit[i]);
1301 }
1302
1303 //0x01b0
1304 LOGD_ANR("(0x01b0) ynr_hmax_adjust:%d \n",
1305 pNrCfg->ynr_hmax_adjust);
1306
1307 //0x01b4
1308 LOGD_ANR("(0x01b4) ynr_hstrength:%d \n",
1309 pNrCfg->ynr_hstrength);
1310
1311 //0x01b8
1312 LOGD_ANR("(0x01b8) ynr_lweit_cmp0-1:%d %d\n",
1313 pNrCfg->ynr_lweit_cmp[0],
1314 pNrCfg->ynr_lweit_cmp[1]);
1315
1316 //0x01bc
1317 LOGD_ANR("(0x01bc) ynr_lmaxgain_lv4:%d \n",
1318 pNrCfg->ynr_lmaxgain_lv4);
1319
1320 //0x01c0 - 0x01e0
1321 for(i = 0; i < 17; i++) {
1322 LOGD_ANR("(0x01c0 - 0x01e0 ) ynr_hstv_y[%d]:%d \n",
1323 i, pNrCfg->ynr_hstv_y[i]);
1324 }
1325
1326 //0x01e4 - 0x01e8
1327 for(i = 0; i < 3; i++) {
1328 LOGD_ANR("(0x01e4 - 0x01e8 ) ynr_st_scale[%d]:%d \n",
1329 i, pNrCfg->ynr_st_scale[i]);
1330 }
1331
1332 LOGD_ANR("%s:(%d) exit \n", __FUNCTION__, __LINE__);
1333
1334 return res;
1335 }
1336
1337
ynr_calibdbV2_assign(CalibDbV2_YnrV1_t * pDst,CalibDbV2_YnrV1_t * pSrc)1338 ANRresult_t ynr_calibdbV2_assign(CalibDbV2_YnrV1_t *pDst, CalibDbV2_YnrV1_t *pSrc)
1339 {
1340 ANRresult_t res = ANR_RET_SUCCESS;
1341 CalibDbV2_YnrV1_Calib_t *pSrcCalibParaV2 = NULL;
1342 CalibDbV2_YnrV1_Tuning_t *pSrcTuningParaV2 = NULL;
1343 CalibDbV2_YnrV1_Calib_t *pDstCalibParaV2 = NULL;
1344 CalibDbV2_YnrV1_Tuning_t *pDstTuningParaV2 = NULL;
1345 int setting_len = 0;
1346 int iso_len = 0;
1347
1348
1349 if(pDst == NULL) {
1350 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1351 return ANR_RET_NULL_POINTER;
1352 }
1353
1354 if(pSrc == NULL) {
1355 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1356 return ANR_RET_NULL_POINTER;
1357 }
1358
1359 ynr_calibdbV2_free(pDst);
1360
1361 pSrcCalibParaV2 = &pSrc->CalibPara;
1362 pSrcTuningParaV2 = &pSrc->TuningPara;
1363 pDstCalibParaV2 = &pDst->CalibPara;
1364 pDstTuningParaV2 = &pDst->TuningPara;
1365
1366 //assign the value
1367 pDst->Version = strdup(pSrc->Version);
1368 pDstTuningParaV2->enable = pSrcTuningParaV2->enable;
1369
1370 //malloc iso size
1371 setting_len = pSrcCalibParaV2->Setting_len;
1372 pDstCalibParaV2->Setting = (CalibDbV2_YnrV1_C_Set_t *)malloc(setting_len * sizeof(CalibDbV2_YnrV1_C_Set_t));
1373 memset(pDstCalibParaV2->Setting, 0x00, setting_len * sizeof(CalibDbV2_YnrV1_C_Set_t));
1374 pDstCalibParaV2->Setting_len = setting_len;
1375
1376
1377 for(int i = 0; i < setting_len; i++) {
1378 iso_len = pSrcCalibParaV2->Setting[i].Calib_ISO_len;
1379 pDstCalibParaV2->Setting[i].Calib_ISO = (CalibDbV2_YnrV1_C_ISO_t *)malloc(iso_len * sizeof(CalibDbV2_YnrV1_C_ISO_t));
1380 memset(pDstCalibParaV2->Setting[i].Calib_ISO, 0x00, iso_len * sizeof(CalibDbV2_YnrV1_C_ISO_t));
1381 pDstCalibParaV2->Setting[i].Calib_ISO_len = iso_len;
1382 }
1383
1384 for(int i = 0; i < setting_len; i++) {
1385 iso_len = pSrcCalibParaV2->Setting[i].Calib_ISO_len;
1386 pDstCalibParaV2->Setting[i].SNR_Mode = strdup(pSrcTuningParaV2->Setting[i].SNR_Mode);
1387 pDstCalibParaV2->Setting[i].Sensor_Mode = strdup(pSrcTuningParaV2->Setting[i].Sensor_Mode);
1388
1389 for(int j = 0; j < iso_len; j++) {
1390 pDstCalibParaV2->Setting[i].Calib_ISO[j] = pSrcCalibParaV2->Setting[i].Calib_ISO[j];
1391 }
1392 }
1393
1394
1395
1396 setting_len = pSrcTuningParaV2->Setting_len;
1397 pDstTuningParaV2->Setting = (CalibDbV2_YnrV1_T_Set_t *)malloc(setting_len * sizeof(CalibDbV2_YnrV1_T_Set_t));
1398 memset(pDstTuningParaV2->Setting, 0x00, setting_len * sizeof(CalibDbV2_YnrV1_T_Set_t));
1399 pDstTuningParaV2->Setting_len = setting_len;
1400
1401 for(int i = 0; i < setting_len; i++) {
1402 iso_len = pSrcTuningParaV2->Setting[i].Tuning_ISO_len;
1403 pDstTuningParaV2->Setting[i].Tuning_ISO = (CalibDbV2_YnrV1_T_ISO_t *)malloc(iso_len * sizeof(CalibDbV2_YnrV1_T_ISO_t));
1404 memset(pDstTuningParaV2->Setting[i].Tuning_ISO, 0x00, iso_len * sizeof(CalibDbV2_YnrV1_T_ISO_t));
1405 pDstTuningParaV2->Setting[i].Tuning_ISO_len = iso_len;
1406 }
1407
1408 for(int i = 0; i < setting_len; i++) {
1409 iso_len = pSrcTuningParaV2->Setting[i].Tuning_ISO_len;
1410
1411 pDstTuningParaV2->Setting[i].SNR_Mode = strdup(pSrcTuningParaV2->Setting[i].SNR_Mode);
1412 pDstTuningParaV2->Setting[i].Sensor_Mode = strdup(pSrcTuningParaV2->Setting[i].Sensor_Mode);
1413
1414 for(int j = 0; j < iso_len; j++) {
1415 pDstTuningParaV2->Setting[i].Tuning_ISO[j] = pSrcTuningParaV2->Setting[i].Tuning_ISO[j];
1416 }
1417 }
1418
1419 return res;
1420 }
1421
1422
1423
ynr_calibdbV2_free(CalibDbV2_YnrV1_t * pCalibdbV2)1424 void ynr_calibdbV2_free(CalibDbV2_YnrV1_t *pCalibdbV2)
1425 {
1426 if(pCalibdbV2) {
1427 if(pCalibdbV2->Version) {
1428 free(pCalibdbV2->Version);
1429 }
1430
1431 if(pCalibdbV2->CalibPara.Setting) {
1432 for(int i = 0; i < pCalibdbV2->CalibPara.Setting_len; i++) {
1433 if(pCalibdbV2->CalibPara.Setting[i].SNR_Mode) {
1434 free(pCalibdbV2->CalibPara.Setting[i].SNR_Mode);
1435 }
1436 if(pCalibdbV2->CalibPara.Setting[i].Sensor_Mode) {
1437 free(pCalibdbV2->CalibPara.Setting[i].Sensor_Mode);
1438 }
1439 if(pCalibdbV2->CalibPara.Setting[i].Calib_ISO) {
1440 free(pCalibdbV2->CalibPara.Setting[i].Calib_ISO);
1441 }
1442 }
1443
1444 free(pCalibdbV2->CalibPara.Setting);
1445 }
1446
1447 if(pCalibdbV2->TuningPara.Setting) {
1448 for(int i = 0; i < pCalibdbV2->TuningPara.Setting_len; i++) {
1449 if(pCalibdbV2->TuningPara.Setting[i].SNR_Mode) {
1450 free(pCalibdbV2->TuningPara.Setting[i].SNR_Mode);
1451 }
1452 if(pCalibdbV2->TuningPara.Setting[i].Sensor_Mode) {
1453 free(pCalibdbV2->TuningPara.Setting[i].Sensor_Mode);
1454 }
1455 if(pCalibdbV2->TuningPara.Setting[i].Tuning_ISO) {
1456 free(pCalibdbV2->TuningPara.Setting[i].Tuning_ISO);
1457 }
1458 }
1459
1460 free(pCalibdbV2->TuningPara.Setting);
1461 }
1462
1463 }
1464
1465 }
1466
1467
1468 RKAIQ_END_DECLARE
1469
1470