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