1 #include "rk_aiq_anr_algo_mfnr.h"
2
3 #define ANR_MFNR_SIGMA_X_SHIFT_BITS (0)
mfnr_get_mode_cell_idx_by_name(CalibDb_MFNR_2_t * pCalibdb,const char * name,int * mode_idx)4 ANRresult_t mfnr_get_mode_cell_idx_by_name(CalibDb_MFNR_2_t *pCalibdb, const char *name, int *mode_idx)
5 {
6 int i = 0;
7 ANRresult_t res = ANR_RET_SUCCESS;
8
9 if(pCalibdb == NULL) {
10 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
11 return ANR_RET_NULL_POINTER;
12 }
13
14 if(name == NULL) {
15 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
16 return ANR_RET_NULL_POINTER;
17 }
18
19 if(mode_idx == NULL) {
20 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
21 return ANR_RET_NULL_POINTER;
22 }
23
24 if(pCalibdb->mode_num < 1) {
25 LOGE_ANR("%s(%d): mfnr mode cell num is zero\n", __FUNCTION__, __LINE__);
26 return ANR_RET_NULL_POINTER;
27 }
28
29 for(i = 0; i < pCalibdb->mode_num; i++) {
30 if(strncmp(name, pCalibdb->mode_cell[i].name, sizeof(pCalibdb->mode_cell[i].name)) == 0) {
31 break;
32 }
33 }
34
35 if(i < pCalibdb->mode_num) {
36 *mode_idx = i;
37 res = ANR_RET_SUCCESS;
38 } else {
39 *mode_idx = 0;
40 res = ANR_RET_FAILURE;
41 }
42
43 LOGD_ANR("%s:%d mode_name:%s mode_idx:%d i:%d \n", __FUNCTION__, __LINE__, name, *mode_idx, i);
44 return res;
45
46 }
47
48
mfnr_get_setting_idx_by_name(CalibDb_MFNR_2_t * pCalibdb,char * name,int mode_idx,int * setting_idx)49 ANRresult_t mfnr_get_setting_idx_by_name(CalibDb_MFNR_2_t *pCalibdb, char *name, int mode_idx, int *setting_idx)
50 {
51 int i = 0;
52 ANRresult_t res = ANR_RET_SUCCESS;
53
54 if(pCalibdb == NULL) {
55 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
56 return ANR_RET_NULL_POINTER;
57 }
58
59 if(name == NULL) {
60 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
61 return ANR_RET_NULL_POINTER;
62 }
63
64 if(setting_idx == NULL) {
65 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
66 return ANR_RET_NULL_POINTER;
67 }
68
69 for(i = 0; i < CALIBDB_NR_SHARP_SETTING_LEVEL; i++) {
70 if(strncmp(name, pCalibdb->mode_cell[mode_idx].setting[i].snr_mode, sizeof(pCalibdb->mode_cell[mode_idx].setting[i].snr_mode)) == 0) {
71 break;
72 }
73 }
74
75 if(i < CALIBDB_NR_SHARP_SETTING_LEVEL) {
76 *setting_idx = i;
77 res = ANR_RET_SUCCESS;
78 } else {
79 *setting_idx = 0;
80 res = ANR_RET_FAILURE;
81 }
82
83 LOGD_ANR("%s:%d snr_name:%s snr_idx:%d i:%d \n", __FUNCTION__, __LINE__, name, *setting_idx, i);
84 return res;
85
86 }
87
init_mfnr_dynamic_params(RKAnr_Mfnr_Dynamic_t * pDynamic,CalibDb_MFNR_2_t * pCalibdb,int mode_idx)88 ANRresult_t init_mfnr_dynamic_params(RKAnr_Mfnr_Dynamic_t *pDynamic, CalibDb_MFNR_2_t *pCalibdb, int mode_idx)
89 {
90 ANRresult_t res = ANR_RET_SUCCESS;
91 int i = 0;
92 int j = 0;
93
94 if(pDynamic == NULL) {
95 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
96 return ANR_RET_NULL_POINTER;
97 }
98
99 if(pCalibdb == NULL) {
100 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
101 return ANR_RET_NULL_POINTER;
102 }
103
104 pDynamic->enable = pCalibdb->mode_cell[mode_idx].dynamic.enable;
105 pDynamic->lowth_iso = pCalibdb->mode_cell[mode_idx].dynamic.lowth_iso;
106 pDynamic->lowth_time = pCalibdb->mode_cell[mode_idx].dynamic.lowth_time;
107 pDynamic->highth_iso = pCalibdb->mode_cell[mode_idx].dynamic.highth_iso;
108 pDynamic->highth_time = pCalibdb->mode_cell[mode_idx].dynamic.highth_time;
109
110 LOGD_ANR("dynamic final param mode:%d \n", mode_idx);
111 return res;
112
113 }
114
mfnr_config_dynamic_param(RKAnr_Mfnr_Dynamic_t * pDynamic,CalibDb_MFNR_2_t * pCalibdb,char * param_mode)115 ANRresult_t mfnr_config_dynamic_param(RKAnr_Mfnr_Dynamic_t *pDynamic, CalibDb_MFNR_2_t *pCalibdb, char* param_mode)
116 {
117
118 ANRresult_t res = ANR_RET_SUCCESS;
119 int mode_idx = 0;
120 int setting_idx = 0;
121
122 if(pDynamic == NULL) {
123 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
124 return ANR_RET_NULL_POINTER;
125 }
126
127 if(pCalibdb == NULL) {
128 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
129 return ANR_RET_NULL_POINTER;
130 }
131
132 if(param_mode == NULL) {
133 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
134 return ANR_RET_NULL_POINTER;
135 }
136
137 res = mfnr_get_mode_cell_idx_by_name(pCalibdb, param_mode, &mode_idx);
138 if(res != ANR_RET_SUCCESS) {
139 LOGW_ANR("%s(%d): error!!! can't find mode name in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
140 }
141
142 res = init_mfnr_dynamic_params(pDynamic, pCalibdb, mode_idx);
143
144 LOGD_ANR("final param mode:%d snr_mode:%d\n", mode_idx);
145 return res;
146
147 }
148
mfnr_config_motion_param_json(CalibDb_MFNR_Motion_t * pMotion,CalibDbV2_MFNR_t * pCalibdb,char * param_mode)149 ANRresult_t mfnr_config_motion_param_json(CalibDb_MFNR_Motion_t *pMotion, CalibDbV2_MFNR_t *pCalibdb, char* param_mode)
150 {
151
152 ANRresult_t res = ANR_RET_SUCCESS;
153 int mode_idx = 0;
154 int setting_idx = 0;
155 CalibDbV2_MFNR_Motion_ISO_t *pMotion_ISO = NULL;
156
157 if(pMotion == NULL) {
158 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
159 return ANR_RET_NULL_POINTER;
160 }
161
162 if(pCalibdb == NULL) {
163 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
164 return ANR_RET_NULL_POINTER;
165 }
166
167 if(param_mode == NULL) {
168 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
169 return ANR_RET_NULL_POINTER;
170 }
171
172
173 pMotion->enable = pCalibdb->TuningPara.motion_detect_en;
174
175 for(int i = 0; i < pCalibdb->TuningPara.Motion.Motion_ISO_len; i++) {
176 pMotion_ISO = &pCalibdb->TuningPara.Motion.Motion_ISO[i];
177
178 pMotion->iso[i] = pMotion_ISO->iso;
179 pMotion->sigmaHScale[i] = pMotion_ISO->sigmaHScale;
180 pMotion->sigmaLScale[i] = pMotion_ISO->sigmaLScale;
181 pMotion->lightClp[i] = pMotion_ISO->lightClp;
182 pMotion->uvWeight[i] = pMotion_ISO->uvWeight;
183
184 pMotion->mfnrSigmaScale[i] = pMotion_ISO->mfnrSigmaScale;
185 pMotion->yuvnrGainScale0[i] = pMotion_ISO->yuvnrGainScale0;
186 pMotion->yuvnrGainScale1[i] = pMotion_ISO->yuvnrGainScale1;
187 pMotion->yuvnrGainScale2[i] = pMotion_ISO->yuvnrGainScale2;
188
189 pMotion->frame_limit_uv[i] = pMotion_ISO->frame_limit_uv;
190 pMotion->frame_limit_y[i] = pMotion_ISO->frame_limit_y;
191
192 pMotion->reserved0[i] = 1;
193 pMotion->reserved1[i] = 1;
194 pMotion->reserved2[i] = 1;
195 pMotion->reserved3[i] = 1;
196 pMotion->reserved4[i] = 1;
197 pMotion->reserved5[i] = 1;
198 pMotion->reserved6[i] = 1;
199 pMotion->reserved7[i] = 1;
200 }
201
202
203 LOGD_ANR("final param mode:%d snr_mode:%d\n", mode_idx);
204 return res;
205
206 }
207
208
mfnr_config_setting_param(RKAnr_Mfnr_Params_t * pParams,CalibDb_MFNR_2_t * pCalibdb,char * param_mode,char * snr_name)209 ANRresult_t mfnr_config_setting_param(RKAnr_Mfnr_Params_t *pParams, CalibDb_MFNR_2_t *pCalibdb, char* param_mode, char* snr_name)
210 {
211 ANRresult_t res = ANR_RET_SUCCESS;
212 int mode_idx = 0;
213 int setting_idx = 0;
214
215 if(pParams == NULL) {
216 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
217 return ANR_RET_NULL_POINTER;
218 }
219
220 if(pCalibdb == NULL) {
221 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
222 return ANR_RET_NULL_POINTER;
223 }
224
225 if(param_mode == NULL) {
226 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
227 return ANR_RET_NULL_POINTER;
228 }
229
230 if(snr_name == NULL) {
231 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
232 return ANR_RET_NULL_POINTER;
233 }
234
235 res = mfnr_get_mode_cell_idx_by_name(pCalibdb, param_mode, &mode_idx);
236 if(res != ANR_RET_SUCCESS) {
237 LOGW_ANR("%s(%d): error!!! can't find mode name in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
238 }
239
240 res = mfnr_get_setting_idx_by_name(pCalibdb, snr_name, mode_idx, &setting_idx);
241 if(res != ANR_RET_SUCCESS) {
242 LOGW_ANR("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
243 }
244
245 res = init_mfnr_params(pParams, pCalibdb, mode_idx, setting_idx);
246
247 LOGD_ANR("final param mode:%d snr_mode:%d\n", mode_idx, setting_idx);
248 return res;
249
250 }
251
init_mfnr_params(RKAnr_Mfnr_Params_t * pParams,CalibDb_MFNR_2_t * pCalibdb,int mode_idx,int setting_idx)252 ANRresult_t init_mfnr_params(RKAnr_Mfnr_Params_t *pParams, CalibDb_MFNR_2_t *pCalibdb, int mode_idx, int setting_idx)
253 {
254 ANRresult_t res = ANR_RET_SUCCESS;
255 int i = 0;
256 int j = 0;
257 int step_y = (1 << (Y_CALIBRATION_BITS - 8));
258 int range_sample = 1 << (Y_CALIBRATION_BITS - ANR_MFNR_SIGMA_X_SHIFT_BITS);
259 int step_sample = 1 << ANR_MFNR_SIGMA_X_SHIFT_BITS;
260
261 if(pParams == NULL) {
262 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
263 return ANR_RET_NULL_POINTER;
264 }
265
266 if(pCalibdb == NULL) {
267 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
268 return ANR_RET_NULL_POINTER;
269 }
270
271 int max_iso_step = MAX_ISO_STEP;
272 int dir_num = MFNR_DIR_NUM;
273 int polyorder = MFNR_POLYORDER;
274 int max_lvl = MFNR_MAX_LVL;
275 int max_lvl_uv = MFNR_MAX_LVL_UV;
276 int lumancurve_step = LUMANRCURVE_STEP;
277 int range = 1 << Y_CALIBRATION_BITS;
278 int dir_lo = DIR_LO;
279 int dir_hi = DIR_HI;
280
281
282 max_lvl = pCalibdb->max_level;
283 max_lvl_uv = pCalibdb->max_level_uv;
284 pParams->back_ref_num = pCalibdb->back_ref_num;
285
286 CalibDb_MFNR_Setting_t *pSetting = &pCalibdb->mode_cell[mode_idx].setting[setting_idx];
287 for(int lvl = 0; lvl < max_lvl; lvl++) {
288 for (i = 0; i < max_iso_step; i++)
289 pParams->weight_limit_y[i][lvl] = pSetting->mfnr_iso[i].weight_limit_y[lvl];
290 }
291
292 for(int lvl = 0; lvl < max_lvl_uv; lvl++) {
293 for (i = 0; i < max_iso_step; i++)
294 pParams->weight_limit_uv[i][lvl] = pSetting->mfnr_iso[i].weight_limit_uv[lvl];
295 }
296
297 for(int j = 0; j < 4; j++) {
298 for (i = 0; i < max_iso_step; i++)
299 pParams->ratio_frq[i][j] = pSetting->mfnr_iso[i].ratio_frq[j];
300 }
301
302 for(int lvl = 0; lvl < max_lvl_uv; lvl++) {
303 for (i = 0; i < max_iso_step; i++)
304 pParams->luma_w_in_chroma[i][lvl] = pSetting->mfnr_iso[i].luma_w_in_chroma[lvl];
305 }
306
307 for(j = 0; j < 4; j++) {
308 for(i = 0; i < 2; i++)
309 pParams->awb_uv_ratio[j][i] = pCalibdb->uv_ratio[j].ratio[i];
310 }
311
312 for(int j = 0; j < polyorder + 1; j++) {
313 for (i = 0; i < max_iso_step; i++)
314 pParams->curve[i][j] = pSetting->mfnr_iso[i].noise_curve[j];
315 }
316
317 for (i = 0; i < max_iso_step; i++) {
318 pParams->curve_x0[i] = pSetting->mfnr_iso[i].noise_curve_x00;
319 }
320
321
322 for (j = 0; j < max_lvl; j++) {
323 for (i = 0; i < max_iso_step; i++) {
324 pParams->ci[i][0][j] = pSetting->mfnr_iso[i].y_lo_noiseprofile[j];
325 pParams->ci[i][1][j] = pSetting->mfnr_iso[i].y_hi_noiseprofile[j];
326 pParams->scale[i][0][j] = pSetting->mfnr_iso[i].y_lo_bfscale[j];
327 pParams->scale[i][1][j] = pSetting->mfnr_iso[i].y_hi_bfscale[j];
328 }
329 }
330
331 for (j = 0; j < lumancurve_step; j++) {
332 for (i = 0; i < max_iso_step; i++) {
333 pParams->lumanrpoint[i][dir_lo][j] = pSetting->mfnr_iso[i].y_lumanrpoint[j];
334 pParams->lumanrcurve[i][dir_lo][j] = pSetting->mfnr_iso[i].y_lumanrcurve[j];
335 pParams->lumanrpoint[i][dir_hi][j] = pSetting->mfnr_iso[i].y_lumanrpoint[j];
336 pParams->lumanrcurve[i][dir_hi][j] = pSetting->mfnr_iso[i].y_lumanrcurve[j];
337 }
338 }
339
340 for (i = 0; i < max_iso_step; i++) {
341 pParams->dnstr[i][dir_lo] = pSetting->mfnr_iso[i].y_denoisestrength;
342 pParams->dnstr[i][dir_hi] = pParams->dnstr[i][dir_lo];
343 }
344
345
346 for(int j = 0; j < 6; j++) {
347 for (i = 0; i < max_iso_step; i++) {
348 pParams->gfdelta[i][0][0][j] = pSetting->mfnr_iso[i].y_lo_lvl0_gfdelta[j];
349 pParams->gfdelta[i][1][0][j] = pSetting->mfnr_iso[i].y_hi_lvl0_gfdelta[j];
350 }
351 }
352
353 for(int j = 0; j < 3; j++) {
354 for (i = 0; i < max_iso_step; i++) {
355 pParams->gfdelta[i][0][1][j] = pSetting->mfnr_iso[i].y_lo_lvl1_gfdelta[j];
356 pParams->gfdelta[i][0][2][j] = pSetting->mfnr_iso[i].y_lo_lvl2_gfdelta[j];
357 pParams->gfdelta[i][0][3][j] = pSetting->mfnr_iso[i].y_lo_lvl3_gfdelta[j];
358
359 pParams->gfdelta[i][1][1][j] = pSetting->mfnr_iso[i].y_hi_lvl1_gfdelta[j];
360 pParams->gfdelta[i][1][2][j] = pSetting->mfnr_iso[i].y_hi_lvl2_gfdelta[j];
361 pParams->gfdelta[i][1][3][j] = pSetting->mfnr_iso[i].y_hi_lvl3_gfdelta[j];
362 }
363 }
364
365 for (j = 0; j < max_lvl_uv; j++) {
366 for (i = 0; i < max_iso_step; i++) {
367 pParams->ci_uv[i][0][j] = pSetting->mfnr_iso[i].uv_lo_noiseprofile[j];
368 pParams->ci_uv[i][1][j] = pSetting->mfnr_iso[i].uv_hi_noiseprofile[j];
369 pParams->scale_uv[i][0][j] = pSetting->mfnr_iso[i].uv_lo_bfscale[j];
370 pParams->scale_uv[i][1][j] = pSetting->mfnr_iso[i].uv_hi_bfscale[j];
371
372 LOGI_ANR("j:%d i:%d ci:%f %f scale:%f %f\n", j, i,
373 pParams->ci_uv[i][0][j],
374 pParams->ci_uv[i][1][j],
375 pParams->scale_uv[i][0][j],
376 pParams->scale_uv[i][1][j]);
377 }
378 }
379
380 for (j = 0; j < lumancurve_step; j++) {
381 for (i = 0; i < max_iso_step; i++) {
382 pParams->lumanrpoint_uv[i][dir_lo][j] = pSetting->mfnr_iso[i].uv_lumanrpoint[j];
383 pParams->lumanrcurve_uv[i][dir_lo][j] = pSetting->mfnr_iso[i].uv_lumanrcurve[j];
384 pParams->lumanrpoint_uv[i][dir_hi][j] = pSetting->mfnr_iso[i].uv_lumanrpoint[j];
385 pParams->lumanrcurve_uv[i][dir_hi][j] = pSetting->mfnr_iso[i].uv_lumanrcurve[j];
386 }
387 }
388
389 for (i = 0; i < max_iso_step; i++) {
390 pParams->dnstr_uv[i][dir_lo] = pSetting->mfnr_iso[i].uv_denoisestrength;
391 pParams->dnstr_uv[i][dir_hi] = pParams->dnstr_uv[i][dir_lo];
392 LOGI_ANR("%d: dnstr_uv:%f %f\n", i,
393 pParams->dnstr_uv[i][dir_lo],
394 pParams->dnstr_uv[i][dir_hi]);
395 }
396
397 for(int j = 0; j < 6; j++) {
398 for (i = 0; i < max_iso_step; i++) {
399 pParams->gfdelta_uv[i][0][0][j] = pSetting->mfnr_iso[i].uv_lo_lvl0_gfdelta[j];
400 pParams->gfdelta_uv[i][1][0][j] = pSetting->mfnr_iso[i].uv_hi_lvl0_gfdelta[j];
401 }
402 }
403
404 for(int j = 0; j < 3; j++) {
405 for (i = 0; i < max_iso_step; i++) {
406 pParams->gfdelta_uv[i][0][1][j] = pSetting->mfnr_iso[i].uv_lo_lvl1_gfdelta[j];
407 pParams->gfdelta_uv[i][0][2][j] = pSetting->mfnr_iso[i].uv_lo_lvl2_gfdelta[j];
408 pParams->gfdelta_uv[i][1][1][j] = pSetting->mfnr_iso[i].uv_hi_lvl1_gfdelta[j];
409 pParams->gfdelta_uv[i][1][2][j] = pSetting->mfnr_iso[i].uv_hi_lvl2_gfdelta[j];
410 }
411 }
412
413
414 for(int j = 0; j < 6; j++) {
415 for (i = 0; i < max_iso_step; i++) {
416 pParams->gfsigma[i][0][j] = pSetting->mfnr_iso[i].lvl0_gfsigma[j];
417 }
418 }
419
420 for(int j = 0; j < 3; j++) {
421 for (i = 0; i < max_iso_step; i++) {
422 pParams->gfsigma[i][1][j] = pSetting->mfnr_iso[i].lvl1_gfsigma[j];
423 pParams->gfsigma[i][2][j] = pSetting->mfnr_iso[i].lvl2_gfsigma[j];
424 pParams->gfsigma[i][3][j] = pSetting->mfnr_iso[i].lvl3_gfsigma[j];
425 }
426 }
427
428 for (i = 0; i < max_iso_step; i++) {
429 int64_t curve_x0 = (int)pParams->curve_x0[i];
430 for (j = 0; j < range; j++) {
431 int64_t X[5];
432 double y;
433
434 X[0] = 1;
435 y = pParams->curve[i][polyorder];
436 for(int order = 1; order < polyorder + 1; order++) {
437 X[order] = X[order - 1] * j;
438 y = y + (double)X[order] * pParams->curve[i][polyorder - order];
439 }
440
441 if(j > curve_x0)
442 pParams->noise_sigma[i][j] = pParams->noise_sigma[i][curve_x0];
443 else
444 pParams->noise_sigma[i][j] = y;
445 }
446 for(j = 0; j < range_sample; j++) {
447 pParams->noise_sigma[i][j] = pParams->noise_sigma[i][j * step_sample] / step_y;
448 }
449 for(j = range_sample; j < range; j++) {
450 pParams->noise_sigma[i][j] = 0;
451 }
452 pParams->curve_x0[i] = pParams->curve_x0[i] / step_sample;
453 }
454
455 #ifndef RK_SIMULATOR_HW
456 pParams->motion_detection_enable = pCalibdb->mode_cell[mode_idx].motion.enable & pCalibdb->motion_detect_en;
457 for(int j = 0; j < MAX_ISO_STEP; j++)
458 {
459 pParams->mfnr_sigma_scale[j] = pCalibdb->mode_cell[mode_idx].motion.mfnrSigmaScale[j];
460 }
461 #endif
462
463 #ifndef RK_SIMULATOR_HW
464 for (i = 0; i < max_iso_step; i++) {
465 pParams->iso[i] = pSetting->mfnr_iso[i].iso;
466 }
467 #endif
468
469 LOGD_ANR("oyyf mfnr iso50: lbfscale:%f hbfscale:%f strength:%f %f\n",
470 pParams->scale[0][0][0],
471 pParams->scale[0][1][0],
472 pParams->dnstr[0][0],
473 pParams->dnstr[0][1]);
474
475 //memcpy(pParams->mfnr_ver_char, pCalibdb->version, sizeof(pParams->mfnr_ver_char));
476 LOGI_ANR("%s(%d): exit!\n", __FUNCTION__, __LINE__);
477
478 return res;
479 }
480
481
mfnr_get_setting_idx_by_name_json(CalibDbV2_MFNR_t * pCalibdb,char * name,int * calib_idx,int * tuning_idx)482 ANRresult_t mfnr_get_setting_idx_by_name_json(CalibDbV2_MFNR_t *pCalibdb, char *name, int* calib_idx, int *tuning_idx)
483 {
484 int i = 0;
485 ANRresult_t res = ANR_RET_SUCCESS;
486
487 if(pCalibdb == NULL) {
488 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
489 return ANR_RET_NULL_POINTER;
490 }
491
492 if(name == NULL) {
493 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
494 return ANR_RET_NULL_POINTER;
495 }
496
497 if(calib_idx == NULL) {
498 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
499 return ANR_RET_NULL_POINTER;
500 }
501
502 if(tuning_idx == NULL) {
503 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
504 return ANR_RET_NULL_POINTER;
505 }
506
507 for(i = 0; i < pCalibdb->TuningPara.Setting_len; i++) {
508 if(strncmp(name, pCalibdb->TuningPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
509 break;
510 }
511 }
512
513 if(i < pCalibdb->TuningPara.Setting_len) {
514 *tuning_idx = i;
515 } else {
516 *tuning_idx = 0;
517 }
518
519 for(i = 0; i < pCalibdb->CalibPara.Setting_len; i++) {
520 if(strncmp(name, pCalibdb->CalibPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
521 break;
522 }
523 }
524
525 if(i < pCalibdb->CalibPara.Setting_len) {
526 *calib_idx = i;
527 } else {
528 *calib_idx = 0;
529 }
530
531 LOGD_ANR("%s:%d snr_name:%s snr_idx:%d i:%d \n", __FUNCTION__, __LINE__, name, *calib_idx, i);
532 return res;
533
534 }
535
536
mfnr_config_dynamic_param_json(RKAnr_Mfnr_Dynamic_t * pDynamic,CalibDbV2_MFNR_t * pCalibdb,char * param_mode)537 ANRresult_t mfnr_config_dynamic_param_json(RKAnr_Mfnr_Dynamic_t *pDynamic, CalibDbV2_MFNR_t *pCalibdb, char* param_mode)
538 {
539
540 ANRresult_t res = ANR_RET_SUCCESS;
541 int mode_idx = 0;
542 int setting_idx = 0;
543
544 if(pDynamic == NULL) {
545 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
546 return ANR_RET_NULL_POINTER;
547 }
548
549 if(pCalibdb == NULL) {
550 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
551 return ANR_RET_NULL_POINTER;
552 }
553
554 if(param_mode == NULL) {
555 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
556 return ANR_RET_NULL_POINTER;
557 }
558
559 res = init_mfnr_dynamic_params_json(pDynamic, pCalibdb);
560
561 return res;
562
563 }
564
init_mfnr_params_json(RKAnr_Mfnr_Params_t * pParams,CalibDbV2_MFNR_t * pCalibdb,int calib_idx,int tuning_idx)565 ANRresult_t init_mfnr_params_json(RKAnr_Mfnr_Params_t *pParams, CalibDbV2_MFNR_t *pCalibdb, int calib_idx, int tuning_idx)
566 {
567 ANRresult_t res = ANR_RET_SUCCESS;
568 int i = 0;
569 int j = 0;
570 int step_y = (1 << (Y_CALIBRATION_BITS - 8));
571 int range_sample = 1 << (Y_CALIBRATION_BITS - ANR_MFNR_SIGMA_X_SHIFT_BITS);
572 int step_sample = 1 << ANR_MFNR_SIGMA_X_SHIFT_BITS;
573
574 if(pParams == NULL) {
575 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
576 return ANR_RET_NULL_POINTER;
577 }
578
579 if(pCalibdb == NULL) {
580 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
581 return ANR_RET_NULL_POINTER;
582 }
583
584 int max_iso_step = MAX_ISO_STEP;
585 int dir_num = MFNR_DIR_NUM;
586 int polyorder = MFNR_POLYORDER;
587 int max_lvl = MFNR_MAX_LVL;
588 int max_lvl_uv = MFNR_MAX_LVL_UV;
589 int lumancurve_step = LUMANRCURVE_STEP;
590 int range = 1 << Y_CALIBRATION_BITS;
591 int dir_lo = DIR_LO;
592 int dir_hi = DIR_HI;
593
594
595 max_lvl = 4;
596 max_lvl_uv = 3;
597 pParams->back_ref_num = 0;
598
599 CalibDbV2_MFNR_T_Set_t *pTuningSetting = &pCalibdb->TuningPara.Setting[tuning_idx];
600 CalibDbV2_MFNR_C_Set_t *pCalibSetting = &pCalibdb->CalibPara.Setting[calib_idx];
601 CalibDbV2_MFNR_T_ISO_t *pTuningISO = NULL;
602 CalibDbV2_MFNR_C_ISO_t *pCalibISO = NULL;
603
604 #ifndef RK_SIMULATOR_HW
605 pParams->motion_detection_enable = pCalibdb->TuningPara.motion_detect_en;
606 #endif
607
608 for (i = 0; i < pTuningSetting->Tuning_ISO_len; i++) {
609 pTuningISO = &pTuningSetting->Tuning_ISO[i];
610
611 #ifndef RK_SIMULATOR_HW
612 pParams->iso[i] = pTuningISO->iso;
613 #endif
614
615 pParams->weight_limit_y[i][0] = pTuningISO->weight_limit_y_0;
616 pParams->weight_limit_y[i][1] = pTuningISO->weight_limit_y_1;
617 pParams->weight_limit_y[i][2] = pTuningISO->weight_limit_y_2;
618 pParams->weight_limit_y[i][3] = pTuningISO->weight_limit_y_3;
619
620 pParams->weight_limit_uv[i][0] = pTuningISO->weight_limit_uv_0;
621 pParams->weight_limit_uv[i][1] = pTuningISO->weight_limit_uv_1;
622 pParams->weight_limit_uv[i][2] = pTuningISO->weight_limit_uv_2;
623
624 pParams->ratio_frq[i][0] = pTuningISO->ratio_frq_y_l;
625 pParams->ratio_frq[i][1] = pTuningISO->ratio_frq_y_h;
626 pParams->ratio_frq[i][2] = pTuningISO->ratio_frq_uv_l;
627 pParams->ratio_frq[i][3] = pTuningISO->ratio_frq_uv_h;
628
629 pParams->luma_w_in_chroma[i][0] = pTuningISO->luma_w_in_chroma_0;
630 pParams->luma_w_in_chroma[i][1] = pTuningISO->luma_w_in_chroma_1;
631 pParams->luma_w_in_chroma[i][2] = pTuningISO->luma_w_in_chroma_2;
632
633 pParams->scale[i][0][0] = pTuningISO->y_lo_bfscale_0;
634 pParams->scale[i][0][1] = pTuningISO->y_lo_bfscale_1;
635 pParams->scale[i][0][2] = pTuningISO->y_lo_bfscale_2;
636 pParams->scale[i][0][3] = pTuningISO->y_lo_bfscale_3;
637
638 pParams->scale[i][1][0] = pTuningISO->y_hi_bfscale_0;
639 pParams->scale[i][1][1] = pTuningISO->y_hi_bfscale_1;
640 pParams->scale[i][1][2] = pTuningISO->y_hi_bfscale_2;
641 pParams->scale[i][1][3] = pTuningISO->y_hi_bfscale_3;
642
643 for (j = 0; j < lumancurve_step; j++) {
644 pParams->lumanrpoint[i][dir_lo][j] = pTuningISO->luma_para.y_lumanrpoint[j];
645 pParams->lumanrcurve[i][dir_lo][j] = pTuningISO->luma_para.y_lumanrcurve[j];
646 pParams->lumanrpoint[i][dir_hi][j] = pTuningISO->luma_para.y_lumanrpoint[j];
647 pParams->lumanrcurve[i][dir_hi][j] = pTuningISO->luma_para.y_lumanrcurve[j];
648
649 pParams->lumanrpoint_uv[i][dir_lo][j] = pTuningISO->luma_para.uv_lumanrpoint[j];
650 pParams->lumanrcurve_uv[i][dir_lo][j] = pTuningISO->luma_para.uv_lumanrcurve[j];
651 pParams->lumanrpoint_uv[i][dir_hi][j] = pTuningISO->luma_para.uv_lumanrpoint[j];
652 pParams->lumanrcurve_uv[i][dir_hi][j] = pTuningISO->luma_para.uv_lumanrcurve[j];
653 }
654
655 pParams->dnstr[i][dir_lo] = pTuningISO->y_denoisestrength;
656 pParams->dnstr[i][dir_hi] = pParams->dnstr[i][dir_lo];
657
658 pParams->dnstr_uv[i][dir_lo] = pTuningISO->uv_denoisestrength;
659 pParams->dnstr_uv[i][dir_hi] = pParams->dnstr_uv[i][dir_lo];
660
661 pParams->scale_uv[i][0][0] = pTuningISO->uv_lo_bfscale_0;
662 pParams->scale_uv[i][0][1] = pTuningISO->uv_lo_bfscale_1;
663 pParams->scale_uv[i][0][2] = pTuningISO->uv_lo_bfscale_2;
664
665 pParams->scale_uv[i][1][0] = pTuningISO->uv_hi_bfscale_0;
666 pParams->scale_uv[i][1][1] = pTuningISO->uv_hi_bfscale_1;
667 pParams->scale_uv[i][1][2] = pTuningISO->uv_hi_bfscale_2;
668
669
670 for(int j = 0; j < 6; j++) {
671 pParams->gfdelta[i][0][0][j] = pTuningISO->y_gfdelta_para.y_lo_lvl0_gfdelta[j];
672 pParams->gfdelta[i][1][0][j] = pTuningISO->y_gfdelta_para.y_hi_lvl0_gfdelta[j];
673 pParams->gfdelta_uv[i][0][0][j] = pTuningISO->uv_gfdelta_para.uv_lo_lvl0_gfdelta[j];
674 pParams->gfdelta_uv[i][1][0][j] = pTuningISO->uv_gfdelta_para.uv_hi_lvl0_gfdelta[j];
675 pParams->gfsigma[i][0][j] = pTuningISO->gfsigma_para.lvl0_gfsigma[j];
676 }
677
678 for(int j = 0; j < 3; j++) {
679 pParams->gfdelta[i][0][1][j] = pTuningISO->y_gfdelta_para.y_lo_lvl1_gfdelta[j];
680 pParams->gfdelta[i][0][2][j] = pTuningISO->y_gfdelta_para.y_lo_lvl2_gfdelta[j];
681 pParams->gfdelta[i][0][3][j] = pTuningISO->y_gfdelta_para.y_lo_lvl3_gfdelta[j];
682
683 pParams->gfdelta[i][1][1][j] = pTuningISO->y_gfdelta_para.y_hi_lvl1_gfdelta[j];
684 pParams->gfdelta[i][1][2][j] = pTuningISO->y_gfdelta_para.y_hi_lvl2_gfdelta[j];
685 pParams->gfdelta[i][1][3][j] = pTuningISO->y_gfdelta_para.y_hi_lvl3_gfdelta[j];
686
687 pParams->gfdelta_uv[i][0][1][j] = pTuningISO->uv_gfdelta_para.uv_lo_lvl1_gfdelta[j];
688 pParams->gfdelta_uv[i][0][2][j] = pTuningISO->uv_gfdelta_para.uv_lo_lvl2_gfdelta[j];
689 pParams->gfdelta_uv[i][1][1][j] = pTuningISO->uv_gfdelta_para.uv_hi_lvl1_gfdelta[j];
690 pParams->gfdelta_uv[i][1][2][j] = pTuningISO->uv_gfdelta_para.uv_hi_lvl2_gfdelta[j];
691
692 pParams->gfsigma[i][1][j] = pTuningISO->gfsigma_para.lvl1_gfsigma[j];
693 pParams->gfsigma[i][2][j] = pTuningISO->gfsigma_para.lvl2_gfsigma[j];
694 pParams->gfsigma[i][3][j] = pTuningISO->gfsigma_para.lvl3_gfsigma[j];
695 }
696
697 #ifndef RK_SIMULATOR_HW
698 pParams->mfnr_sigma_scale[i] = pCalibdb->TuningPara.Motion.Motion_ISO[i].mfnrSigmaScale;
699 #endif
700
701 }
702
703
704 for (i = 0; i < pCalibSetting->Calib_ISO_len; i++) {
705 pCalibISO = &pCalibSetting->Calib_ISO[i];
706 for(int j = 0; j < polyorder + 1; j++) {
707 pParams->curve[i][j] = pCalibISO->noise_curve[j];
708 }
709 pParams->curve_x0[i] = pCalibISO->noise_curve_x00;
710
711 for (j = 0; j < max_lvl; j++) {
712 pParams->ci[i][0][j] = pCalibISO->y_lo_noiseprofile[j];
713 pParams->ci[i][1][j] = pCalibISO->y_hi_noiseprofile[j];
714 }
715
716 for (j = 0; j < max_lvl_uv; j++) {
717 pParams->ci_uv[i][0][j] = pCalibISO->uv_lo_noiseprofile[j];
718 pParams->ci_uv[i][1][j] = pCalibISO->uv_hi_noiseprofile[j];
719 }
720 }
721
722 for(j = 0; j < 4; j++) {
723 for(i = 0; i < 2; i++)
724 pParams->awb_uv_ratio[j][i] = 0;
725 }
726
727
728
729 for (i = 0; i < pTuningSetting->Tuning_ISO_len; i++) {
730 int64_t curve_x0 = (int)pParams->curve_x0[i];
731 for (j = 0; j < range; j++) {
732 int64_t X[5];
733 double y;
734
735 X[0] = 1;
736 y = pParams->curve[i][polyorder];
737 for(int order = 1; order < polyorder + 1; order++) {
738 X[order] = X[order - 1] * j;
739 y = y + (double)X[order] * pParams->curve[i][polyorder - order];
740 }
741
742 if(j > curve_x0)
743 pParams->noise_sigma[i][j] = pParams->noise_sigma[i][curve_x0];
744 else
745 pParams->noise_sigma[i][j] = y;
746 }
747 for(j = 0; j < range_sample; j++) {
748 pParams->noise_sigma[i][j] = pParams->noise_sigma[i][j * step_sample] / step_y;
749 }
750 for(j = range_sample; j < range; j++) {
751 pParams->noise_sigma[i][j] = 0;
752 }
753 pParams->curve_x0[i] = pParams->curve_x0[i] / step_sample;
754 }
755
756
757 LOGD_ANR("oyyf mfnr iso50: lbfscale:%f hbfscale:%f strength:%f %f\n",
758 pParams->scale[0][0][0],
759 pParams->scale[0][1][0],
760 pParams->dnstr[0][0],
761 pParams->dnstr[0][1]);
762
763 //memcpy(pParams->mfnr_ver_char, pCalibdb->version, sizeof(pParams->mfnr_ver_char));
764 LOGI_ANR("%s(%d): exit!\n", __FUNCTION__, __LINE__);
765
766 mfnr_algo_param_printf(pParams);
767
768 return res;
769 }
770
mfnr_algo_param_printf(RKAnr_Mfnr_Params_t * pParams)771 ANRresult_t mfnr_algo_param_printf(RKAnr_Mfnr_Params_t *pParams)
772 {
773 int i, j;
774
775 if(pParams != NULL) {
776
777 for(i = 0; i < MAX_ISO_STEP; i++) {
778 #ifndef RK_SIMULATOR_HW
779 LOGD_ANR("mfnr: ISO:%f\n", pParams->iso[i]);
780 #endif
781
782 LOGD_ANR("noise_curve: %lf %lf %lf %lf %lf curve_x0:%f\n",
783 pParams->curve[i][0],
784 pParams->curve[i][1],
785 pParams->curve[i][2],
786 pParams->curve[i][3],
787 pParams->curve[i][4],
788 pParams->curve_x0[i]);
789
790 LOGD_ANR("y_lo_noiseprofile: %f %f %f %f\n",
791 pParams->ci[i][0][0],
792 pParams->ci[i][0][1],
793 pParams->ci[i][0][2],
794 pParams->ci[i][0][3]);
795
796 LOGD_ANR("Y_hi_noiseprofile: %f %f %f %f\n",
797 pParams->ci[i][1][0],
798 pParams->ci[i][1][1],
799 pParams->ci[i][1][2],
800 pParams->ci[i][1][3]);
801
802 LOGD_ANR("uv_lo_noiseprofile: %f %f %f \n",
803 pParams->ci_uv[i][0][0],
804 pParams->ci_uv[i][0][1],
805 pParams->ci_uv[i][0][2]);
806
807 LOGD_ANR("uv_hi_noiseprofile: %f %f %f \n",
808 pParams->ci_uv[i][1][0],
809 pParams->ci_uv[i][1][1],
810 pParams->ci_uv[i][1][2]);
811
812 LOGD_ANR("Y_weight_limit: %d %d %d %d\n",
813 pParams->weight_limit_y[i][0],
814 pParams->weight_limit_y[i][1],
815 pParams->weight_limit_y[i][2],
816 pParams->weight_limit_y[i][3]);
817
818 LOGD_ANR("uv_weight_limit: %d %d %d \n",
819 pParams->weight_limit_uv[i][0],
820 pParams->weight_limit_uv[i][1],
821 pParams->weight_limit_uv[i][2]);
822
823 LOGD_ANR("ratio_frq: %f %f %f %f\n",
824 pParams->ratio_frq[i][0],
825 pParams->ratio_frq[i][1],
826 pParams->ratio_frq[i][2],
827 pParams->ratio_frq[i][3]);
828
829 LOGD_ANR("luma_w_in_chroma: %f %f %f \n",
830 pParams->luma_w_in_chroma[i][0],
831 pParams->luma_w_in_chroma[i][1],
832 pParams->luma_w_in_chroma[i][2]);
833
834 LOGD_ANR("y_lo_scale: %f %f %f %f\n",
835 pParams->scale[i][0][0],
836 pParams->scale[i][0][1],
837 pParams->scale[i][0][2],
838 pParams->scale[i][0][3]);
839
840 LOGD_ANR("Y_hi_scale: %f %f %f %f\n",
841 pParams->scale[i][1][0],
842 pParams->scale[i][1][1],
843 pParams->scale[i][1][2],
844 pParams->scale[i][1][3]);
845
846 LOGD_ANR("y_denoiseStrength: %f uv_denoiseStrength:%f \n",
847 pParams->dnstr[i][0],
848 pParams->dnstr_uv[i][0]);
849
850
851 LOGD_ANR("uv_lo_scale: %f %f %f\n",
852 pParams->scale_uv[i][0][0],
853 pParams->scale_uv[i][0][1],
854 pParams->scale_uv[i][0][2]);
855
856 LOGD_ANR("uv_hi_scale: %f %f %f\n",
857 pParams->scale_uv[i][1][0],
858 pParams->scale_uv[i][1][1],
859 pParams->scale_uv[i][1][2]);
860
861
862 for (j = 0; j < 6; j++) {
863 LOGD_ANR("y luma: %f %f \n",
864 pParams->lumanrpoint[i][0][j],
865 pParams->lumanrcurve[i][0][j]);
866 }
867
868 for (j = 0; j < 6; j++) {
869 LOGD_ANR("uv luma: %f %f \n",
870 pParams->lumanrpoint_uv[i][0][j],
871 pParams->lumanrcurve_uv[i][0][j]);
872 }
873
874 }
875 }
876
877 return ANR_RET_SUCCESS;
878 }
879
init_mfnr_dynamic_params_json(RKAnr_Mfnr_Dynamic_t * pDynamic,CalibDbV2_MFNR_t * pCalibdb)880 ANRresult_t init_mfnr_dynamic_params_json(RKAnr_Mfnr_Dynamic_t *pDynamic, CalibDbV2_MFNR_t *pCalibdb)
881 {
882 ANRresult_t res = ANR_RET_SUCCESS;
883 int i = 0;
884 int j = 0;
885
886 if(pDynamic == NULL) {
887 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
888 return ANR_RET_NULL_POINTER;
889 }
890
891 if(pCalibdb == NULL) {
892 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
893 return ANR_RET_NULL_POINTER;
894 }
895
896 pDynamic->enable = pCalibdb->TuningPara.Dynamic.Enable;
897 pDynamic->lowth_iso = pCalibdb->TuningPara.Dynamic.LowTh_iso;
898 pDynamic->lowth_time = pCalibdb->TuningPara.Dynamic.LowTh_time;
899 pDynamic->highth_iso = pCalibdb->TuningPara.Dynamic.HighTh_iso;
900 pDynamic->highth_time = pCalibdb->TuningPara.Dynamic.HighTh_time;
901
902 //LOGD_ANR("dynamic final param mode:%d \n", mode_idx);
903 return res;
904
905 }
906
mfnr_config_setting_param_json(RKAnr_Mfnr_Params_t * pParams,CalibDbV2_MFNR_t * pCalibdb,char * param_mode,char * snr_name)907 ANRresult_t mfnr_config_setting_param_json(RKAnr_Mfnr_Params_t *pParams, CalibDbV2_MFNR_t *pCalibdb, char* param_mode, char* snr_name)
908 {
909 ANRresult_t res = ANR_RET_SUCCESS;
910 int calib_idx = 0;
911 int setting_idx = 0;
912
913 if(pParams == NULL) {
914 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
915 return ANR_RET_NULL_POINTER;
916 }
917
918 if(pCalibdb == NULL) {
919 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
920 return ANR_RET_NULL_POINTER;
921 }
922
923 if(param_mode == NULL) {
924 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
925 return ANR_RET_NULL_POINTER;
926 }
927
928 if(snr_name == NULL) {
929 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
930 return ANR_RET_NULL_POINTER;
931 }
932
933 res = mfnr_get_setting_idx_by_name_json(pCalibdb, snr_name, &calib_idx, &setting_idx);
934 if(res != ANR_RET_SUCCESS) {
935 LOGW_ANR("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
936 }
937
938 res = init_mfnr_params_json(pParams, pCalibdb, calib_idx, setting_idx);
939
940 LOGD_ANR("final param mode:%d snr_mode:%d\n", calib_idx, setting_idx);
941 return res;
942
943 }
944
945
select_mfnr_params_by_ISO(RKAnr_Mfnr_Params_t * stmfnrParams,RKAnr_Mfnr_Params_Select_t * stmfnrParamsSelected,ANRExpInfo_t * pExpInfo,int bits_proc)946 ANRresult_t select_mfnr_params_by_ISO(RKAnr_Mfnr_Params_t *stmfnrParams, RKAnr_Mfnr_Params_Select_t *stmfnrParamsSelected, ANRExpInfo_t *pExpInfo, int bits_proc)
947 {
948 ANRresult_t res = ANR_RET_SUCCESS;
949 int iso = 50;
950
951 if(stmfnrParams == NULL) {
952 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
953 return ANR_RET_NULL_POINTER;
954 }
955
956 if(stmfnrParamsSelected == NULL) {
957 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
958 return ANR_RET_NULL_POINTER;
959 }
960
961 if(pExpInfo == NULL) {
962 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
963 return ANR_RET_NULL_POINTER;
964 }
965
966 if(pExpInfo->mfnr_mode_3to1) {
967 iso = pExpInfo->preIso[pExpInfo->hdr_mode];
968 } else {
969 iso = pExpInfo->arIso[pExpInfo->hdr_mode];
970 }
971
972 int i, j;
973 int iso_low = iso, iso_high = iso;
974 int gain_high = 0, gain_low = 0;
975 double ratio = 0.0f;
976 int iso_div = 50;
977 int dir_num = MFNR_DIR_NUM;
978 int polyorder = MFNR_POLYORDER;
979 int max_lvl = MFNR_MAX_LVL;
980 int max_lvl_uv = MFNR_MAX_LVL_UV;
981 int lumancurve_step = LUMANRCURVE_STEP;
982 int range = (1 << (Y_CALIBRATION_BITS - ANR_MFNR_SIGMA_X_SHIFT_BITS));
983 int step = (1 << (Y_CALIBRATION_BITS - bits_proc - ANR_MFNR_SIGMA_X_SHIFT_BITS));
984 int step_x = (1 << (Y_CALIBRATION_BITS - Y_SIGMA_TABLE_BITS - ANR_MFNR_SIGMA_X_SHIFT_BITS));
985 int step_x1 = (1 << (Y_CALIBRATION_BITS - bits_proc - ANR_MFNR_SIGMA_X_SHIFT_BITS));
986 //int step_y = (1 << (Y_CALIBRATION_BITS - bits_proc));
987 int step_x_dehz = (1 << (Y_CALIBRATION_BITS - Y_SIGMA_TABLE_BITS_DEHAZE - ANR_MFNR_SIGMA_X_SHIFT_BITS));
988 double noise_sigma_tmp[(1 << (Y_CALIBRATION_BITS - ANR_MFNR_SIGMA_X_SHIFT_BITS) ) + 1];
989
990 #ifndef RK_SIMULATOR_HW
991 for (i = 0; i < MAX_ISO_STEP - 1; i++) {
992 if(iso >= stmfnrParams->iso[i] && iso <= stmfnrParams->iso[i + 1]) {
993 iso_low = stmfnrParams->iso[i];
994 iso_high = stmfnrParams->iso[i + 1];
995 gain_low = i;
996 gain_high = i + 1;
997 ratio = (double)(iso - iso_low) / (iso_high - iso_low);
998 break;
999 }
1000 }
1001
1002 if(i == MAX_ISO_STEP - 1) {
1003 if(iso < stmfnrParams->iso[0]) {
1004 iso_low = stmfnrParams->iso[0];
1005 iso_high = stmfnrParams->iso[1];
1006 gain_low = 0;
1007 gain_high = 1;
1008 ratio = 0;
1009 }
1010
1011 if(iso > stmfnrParams->iso[MAX_ISO_STEP - 1]) {
1012 iso_low = stmfnrParams->iso[MAX_ISO_STEP - 2];
1013 iso_high = stmfnrParams->iso[MAX_ISO_STEP - 1];
1014 gain_low = MAX_ISO_STEP - 2;
1015 gain_high = MAX_ISO_STEP - 1;
1016 ratio = 1;
1017 }
1018 }
1019 #else
1020 for (i = MAX_ISO_STEP - 1; i >= 0; i--)
1021 {
1022 if (iso < iso_div * (2 << i))
1023 {
1024 iso_low = iso_div * (2 << (i)) / 2;
1025 iso_high = iso_div * (2 << i);
1026 }
1027 }
1028 ratio = (double)(iso - iso_low) / (iso_high - iso_low);
1029 if (iso_low == iso)
1030 {
1031 iso_high = iso;
1032 ratio = 0;
1033 }
1034 if (iso_high == iso )
1035 {
1036 iso_low = iso;
1037 ratio = 1;
1038 }
1039 gain_high = (int)(log((double)iso_high / 50) / log((double)2));
1040 gain_low = (int)(log((double)iso_low / 50) / log((double)2));
1041 #endif
1042
1043
1044 LOGD_ANR("%s:%d iso:%d high:%d low:%d ratio:%f \n",
1045 __FUNCTION__, __LINE__,
1046 iso, iso_high, iso_low, ratio);
1047
1048
1049 stmfnrParamsSelected->back_ref_num = stmfnrParams->back_ref_num;
1050 for(int lvl = 0; lvl < max_lvl; lvl++)
1051 stmfnrParamsSelected->weight_limit_y[lvl] = ratio * (stmfnrParams->weight_limit_y[gain_high][lvl] - stmfnrParams->weight_limit_y[gain_low][lvl]) + stmfnrParams->weight_limit_y[gain_low][lvl];;
1052 for(int lvl = 0; lvl < max_lvl_uv; lvl++)
1053 stmfnrParamsSelected->weight_limit_uv[lvl] = ratio * (stmfnrParams->weight_limit_uv[gain_high][lvl] - stmfnrParams->weight_limit_uv[gain_low][lvl]) + stmfnrParams->weight_limit_uv[gain_low][lvl];;
1054 for(int i = 0; i < 4; i++)
1055 stmfnrParamsSelected->ratio_frq[i] = ratio * (stmfnrParams->ratio_frq[gain_high][i] - stmfnrParams->ratio_frq[gain_low][i]) + stmfnrParams->ratio_frq[gain_low][i];
1056
1057 for(int lvl = 0; lvl < max_lvl_uv; lvl++)
1058 stmfnrParamsSelected->luma_w_in_chroma[lvl] = ratio * (stmfnrParams->luma_w_in_chroma[gain_high][lvl] - stmfnrParams->luma_w_in_chroma[gain_low][lvl]) + stmfnrParams->luma_w_in_chroma[gain_low][lvl];
1059 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1060 for (j = 0; j < max_lvl; j++)
1061 {
1062 stmfnrParamsSelected->ci[dir_idx][j] = ratio * (1 / stmfnrParams->ci[gain_high][dir_idx][j] - 1 / stmfnrParams->ci[gain_low][dir_idx][j]) + 1 / stmfnrParams->ci[gain_low][dir_idx][j];
1063 }
1064 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1065 for (j = 0; j < max_lvl; j++)
1066 {
1067 stmfnrParamsSelected->dnweight[dir_idx][j] = ratio * (stmfnrParams->dnweight[gain_high][dir_idx][j] - stmfnrParams->dnweight[gain_low][dir_idx][j]) + stmfnrParams->dnweight[gain_low][dir_idx][j];
1068 }
1069
1070 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1071 for (j = 0; j < max_lvl; j++)
1072 {
1073 stmfnrParamsSelected->scale[dir_idx][j] = ratio * (stmfnrParams->scale[gain_high][dir_idx][j] - stmfnrParams->scale[gain_low][dir_idx][j]) + stmfnrParams->scale[gain_low][dir_idx][j];
1074 }
1075 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1076 for (j = 0; j < lumancurve_step; j++)
1077 {
1078 stmfnrParamsSelected->lumanrpoint[dir_idx][j] = ratio * (stmfnrParams->lumanrpoint[gain_high][dir_idx][j] - stmfnrParams->lumanrpoint[gain_low][dir_idx][j]) + stmfnrParams->lumanrpoint[gain_low][dir_idx][j];
1079 stmfnrParamsSelected->lumanrcurve[dir_idx][j] = ratio * (stmfnrParams->lumanrcurve[gain_high][dir_idx][j] - stmfnrParams->lumanrcurve[gain_low][dir_idx][j]) + stmfnrParams->lumanrcurve[gain_low][dir_idx][j];
1080 }
1081 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1082 stmfnrParamsSelected->dnstr[dir_idx] = ratio * (stmfnrParams->dnstr[gain_high][dir_idx] - stmfnrParams->dnstr[gain_low][dir_idx]) + stmfnrParams->dnstr[gain_low][dir_idx];
1083 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1084 for (int lvl = 0; lvl < max_lvl; lvl++)
1085 {
1086 for(int i = 0; i < MFNR_MAX_GAUS_SIZE; i++)
1087 stmfnrParamsSelected->gfdelta[dir_idx][lvl][i] = ratio * (stmfnrParams->gfdelta[gain_high][dir_idx][lvl][i] - stmfnrParams->gfdelta[gain_low][dir_idx][lvl][i]) + stmfnrParams->gfdelta[gain_low][dir_idx][lvl][i];
1088 }
1089
1090 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1091 for (j = 0; j < max_lvl_uv; j++)
1092 {
1093 stmfnrParamsSelected->ci_uv[dir_idx][j] = ratio * (1 / stmfnrParams->ci_uv[gain_high][dir_idx][j] - 1 / stmfnrParams->ci_uv[gain_low][dir_idx][j]) + 1 / stmfnrParams->ci_uv[gain_low][dir_idx][j];
1094 stmfnrParamsSelected->dnweight_uv[dir_idx][j] = ratio * (stmfnrParams->dnweight_uv[gain_high][dir_idx][j] - stmfnrParams->dnweight_uv[gain_low][dir_idx][j]) + stmfnrParams->dnweight_uv[gain_low][dir_idx][j];
1095 stmfnrParamsSelected->scale_uv[dir_idx][j] = ratio * (stmfnrParams->scale_uv[gain_high][dir_idx][j] - stmfnrParams->scale_uv[gain_low][dir_idx][j]) + stmfnrParams->scale_uv[gain_low][dir_idx][j];
1096 }
1097 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1098 for (j = 0; j < lumancurve_step; j++)
1099 {
1100 stmfnrParamsSelected->lumanrpoint_uv[dir_idx][j] = ratio * (stmfnrParams->lumanrpoint_uv[gain_high][dir_idx][j] - stmfnrParams->lumanrpoint_uv[gain_low][dir_idx][j]) + stmfnrParams->lumanrpoint_uv[gain_low][dir_idx][j];
1101 stmfnrParamsSelected->lumanrcurve_uv[dir_idx][j] = ratio * (stmfnrParams->lumanrcurve_uv[gain_high][dir_idx][j] - stmfnrParams->lumanrcurve_uv[gain_low][dir_idx][j]) + stmfnrParams->lumanrcurve_uv[gain_low][dir_idx][j];
1102 }
1103 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1104 stmfnrParamsSelected->dnstr_uv[dir_idx] = ratio * (stmfnrParams->dnstr_uv[gain_high][dir_idx] - stmfnrParams->dnstr_uv[gain_low][dir_idx]) + stmfnrParams->dnstr_uv[gain_low][dir_idx];
1105
1106 for (int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1107 for (int lvl = 0; lvl < max_lvl; lvl++)
1108 {
1109 for(int i = 0; i < MFNR_MAX_GAUS_SIZE; i++)
1110 stmfnrParamsSelected->gfdelta_uv[dir_idx][lvl][i] = ratio * (stmfnrParams->gfdelta_uv[gain_high][dir_idx][lvl][i] - stmfnrParams->gfdelta_uv[gain_low][dir_idx][lvl][i]) + stmfnrParams->gfdelta_uv[gain_low][dir_idx][lvl][i];
1111 }
1112
1113
1114
1115
1116 for (int lvl = 0; lvl < max_lvl; lvl++)
1117 {
1118 for(int i = 0; i < MFNR_MAX_GAUS_SIZE; i++)
1119 stmfnrParamsSelected->gfsigma[lvl][i] = ratio * (stmfnrParams->gfsigma[gain_high][lvl][i] - stmfnrParams->gfsigma[gain_low][lvl][i]) + stmfnrParams->gfsigma[gain_low][lvl][i];
1120 }
1121
1122 for (i = 0; i < range; i++)
1123 noise_sigma_tmp[i] = (ratio * (stmfnrParams->noise_sigma[gain_high][i] - stmfnrParams->noise_sigma[gain_low][i]) + stmfnrParams->noise_sigma[gain_low][i]);
1124 noise_sigma_tmp[range] = noise_sigma_tmp[range - 1];
1125
1126 int max_pos[2];
1127 int min_pos[2];
1128 int intep_pos_flg[POLT_ORDER + 2];
1129 int intep_pos[POLT_ORDER + 2];
1130 int fix_x_pos[MAX_INTEPORATATION_LUMAPOINT];
1131 int max_idx = 0;
1132 int min_idx = 0;
1133 int intep_num = 0;
1134 int intep_num_1 = 0;
1135 #if 1
1136 for(i = 1; i < MAX(stmfnrParams->curve_x0[gain_high], stmfnrParams->curve_x0[gain_low]); i++)
1137 {
1138 if(noise_sigma_tmp[i] > noise_sigma_tmp[i - 1] && noise_sigma_tmp[i] > noise_sigma_tmp[i + 1])
1139 {
1140 max_pos[max_idx] = i;
1141 max_idx++;
1142 }
1143 if(noise_sigma_tmp[i] < noise_sigma_tmp[i - 1] && noise_sigma_tmp[i] < noise_sigma_tmp[i + 1])
1144 {
1145 min_pos[min_idx] = i;
1146 min_idx++;
1147 }
1148 }
1149 intep_pos[intep_num++] = 0;
1150 intep_pos[intep_num++] = MAX(stmfnrParams->curve_x0[gain_high], stmfnrParams->curve_x0[gain_low]);
1151 for(i = 0; i < max_idx; i++)
1152 intep_pos[intep_num++] = max_pos[i];
1153 for(i = 0; i < MIN(1, min_idx); i++)// only 1 min point is allowed
1154 intep_pos[intep_num++] = min_pos[i];
1155 for(i = 0; i < intep_num; i++) {
1156 for(j = i; j < intep_num; j++)
1157 {
1158 if(intep_pos[i] > intep_pos[j])
1159 {
1160 int temp;
1161 temp = intep_pos[i];
1162 intep_pos[i] = intep_pos[j];
1163 intep_pos[j] = temp;
1164
1165 }
1166 }
1167 }
1168
1169 intep_pos[intep_num++] = range;
1170 #endif
1171
1172 #if 1
1173 #if 1
1174 for (i = 1; i < intep_num; i++)
1175 {
1176 if(i == 1)
1177 intep_pos[i] = ROUND_F(intep_pos[i] / (step_x1 * 4)) * (4 * step_x1);
1178 else
1179 intep_pos[i] = ROUND_F(intep_pos[i] / (step_x1 * 16)) * (16 * step_x1);
1180 }
1181 memset(intep_pos_flg, 0, sizeof(intep_pos_flg));
1182 for (i = 1; i < intep_num; i++)
1183 {
1184 if(intep_pos[i - 1] == intep_pos[i])
1185 intep_pos_flg[i] = 1;
1186 }
1187 for (int i = 0, j = 0; i < intep_num; i++)
1188 {
1189 if(intep_pos_flg[i] == 0)
1190 {
1191 intep_pos[j] = intep_pos[i];
1192 j++;
1193 }
1194 }
1195 intep_num = j;
1196
1197
1198 int off = 0;
1199 int st;
1200 int idx;
1201 int off4 = (0x4 * step_x1);
1202 int off8 = (0x8 * step_x1);
1203 int off16 = (0x10 * step_x1);
1204 int off32 = (0x20 * step_x1);
1205 for (int i = 0, idx = 1; i < MAX_INTEPORATATION_LUMAPOINT - 1; i++)
1206 {
1207 int cur_pos;
1208 if(idx >= intep_num && off >= range)
1209 {
1210
1211 fix_x_pos[intep_num_1++] = range;
1212 continue;
1213 }
1214 cur_pos = intep_pos[idx];
1215 fix_x_pos[intep_num_1++] = off;
1216
1217 if(off & off4)
1218 st = off4;
1219 else if(off & off8)
1220 st = off8;
1221 else if((off < 64 * step_x1) || (off & off16))
1222 st = off16;
1223 else
1224 st = off32;
1225 if(off + st > cur_pos && off != cur_pos)
1226 {
1227 if((cur_pos - off) & off4)
1228 st = off4;
1229 else if((cur_pos - off) & off8)
1230 st = off8;
1231 else if((cur_pos - off) & off16)
1232 st = off16;
1233 else
1234 st = off32;
1235 }
1236 if(off + st == cur_pos)
1237 idx++;
1238
1239 off += st;
1240
1241 }
1242 fix_x_pos[intep_num_1++] = range;
1243 #else
1244 for(int i = 0, idx = 1; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1245 fix_x_pos[intep_num_1++] = i * (range / (MAX_INTEPORATATION_LUMAPOINT - 1));
1246 #endif
1247
1248
1249
1250 for (i = 0; i < range; i += step_x)
1251 stmfnrParamsSelected->noise_sigma[i / step_x] = noise_sigma_tmp[i] ;
1252
1253 for (i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++) {
1254 stmfnrParamsSelected->noise_sigma_sample[i] = noise_sigma_tmp[fix_x_pos[i]];
1255 stmfnrParamsSelected->noise_sigma_sample[i] = ABS(stmfnrParamsSelected->noise_sigma_sample[i]);
1256 }
1257 for (i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1258 stmfnrParamsSelected->fix_x_pos[i] = fix_x_pos[i] / step_x;
1259
1260
1261 for (i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++) {
1262 stmfnrParamsSelected->noise_sigma_dehaze[i] = noise_sigma_tmp[fix_x_pos[i]];
1263 stmfnrParamsSelected->noise_sigma_dehaze[i] = ABS(stmfnrParamsSelected->noise_sigma_dehaze[i]);
1264 }
1265 for (i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1266 stmfnrParamsSelected->fix_x_pos_dehaze[i] = fix_x_pos[i] / step_x_dehz;
1267
1268
1269 #else
1270 for (i = 0; i < range; i += step)
1271 stmfnrParamsSelected->noise_sigma[i / step] = noise_sigma_tmp[i] / step;
1272
1273 int gap_num[POLT_ORDER] = {6, 6, 2, 2};
1274 int gap_piece = 8;
1275 int gap_rat[POLT_ORDER][5] = {{1, 2, 4, 6, 7}, {1, 2, 4, 6, 7}, {4, 8, 4, 4, 4}, {8, 8, 8, 8, 8}};
1276
1277 for (i = 0; i < intep_num - 1; i++)
1278 {
1279 int left_pos = intep_pos[i];
1280 int right_pos = intep_pos[i + 1];
1281 int gap_num_cur = gap_num[i];
1282 intep_pos_1[intep_num_1++] = intep_pos[i];
1283 for (j = 0; j < gap_num_cur - 1; j++)
1284 {
1285 intep_pos_1[intep_num_1++] = ceil(left_pos + (double)(right_pos - left_pos) * gap_rat[i][j] / gap_piece);
1286 }
1287 }
1288
1289 for (int idx = intep_num_1; idx < MAX_INTEPORATATION_LUMAPOINT - 1; idx++)
1290 {
1291 intep_pos_1[idx] = intep_pos[intep_num - 1];
1292 }
1293
1294 intep_pos_1[MAX_INTEPORATATION_LUMAPOINT - 1] = range;
1295
1296 for (int idx = 0; idx < MAX_INTEPORATATION_LUMAPOINT; idx++)
1297 {
1298 intep_pos_1[idx] = ROUND_F((double)intep_pos_1[idx] / step) * step;
1299 }
1300
1301
1302 for (int idx = 0; idx < intep_num; idx++)
1303 {
1304 intep_pos[idx] = ROUND_F((double)intep_pos[idx] / step) * step;
1305 }
1306
1307
1308 for (i = 0; i < intep_num_1 - 1; i++)
1309 {
1310 int left_pos = intep_pos_1[i] ;
1311 int right_pos = intep_pos_1[i + 1];
1312 double left_val = noise_sigma_tmp[intep_pos_1[i]];
1313 double right_val = noise_sigma_tmp[intep_pos_1[i + 1]];
1314 for(j = left_pos; j < right_pos; j++)
1315 {
1316 if(j == 112)
1317 j = j;
1318 if(j != left_pos && j != right_pos)
1319 noise_sigma_tmp[j] = (left_val * (right_pos - j) + right_val * (j - left_pos)) / (right_pos - left_pos);
1320 }
1321 }
1322
1323 for (i = 0; i < range; i += step)
1324 stmfnrParamsSelected->noise_sigma_intep[i / step] = noise_sigma_tmp[i] / step;
1325
1326 for (i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1327 stmfnrParamsSelected->intep_pos_1[i] = intep_pos_1[i] / step;
1328
1329 for (i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1330 stmfnrParamsSelected->noise_sigma_dehaze[i] = noise_sigma_tmp[intep_pos_1[i] ] / step;
1331
1332 #endif
1333
1334 #if 1
1335 if(stmfnrParams->motion_detection_enable) {
1336 stmfnrParamsSelected->mfnr_sigma_scale = ((stmfnrParams->mfnr_sigma_scale[gain_high] * ratio + stmfnrParams->mfnr_sigma_scale[gain_low] * (1 - ratio))) ;
1337 } else {
1338 stmfnrParamsSelected->mfnr_sigma_scale = 1.0;
1339 }
1340 LOGD_ANR("mfnr motion detetion enable:%d mfnr_sigma_scale:%f\n",
1341 stmfnrParams->motion_detection_enable,
1342 stmfnrParamsSelected->mfnr_sigma_scale);
1343 #endif
1344 //for (i = 0; i < range; i++)
1345 // noise_sigma_tmp[i] = ROUND_F(noise_sigma_tmp[i] * (1 << 12)) >> ;
1346
1347
1348 double noise_sigma_max = 0;
1349 double noise_sigma_limit = 1 << MFNR_F_INTE_SIGMA;
1350 double sigma_scale = 1.0;
1351 double scale_scale = 1.0;
1352 for(int i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1353 noise_sigma_max = MAX(stmfnrParamsSelected->noise_sigma_sample[i], noise_sigma_max);
1354
1355 if(noise_sigma_max * stmfnrParamsSelected->mfnr_sigma_scale <= noise_sigma_limit) {
1356 scale_scale = 1;
1357 sigma_scale = stmfnrParamsSelected->mfnr_sigma_scale;
1358 } else {
1359 scale_scale = noise_sigma_limit / (noise_sigma_max * stmfnrParamsSelected->mfnr_sigma_scale);
1360 sigma_scale = stmfnrParamsSelected->mfnr_sigma_scale * scale_scale;
1361 }
1362
1363 if(scale_scale != 1.0 || sigma_scale != 1.0)
1364 {
1365 for(int i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1366 stmfnrParamsSelected->noise_sigma_sample[i] = stmfnrParamsSelected->noise_sigma_sample[i] * sigma_scale;
1367 for(int i = 0; i < MAX_INTEPORATATION_LUMAPOINT; i++)
1368 stmfnrParamsSelected->noise_sigma_dehaze[i] = stmfnrParamsSelected->noise_sigma_dehaze[i] * sigma_scale;
1369 for(int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1370 for(int lvl = 0; lvl < max_lvl; lvl++)
1371 stmfnrParamsSelected->scale[dir_idx][lvl] = stmfnrParamsSelected->scale[dir_idx][lvl] * scale_scale;
1372 for(int dir_idx = 0; dir_idx < dir_num; dir_idx++)
1373 for(int lvl = 0; lvl < max_lvl_uv; lvl++)
1374 stmfnrParamsSelected->scale_uv[dir_idx][lvl] = stmfnrParamsSelected->scale_uv[dir_idx][lvl] * scale_scale;
1375 }
1376
1377 LOGD_ANR("mfnr final sigma_max:%f motion_scale:%f sigma_limit:%f sigma_scale:%f scale_scale:%f\n",
1378 noise_sigma_max,
1379 stmfnrParamsSelected->mfnr_sigma_scale,
1380 noise_sigma_limit,
1381 sigma_scale,
1382 scale_scale);
1383
1384 return res;
1385
1386 }
1387
1388
1389 template<typename T1, typename T2>
FIX_FLOAT(T1 data0,int bits,T2 & dst,int flag=0)1390 T1 FIX_FLOAT(T1 data0, int bits, T2 &dst, int flag = 0)
1391 {
1392 if(flag == 0)
1393 dst = (T2)ROUND_D(data0 * (1 << bits));
1394 else
1395 dst = (T2)FLOOR_INT64(data0 * (1 << bits));
1396 return ((T1)dst / (1 << bits));
1397
1398 }
1399
1400
1401 template<typename T1>
FX_CLP(T1 data0,int inte_bit,int deci_bit)1402 T1 FX_CLP(T1 data0, int inte_bit, int deci_bit)
1403 {
1404 int64_t tmp0;
1405 int64_t max_val;
1406 int64_t min_val;
1407 int64_t out;
1408 tmp0 = (int64_t)(data0 * (1 << deci_bit));
1409 max_val = (((int64_t)1 << (deci_bit + inte_bit)) - 1);
1410 min_val = (-((int64_t)1 << (deci_bit + inte_bit)) + 1);
1411 out = MIN(MAX(min_val, tmp0), max_val);
1412 return (T1)out / (1 << deci_bit);//->dst_shr_off64, round_val64, and_val64, round_bits);
1413
1414 }
1415
1416
get_matrix_idx(int i,int j,int rad)1417 int get_matrix_idx(int i, int j, int rad)
1418 {
1419 int src_i = 0;
1420 int i_act, j_act;
1421 if(i > rad)
1422 i_act = 2 * rad - i;
1423 else
1424 i_act = i;
1425
1426 if(j > rad)
1427 j_act = 2 * rad - j;
1428 else
1429 j_act = j;
1430
1431 if(j_act < i_act) {
1432 int tmp;
1433 tmp = j_act;
1434 j_act = i_act;
1435 i_act = tmp;
1436 }
1437
1438 for(int ii = rad; ii >= 0; ii--) {
1439 for(int jj = rad; jj >= ii; jj--) {
1440 if(i_act == ii && j_act == jj) {
1441 return src_i;
1442 }
1443 src_i++;
1444 }
1445 }
1446
1447 return -1;
1448 }
1449
1450
mfnr_gfcoef_fix(int rad,double * gfcoef,unsigned char * gfcoef_fix)1451 void mfnr_gfcoef_fix(int rad, double *gfcoef, unsigned char* gfcoef_fix)
1452 {
1453 double sum_d2;
1454 double *h;
1455 unsigned long tmp;
1456
1457 h = (double*)malloc((rad * 2 + 1) * (rad * 2 + 1) * sizeof(double));
1458 sum_d2 = 0;
1459 for(int i = 0; i < (rad * 2 + 1); i++) {
1460 for(int j = 0; j < (rad * 2 + 1); j++) {
1461 int src_i = get_matrix_idx(i, j, rad);
1462 if(src_i == -1) {
1463 LOGE_ANR("get_matrix_idx is error \n");
1464 }
1465 h[i * (rad * 2 + 1) + j] = FIX_FLOAT((double)gfcoef[src_i], F_DECI_PIXEL_SIGMA_CONV_WEIGHT, tmp);
1466 gfcoef_fix[src_i] = tmp;
1467 sum_d2 += h[i * (rad * 2 + 1) + j];
1468 }
1469 }
1470 int idx = ((rad * 2 + 1) * rad + rad);
1471 h[idx] = FIX_FLOAT(h[idx] + (1 - sum_d2), F_DECI_PIXEL_SIGMA_CONV_WEIGHT, tmp);
1472 gfcoef_fix[0] = tmp;
1473 free(h);
1474
1475 }
1476
1477
mfnr_fix_transfer(RKAnr_Mfnr_Params_Select_t * tnr,RKAnr_Mfnr_Fix_t * pMfnrCfg,ANRExpInfo_t * pExpInfo,float gain_ratio,float fLumaStrength,float fChromaStrength)1478 ANRresult_t mfnr_fix_transfer(RKAnr_Mfnr_Params_Select_t* tnr, RKAnr_Mfnr_Fix_t *pMfnrCfg, ANRExpInfo_t *pExpInfo, float gain_ratio, float fLumaStrength, float fChromaStrength)
1479 {
1480 LOGI_ANR("%s:(%d) enter \n", __FUNCTION__, __LINE__);
1481
1482 ANRresult_t res = ANR_RET_SUCCESS;
1483
1484 if(tnr == NULL) {
1485 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1486 return ANR_RET_NULL_POINTER;
1487 }
1488
1489 if(pMfnrCfg == NULL) {
1490 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1491 return ANR_RET_NULL_POINTER;
1492 }
1493
1494 if(pExpInfo == NULL) {
1495 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1496 return ANR_RET_NULL_POINTER;
1497 }
1498
1499 LOGD_ANR("%s:%d iso:%d strength:%f\n", __FUNCTION__, __LINE__, pExpInfo->arIso[pExpInfo->hdr_mode], fLumaStrength);
1500 if(fLumaStrength <= 0.0) {
1501 fLumaStrength = 0.000001;
1502 }
1503
1504 int i = 0;
1505 unsigned long tmp = 0;
1506 int mIso_last = 50;
1507 int mIso = 50;
1508 if(pExpInfo->mfnr_mode_3to1) {
1509 mIso_last = pExpInfo->preIso[pExpInfo->hdr_mode];
1510 mIso = pExpInfo->arIso[pExpInfo->hdr_mode];
1511 } else {
1512 mIso_last = pExpInfo->arIso[pExpInfo->hdr_mode];
1513 mIso = pExpInfo->arIso[pExpInfo->hdr_mode];
1514 }
1515 double gain_glb_filt;
1516 double gain_glb_ref1;
1517 double gain_glb_filt_sqrt;
1518 double gain_glb_filt_sqrt_inv;
1519 double scale_l_y [MFNR_DIR_NUM][MFNR_MAX_LVL];
1520 double scale_l_y_uv [MFNR_DIR_NUM][MFNR_MAX_LVL_UV];
1521 double scale_l_uv [MFNR_DIR_NUM][MFNR_MAX_LVL_UV];
1522 double ratio_frq_sub_div [2];
1523 int max_lvl = MFNR_MAX_LVL;
1524 int max_lvl_uv = MFNR_MAX_LVL_UV;
1525 int dir_num = MFNR_DIR_NUM;
1526
1527
1528 int rad_isp20[2][5] = {{2, 1, 1, 1, 1}, {2, 1, 1, 1, 1}};
1529 int rad_uv_isp20[2][5] = {{2, 1, 1, 1, 1}, {2, 1, 1, 1, 1}};
1530 gain_glb_filt = (mIso_last / 50 * gain_ratio);
1531 gain_glb_ref1 = (mIso / 50 * gain_ratio);//ref1
1532 gain_glb_filt_sqrt = sqrt(gain_glb_filt);
1533 gain_glb_filt_sqrt_inv = 1 / sqrt(gain_glb_filt);
1534
1535 for(int dir_idx = 0; dir_idx < dir_num; dir_idx++) {
1536 for(int lvl = 0; lvl < max_lvl; lvl++)
1537 scale_l_y[dir_idx][lvl] = tnr->ci[dir_idx][lvl] * tnr->scale[dir_idx][lvl] / (tnr->dnstr[dir_idx] * fLumaStrength);
1538 }
1539 for(int dir_idx = 0; dir_idx < dir_num; dir_idx++) {
1540 for(int lvl = 0; lvl < max_lvl_uv; lvl++) {
1541 scale_l_y_uv[dir_idx][lvl] = tnr->ci[dir_idx][lvl] * tnr->scale_uv[dir_idx][lvl] / (tnr->dnstr_uv[dir_idx] * fChromaStrength);
1542 scale_l_uv[dir_idx][lvl] = tnr->ci_uv[dir_idx][lvl] * tnr->scale_uv[dir_idx][lvl] / (tnr->dnstr_uv[dir_idx] * fChromaStrength);
1543 }
1544 }
1545
1546 //0x0080
1547 pMfnrCfg->mode = 0;
1548 pMfnrCfg->opty_en = 1;
1549 pMfnrCfg->optc_en = 1;
1550 pMfnrCfg->gain_en = 1;
1551
1552 //0x0088
1553 tmp = (tnr->weight_limit_y[0] / fLumaStrength);
1554 if(tmp > 0xff) {
1555 tmp = 0xff;
1556 }
1557 pMfnrCfg->pk0_y = (unsigned char)tmp;
1558
1559 tmp = (tnr->weight_limit_y[max_lvl - 1] / fLumaStrength);
1560 if(tmp > 0xff) {
1561 tmp = 0xff;
1562 }
1563 pMfnrCfg->pk1_y = (unsigned char)tmp;
1564 tmp = (tnr->weight_limit_uv[0] / fChromaStrength );
1565 if(tmp > 0xff) {
1566 tmp = 0xff;
1567 }
1568 pMfnrCfg->pk0_c = (unsigned char)tmp;
1569 tmp = (tnr->weight_limit_uv[max_lvl_uv - 1] / fChromaStrength);
1570 if(tmp > 0xff) {
1571 tmp = 0xff;
1572 }
1573 pMfnrCfg->pk1_c = (unsigned char)tmp;
1574
1575 //0x008c
1576 FIX_FLOAT(gain_glb_filt, F_DECI_GAIN, tmp, 0);
1577 if(tmp > 0xffff) {
1578 tmp = 0xffff;
1579 }
1580 pMfnrCfg->glb_gain_cur = tmp;
1581 FIX_FLOAT(gain_glb_ref1, F_DECI_GAIN, tmp);
1582 if(tmp > 0xffff) {
1583 tmp = 0xffff;
1584 }
1585 pMfnrCfg->glb_gain_nxt = tmp;
1586
1587 //0x0090
1588 gain_glb_filt_sqrt_inv = FX_CLP(gain_glb_filt_sqrt_inv, F_INTE_GAIN_GLB_SQRT_INV, F_DECI_GAIN_GLB_SQRT_INV);
1589 FIX_FLOAT(gain_glb_filt_sqrt_inv, F_DECI_GAIN_GLB_SQRT_INV, tmp);
1590 if(tmp > 0x1fff) {
1591 tmp = 0x1fff;
1592 }
1593 pMfnrCfg->glb_gain_cur_div = tmp;
1594 FIX_FLOAT(gain_glb_filt_sqrt, F_DECI_GAIN_GLB_SQRT, tmp);
1595 if(tmp > 0xff) {
1596 tmp = 0xff;
1597 }
1598 pMfnrCfg->glb_gain_cur_sqrt = tmp;
1599
1600 //0x0094 - 0x0098
1601 for(i = 0; i < 17 - 1; i++) {
1602 pMfnrCfg->sigma_x[i] = log((double)(tnr->fix_x_pos[i + 1] - tnr->fix_x_pos[i])) / log((double)2) - 2;
1603 }
1604
1605 //0x009c - 0x00bc
1606 for(i = 0; i < 17; i++) {
1607 FIX_FLOAT(tnr->noise_sigma_sample[i], F_DECI_SIGMA, tmp);
1608 pMfnrCfg->sigma_y[i] = tmp;
1609 }
1610
1611 //0x00c4 - 0x00cc
1612 //dir_idx = 0;
1613 for(i = 0; i < 6; i++) {
1614 FIX_FLOAT(tnr->lumanrcurve[0][i], F_DECI_LUMASCALE, tmp);
1615 pMfnrCfg->luma_curve[i] = tmp;
1616 }
1617
1618 //0x00d0
1619 FIX_FLOAT(tnr->ratio_frq[0], F_DECI_TXT_THRD_RATIO, tmp);
1620 pMfnrCfg->txt_th0_y = tmp;
1621 FIX_FLOAT(tnr->ratio_frq[1], F_DECI_TXT_THRD_RATIO, tmp);
1622 pMfnrCfg->txt_th1_y = tmp;
1623
1624 //0x00d4
1625 FIX_FLOAT(tnr->ratio_frq[2], F_DECI_TXT_THRD_RATIO, tmp);
1626 pMfnrCfg->txt_th0_c = tmp;
1627 FIX_FLOAT(tnr->ratio_frq[3], F_DECI_TXT_THRD_RATIO, tmp);
1628 pMfnrCfg->txt_th1_c = tmp;
1629
1630 //0x00d8
1631 ratio_frq_sub_div[0] = 1 / (tnr->ratio_frq[1] - tnr->ratio_frq[0]);
1632 ratio_frq_sub_div[1] = 1 / (tnr->ratio_frq[3] - tnr->ratio_frq[2]);
1633 FIX_FLOAT(ratio_frq_sub_div[0], F_DECI_TXT_THRD_RATIO, tmp, 1);
1634 pMfnrCfg->txt_thy_dlt = tmp;
1635 FIX_FLOAT(ratio_frq_sub_div[1], F_DECI_TXT_THRD_RATIO, tmp, 1);
1636 pMfnrCfg->txt_thc_dlt = tmp;
1637
1638 //0x00dc - 0x00ec
1639 //dir_idx = 0; lvl 0-3;
1640 //rad_isp20[dir][levl]; gfsigma[lvl]
1641 mfnr_gfcoef_fix(rad_isp20[0][0], tnr->gfsigma[0], pMfnrCfg->gfcoef_y0);
1642 mfnr_gfcoef_fix(rad_isp20[0][1], tnr->gfsigma[1], pMfnrCfg->gfcoef_y1);
1643 mfnr_gfcoef_fix(rad_isp20[0][2], tnr->gfsigma[2], pMfnrCfg->gfcoef_y2);
1644 mfnr_gfcoef_fix(rad_isp20[0][3], tnr->gfsigma[3], pMfnrCfg->gfcoef_y3);
1645
1646 //0x00f0 - 0x0100
1647 //dir_idx = 0; lvl 0-3;
1648 //rad_isp20[dir][levl]; gfdelta[[dir_idx][lvl]
1649 mfnr_gfcoef_fix(rad_isp20[0][0], tnr->gfdelta[0][0], pMfnrCfg->gfcoef_yg0);
1650 mfnr_gfcoef_fix(rad_isp20[0][1], tnr->gfdelta[0][1], pMfnrCfg->gfcoef_yg1);
1651 mfnr_gfcoef_fix(rad_isp20[0][2], tnr->gfdelta[0][2], pMfnrCfg->gfcoef_yg2);
1652 mfnr_gfcoef_fix(rad_isp20[0][3], tnr->gfdelta[0][3], pMfnrCfg->gfcoef_yg3);
1653
1654 //0x0104 - 0x0110
1655 //dir_idx = 1; lvl 0-3;
1656 //rad_isp20[dir][levl]; gfdelta[[dir_idx][lvl] ;
1657 mfnr_gfcoef_fix(rad_isp20[1][0], tnr->gfdelta[1][0], pMfnrCfg->gfcoef_yl0);
1658 mfnr_gfcoef_fix(rad_isp20[1][1], tnr->gfdelta[1][1], pMfnrCfg->gfcoef_yl1);
1659 mfnr_gfcoef_fix(rad_isp20[1][2], tnr->gfdelta[1][2], pMfnrCfg->gfcoef_yl2);
1660
1661 //0x0114 - 0x0120
1662 //dir_idx = 0; lvl 0-2;
1663 //rad_isp20[dir][levl]; gfdelta_uv[[dir_idx][lvl] ;
1664 mfnr_gfcoef_fix(rad_uv_isp20[0][0], tnr->gfdelta_uv[0][0], pMfnrCfg->gfcoef_cg0);
1665 mfnr_gfcoef_fix(rad_uv_isp20[0][1], tnr->gfdelta_uv[0][1], pMfnrCfg->gfcoef_cg1);
1666 mfnr_gfcoef_fix(rad_uv_isp20[0][2], tnr->gfdelta_uv[0][2], pMfnrCfg->gfcoef_cg2);
1667
1668 //0x0124 - 0x012c
1669 //dir_idx = 1; lvl 0-1;
1670 //rad_isp20[dir][levl]; gfdelta_uv[[dir_idx][lvl] ;
1671 mfnr_gfcoef_fix(rad_uv_isp20[1][0], tnr->gfdelta_uv[1][0], pMfnrCfg->gfcoef_cl0);
1672 mfnr_gfcoef_fix(rad_uv_isp20[1][1], tnr->gfdelta_uv[1][1], pMfnrCfg->gfcoef_cl1);
1673
1674 //0x0130 - 0x0134
1675 //dir_idx = 0; i = lvl;
1676 for(i = 0; i < 4; i++) {
1677 FIX_FLOAT(scale_l_y[0][i], F_DECI_SCALE_L, tmp);
1678 pMfnrCfg->scale_yg[i] = tmp;
1679 }
1680
1681 //0x0138 - 0x013c
1682 //dir_idx = 1; i = lvl;
1683 for(i = 0; i < 3; i++) {
1684 FIX_FLOAT(scale_l_y[1][i], F_DECI_SCALE_L, tmp);
1685 pMfnrCfg->scale_yl[i] = tmp;
1686 }
1687
1688 //0x0140 - 0x0148
1689 //dir_idx = 0; i = lvl;
1690 for(i = 0; i < 3; i++) {
1691 FIX_FLOAT(scale_l_uv[0][i], F_DECI_SCALE_L_UV, tmp);
1692 pMfnrCfg->scale_cg[i] = tmp;
1693 FIX_FLOAT(scale_l_y_uv[0][i], F_DECI_SCALE_L_UV, tmp);
1694 pMfnrCfg->scale_y2cg[i] = tmp;
1695 }
1696
1697 //0x014c - 0x0154
1698 //dir_idx = 1; i = lvl;
1699 for(i = 0; i < 2; i++) {
1700 FIX_FLOAT(scale_l_uv[1][i], F_DECI_SCALE_L_UV, tmp);
1701 pMfnrCfg->scale_cl[i] = tmp;
1702 }
1703 for(i = 0; i < 3; i++) {
1704 FIX_FLOAT(scale_l_y_uv[1][i], F_DECI_SCALE_L_UV, tmp);
1705 pMfnrCfg->scale_y2cl[i] = tmp;
1706 }
1707
1708 //0x0158
1709 for(i = 0; i < 3; i++) {
1710 FIX_FLOAT(tnr->luma_w_in_chroma[i], F_DECI_LUMA_W_IN_CHROMA, tmp);
1711 pMfnrCfg->weight_y[i] = tmp;
1712 }
1713
1714 #if MFNR_FIX_VALUE_PRINTF
1715 mfnr_fix_Printf(pMfnrCfg);
1716 #endif
1717
1718
1719 LOGI_ANR("%s:(%d) exit \n", __FUNCTION__, __LINE__);
1720
1721 return res;
1722 }
1723
1724
1725
mfnr_fix_Printf(RKAnr_Mfnr_Fix_t * pMfnrCfg)1726 ANRresult_t mfnr_fix_Printf(RKAnr_Mfnr_Fix_t * pMfnrCfg)
1727 {
1728 int i = 0;
1729 ANRresult_t res = ANR_RET_SUCCESS;
1730
1731 if(pMfnrCfg == NULL) {
1732 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1733 return ANR_RET_NULL_POINTER;
1734 }
1735
1736 LOGD_ANR("%s:(%d) enter \n", __FUNCTION__, __LINE__);
1737 //0x0080
1738 LOGD_ANR("(0x0080) mode:%d opty_en:%d optc_en:%d gain_en:%d\n",
1739 pMfnrCfg->mode,
1740 pMfnrCfg->opty_en,
1741 pMfnrCfg->optc_en,
1742 pMfnrCfg->gain_en);
1743
1744 //0x0088
1745 LOGD_ANR("(0x0088) pk0_y:%d pk1_y:%d pk0_c:%d pk1_c:%d \n",
1746 pMfnrCfg->pk0_y,
1747 pMfnrCfg->pk1_y,
1748 pMfnrCfg->pk0_c,
1749 pMfnrCfg->pk1_c);
1750
1751 //0x008c
1752 LOGD_ANR("mfnr (0x008c) glb_gain_cur:%d glb_gain_nxt:%d \n",
1753 pMfnrCfg->glb_gain_cur,
1754 pMfnrCfg->glb_gain_nxt);
1755
1756 //0x0090
1757 LOGD_ANR("(0x0090) glb_gain_cur_div:%d gain_glb_filt_sqrt:%d \n",
1758 pMfnrCfg->glb_gain_cur_div,
1759 pMfnrCfg->glb_gain_cur_sqrt);
1760
1761 //0x0094 - 0x0098
1762 for(i = 0; i < 17 - 1; i++) {
1763 LOGD_ANR("(0x0094 - 0x0098) sigma_x[%d]:%d \n",
1764 i, pMfnrCfg->sigma_x[i]);
1765 }
1766
1767 //0x009c - 0x00bc
1768 for(i = 0; i < 17; i++) {
1769 LOGD_ANR("(0x009c - 0x00bc) sigma_y[%d]:%d \n",
1770 i, pMfnrCfg->sigma_y[i]);
1771 }
1772
1773 //0x00c4 - 0x00cc
1774 //dir_idx = 0;
1775 for(i = 0; i < 6; i++) {
1776 LOGD_ANR("(0x00c4 - 0x00cc) luma_curve[%d]:%d \n",
1777 i, pMfnrCfg->luma_curve[i]);
1778 }
1779
1780 //0x00d0
1781 LOGD_ANR("(0x00d0) txt_th0_y:%d txt_th1_y:%d \n",
1782 pMfnrCfg->txt_th0_y,
1783 pMfnrCfg->txt_th1_y);
1784
1785 //0x00d4
1786 LOGD_ANR("(0x00d0) txt_th0_c:%d txt_th1_c:%d \n",
1787 pMfnrCfg->txt_th0_c,
1788 pMfnrCfg->txt_th1_c);
1789
1790 //0x00d8
1791 LOGD_ANR("(0x00d8) txt_thy_dlt:%d txt_thc_dlt:%d \n",
1792 pMfnrCfg->txt_thy_dlt,
1793 pMfnrCfg->txt_thc_dlt);
1794
1795 //0x00dc - 0x00ec
1796 for(i = 0; i < 6; i++) {
1797 LOGD_ANR("(0x00dc - 0x00ec) gfcoef_y0[%d]:%d \n",
1798 i, pMfnrCfg->gfcoef_y0[i]);
1799 }
1800 for(i = 0; i < 3; i++) {
1801 LOGD_ANR("(0x00dc - 0x00ec) gfcoef_y1[%d]:%d \n",
1802 i, pMfnrCfg->gfcoef_y1[i]);
1803 }
1804 for(i = 0; i < 3; i++) {
1805 LOGD_ANR("(0x00dc - 0x00ec) gfcoef_y2[%d]:%d \n",
1806 i, pMfnrCfg->gfcoef_y2[i]);
1807 }
1808 for(i = 0; i < 3; i++) {
1809 LOGD_ANR("(0x00dc - 0x00ec) gfcoef_y3[%d]:%d \n",
1810 i, pMfnrCfg->gfcoef_y3[i]);
1811 }
1812
1813 //0x00f0 - 0x0100
1814 for(i = 0; i < 6; i++) {
1815 LOGD_ANR("(0x00f0 - 0x0100) gfcoef_yg0[%d]:%d \n",
1816 i, pMfnrCfg->gfcoef_yg0[i]);
1817 }
1818 for(i = 0; i < 3; i++) {
1819 LOGD_ANR("(0x00f0 - 0x0100) gfcoef_yg1[%d]:%d \n",
1820 i, pMfnrCfg->gfcoef_yg1[i]);
1821 }
1822 for(i = 0; i < 3; i++) {
1823 LOGD_ANR("(0x00f0 - 0x0100) gfcoef_yg2[%d]:%d \n",
1824 i, pMfnrCfg->gfcoef_yg2[i]);
1825 }
1826 for(i = 0; i < 3; i++) {
1827 LOGD_ANR("(0x00f0 - 0x0100) gfcoef_yg3[%d]:%d \n",
1828 i, pMfnrCfg->gfcoef_yg3[i]);
1829 }
1830
1831
1832 //0x0104 - 0x0110
1833 for(i = 0; i < 6; i++) {
1834 LOGD_ANR("(0x0104 - 0x0110) gfcoef_yl0[%d]:%d \n",
1835 i, pMfnrCfg->gfcoef_yl0[i]);
1836 }
1837 for(i = 0; i < 3; i++) {
1838 LOGD_ANR("(0x0104 - 0x0110) gfcoef_yl1[%d]:%d \n",
1839 i, pMfnrCfg->gfcoef_yl1[i]);
1840 }
1841 for(i = 0; i < 3; i++) {
1842 LOGD_ANR("(0x0104 - 0x0110) gfcoef_yl2[%d]:%d \n",
1843 i, pMfnrCfg->gfcoef_yl2[i]);
1844 }
1845
1846 //0x0114 - 0x0120
1847 for(i = 0; i < 6; i++) {
1848 LOGD_ANR("(0x0114 - 0x0120) gfcoef_cg0[%d]:%d \n",
1849 i, pMfnrCfg->gfcoef_cg0[i]);
1850 }
1851 for(i = 0; i < 3; i++) {
1852 LOGD_ANR("(0x0114 - 0x0120) gfcoef_cg1[%d]:%d \n",
1853 i, pMfnrCfg->gfcoef_cg1[i]);
1854 }
1855 for(i = 0; i < 3; i++) {
1856 LOGD_ANR("(0x0114 - 0x0120) gfcoef_cg2[%d]:%d \n",
1857 i, pMfnrCfg->gfcoef_cg2[i]);
1858 }
1859
1860
1861 //0x0124 - 0x012c
1862 for(i = 0; i < 6; i++) {
1863 LOGD_ANR("(0x0124 - 0x012c) gfcoef_cl0[%d]:%d \n",
1864 i, pMfnrCfg->gfcoef_cl0[i]);
1865 }
1866 for(i = 0; i < 3; i++) {
1867 LOGD_ANR("(0x0124 - 0x012c) gfcoef_cl1[%d]:%d \n",
1868 i, pMfnrCfg->gfcoef_cl1[i]);
1869 }
1870
1871
1872 //0x0130 - 0x0134
1873 //dir_idx = 0; i = lvl;
1874 for(i = 0; i < 4; i++) {
1875 LOGD_ANR("(0x0130 - 0x0134) scale_yg[%d]:%d \n",
1876 i, pMfnrCfg->scale_yg[i]);
1877 }
1878
1879 //0x0138 - 0x013c
1880 //dir_idx = 1; i = lvl;
1881 for(i = 0; i < 3; i++) {
1882 LOGD_ANR("(0x0138 - 0x013c) scale_yl[%d]:%d \n",
1883 i, pMfnrCfg->scale_yl[i]);
1884 }
1885
1886 //0x0140 - 0x0148
1887 //dir_idx = 0; i = lvl;
1888 for(i = 0; i < 3; i++) {
1889 LOGD_ANR("(0x0140 - 0x0148) scale_cg[%d]:%d \n",
1890 i, pMfnrCfg->scale_cg[i]);
1891 LOGD_ANR("(0x0140 - 0x0148) scale_y2cg[%d]:%d \n",
1892 i, pMfnrCfg->scale_y2cg[i]);
1893 }
1894
1895 //0x014c - 0x0154
1896 //dir_idx = 1; i = lvl;
1897 for(i = 0; i < 2; i++) {
1898 LOGD_ANR("(0x014c - 0x0154) scale_cl[%d]:%d \n",
1899 i, pMfnrCfg->scale_cl[i]);
1900 }
1901 for(i = 0; i < 3; i++) {
1902 LOGD_ANR("(0x014c - 0x0154) scale_y2cl[%d]:%d \n",
1903 i, pMfnrCfg->scale_y2cl[i]);
1904 }
1905
1906 //0x0158
1907 for(i = 0; i < 3; i++) {
1908 LOGD_ANR("(0x0158) weight_y[%d]:%d \n",
1909 i, pMfnrCfg->weight_y[i]);
1910 }
1911
1912 LOGD_ANR("%s:(%d) exit \n", __FUNCTION__, __LINE__);
1913
1914 return res;
1915 }
1916
1917
mfnr_dynamic_calc(RKAnr_Mfnr_Dynamic_t * pDynamic,ANRExpInfo_t * pExpInfo)1918 ANRresult_t mfnr_dynamic_calc(RKAnr_Mfnr_Dynamic_t * pDynamic, ANRExpInfo_t *pExpInfo)
1919 {
1920 LOGI_ANR("%s:(%d) enter \n", __FUNCTION__, __LINE__);
1921
1922 ANRresult_t res = ANR_RET_SUCCESS;
1923 float time = pExpInfo->arTime[pExpInfo->hdr_mode];
1924 float iso = pExpInfo->arIso[pExpInfo->hdr_mode];
1925 float exp = time * iso;
1926
1927 if(pDynamic == NULL) {
1928 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1929 return ANR_RET_NULL_POINTER;
1930 }
1931
1932 if(pExpInfo == NULL) {
1933 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1934 return ANR_RET_NULL_POINTER;
1935 }
1936
1937
1938 if(iso >= pDynamic->highth_iso && time >= pDynamic->highth_time) {
1939 pDynamic->mfnr_enable_state = 1;
1940 } else if(iso <= pDynamic->lowth_iso && time <= pDynamic->lowth_time) {
1941 pDynamic->mfnr_enable_state = 0;
1942 }
1943
1944 LOGD_ANR("%s:%d mfnr: cur:%f %f highth:%f %f lowth:%f %f finnal:%d\n",
1945 __FUNCTION__, __LINE__,
1946 iso, time,
1947 pDynamic->highth_iso, pDynamic->highth_time,
1948 pDynamic->lowth_iso, pDynamic->lowth_time,
1949 pDynamic->mfnr_enable_state);
1950
1951 return res;
1952 }
1953
1954
mfnr_calibdbV2_assign(CalibDbV2_MFNR_t * pDst,CalibDbV2_MFNR_t * pSrc)1955 ANRresult_t mfnr_calibdbV2_assign(CalibDbV2_MFNR_t *pDst, CalibDbV2_MFNR_t *pSrc)
1956 {
1957 ANRresult_t res = ANR_RET_SUCCESS;
1958 CalibDbV2_MFNR_Calib_t *pSrcCalibParaV2 = NULL;
1959 CalibDbV2_MFNR_Tuning_t *pSrcTuningParaV2 = NULL;
1960 CalibDbV2_MFNR_Calib_t *pDstCalibParaV2 = NULL;
1961 CalibDbV2_MFNR_Tuning_t *pDstTuningParaV2 = NULL;
1962 int setting_len = 0;
1963 int iso_len = 0;
1964
1965
1966 if(pDst == NULL) {
1967 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1968 return ANR_RET_NULL_POINTER;
1969 }
1970
1971 if(pSrc == NULL) {
1972 LOGE_ANR("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1973 return ANR_RET_NULL_POINTER;
1974 }
1975
1976 mfnr_calibdbV2_free(pDst);
1977
1978 pSrcCalibParaV2 = &pSrc->CalibPara;
1979 pSrcTuningParaV2 = &pSrc->TuningPara;
1980 pDstCalibParaV2 = &pDst->CalibPara;
1981 pDstTuningParaV2 = &pDst->TuningPara;
1982
1983 //assign the value
1984 pDst->Version = strdup(pSrc->Version);
1985 pDstTuningParaV2->enable = pSrcTuningParaV2->enable;
1986 pDstTuningParaV2->mode_3to1 = pSrcTuningParaV2->mode_3to1;
1987 pDstTuningParaV2->local_gain_en = pSrcTuningParaV2->local_gain_en;
1988 pDstTuningParaV2->motion_detect_en = pSrcTuningParaV2->motion_detect_en;
1989
1990 //malloc iso size
1991 setting_len = pSrcCalibParaV2->Setting_len;
1992 pDstCalibParaV2->Setting = (CalibDbV2_MFNR_C_Set_t *)malloc(setting_len * sizeof(CalibDbV2_MFNR_C_Set_t));
1993 memset(pDstCalibParaV2->Setting, 0x00, setting_len * sizeof(CalibDbV2_MFNR_C_Set_t));
1994 pDstCalibParaV2->Setting_len = setting_len;
1995
1996 for(int i = 0; i < setting_len; i++) {
1997 iso_len = pSrcCalibParaV2->Setting[i].Calib_ISO_len;
1998 pDstCalibParaV2->Setting[i].Calib_ISO = (CalibDbV2_MFNR_C_ISO_t *)malloc(iso_len * sizeof(CalibDbV2_MFNR_C_ISO_t));
1999 memset(pDstCalibParaV2->Setting[i].Calib_ISO, 0x00, iso_len * sizeof(CalibDbV2_MFNR_C_ISO_t));
2000 pDstCalibParaV2->Setting[i].Calib_ISO_len = iso_len;
2001 }
2002
2003 for(int i = 0; i < setting_len; i++) {
2004 iso_len = pSrcCalibParaV2->Setting[i].Calib_ISO_len;
2005 pDstCalibParaV2->Setting[i].SNR_Mode = strdup(pSrcCalibParaV2->Setting[i].SNR_Mode);
2006 pDstCalibParaV2->Setting[i].Sensor_Mode = strdup(pSrcCalibParaV2->Setting[i].Sensor_Mode);
2007
2008 for(int j = 0; j < iso_len; j++) {
2009 pDstCalibParaV2->Setting[i].Calib_ISO[j] = pSrcCalibParaV2->Setting[i].Calib_ISO[j];
2010 }
2011 }
2012
2013
2014 setting_len = pSrcTuningParaV2->Setting_len;
2015 pDstTuningParaV2->Setting = (CalibDbV2_MFNR_T_Set_t *)malloc(setting_len * sizeof(CalibDbV2_MFNR_T_Set_t));
2016 memset(pDstTuningParaV2->Setting, 0x00, setting_len * sizeof(CalibDbV2_MFNR_T_Set_t));
2017 pDstTuningParaV2->Setting_len = setting_len;
2018
2019 for(int i = 0; i < setting_len; i++) {
2020 iso_len = pSrcTuningParaV2->Setting[i].Tuning_ISO_len;
2021 pDstTuningParaV2->Setting[i].Tuning_ISO = (CalibDbV2_MFNR_T_ISO_t *)malloc(iso_len * sizeof(CalibDbV2_MFNR_T_ISO_t));
2022 memset(pDstTuningParaV2->Setting[i].Tuning_ISO, 0x00, iso_len * sizeof(CalibDbV2_MFNR_T_ISO_t));
2023 pDstTuningParaV2->Setting[i].Tuning_ISO_len = iso_len;
2024 }
2025
2026 for(int i = 0; i < setting_len; i++) {
2027 iso_len = pSrcTuningParaV2->Setting[i].Tuning_ISO_len;
2028 pDstTuningParaV2->Setting[i].SNR_Mode = strdup(pSrcCalibParaV2->Setting[i].SNR_Mode);
2029 pDstTuningParaV2->Setting[i].Sensor_Mode = strdup(pSrcCalibParaV2->Setting[i].Sensor_Mode);
2030
2031 for(int j = 0; j < iso_len; j++) {
2032 pDstTuningParaV2->Setting[i].Tuning_ISO[j] = pSrcTuningParaV2->Setting[i].Tuning_ISO[j];
2033 }
2034 }
2035
2036 //motion
2037 iso_len = pSrcTuningParaV2->Motion.Motion_ISO_len;
2038 pDstTuningParaV2->Motion.Motion_ISO = (CalibDbV2_MFNR_Motion_ISO_t *)malloc(iso_len * sizeof(CalibDbV2_MFNR_Motion_ISO_t));
2039 memset(pDstTuningParaV2->Motion.Motion_ISO, 0x00, iso_len * sizeof(CalibDbV2_MFNR_Motion_ISO_t));
2040 pDstTuningParaV2->Motion.Motion_ISO_len = iso_len;
2041 for(int j = 0; j < iso_len; j++) {
2042 pDstTuningParaV2->Motion.Motion_ISO[j] = pSrcTuningParaV2->Motion.Motion_ISO[j];
2043 }
2044
2045 //dynamic
2046 pDstTuningParaV2->Dynamic = pSrcTuningParaV2->Dynamic;
2047
2048 return res;
2049 }
2050
2051
2052
mfnr_calibdbV2_free(CalibDbV2_MFNR_t * pCalibdbV2)2053 void mfnr_calibdbV2_free(CalibDbV2_MFNR_t *pCalibdbV2)
2054 {
2055 if(pCalibdbV2) {
2056 if(pCalibdbV2->Version) {
2057 free(pCalibdbV2->Version);
2058 }
2059
2060 if(pCalibdbV2->CalibPara.Setting) {
2061 for(int i = 0; i < pCalibdbV2->CalibPara.Setting_len; i++) {
2062 if(pCalibdbV2->CalibPara.Setting[i].Calib_ISO) {
2063 if(pCalibdbV2->CalibPara.Setting[i].Calib_ISO) {
2064 free(pCalibdbV2->CalibPara.Setting[i].Calib_ISO);
2065 }
2066 if(pCalibdbV2->CalibPara.Setting[i].SNR_Mode) {
2067 free(pCalibdbV2->CalibPara.Setting[i].SNR_Mode);
2068 }
2069 if(pCalibdbV2->CalibPara.Setting[i].Sensor_Mode) {
2070 free(pCalibdbV2->CalibPara.Setting[i].Sensor_Mode);
2071 }
2072 }
2073 }
2074 free(pCalibdbV2->CalibPara.Setting);
2075 }
2076
2077
2078 if(pCalibdbV2->TuningPara.Setting) {
2079 for(int i = 0; i < pCalibdbV2->TuningPara.Setting_len; i++) {
2080 if(pCalibdbV2->TuningPara.Setting[i].Tuning_ISO) {
2081 if(pCalibdbV2->TuningPara.Setting[i].Tuning_ISO) {
2082 free(pCalibdbV2->TuningPara.Setting[i].Tuning_ISO);
2083 }
2084 if(pCalibdbV2->TuningPara.Setting[i].SNR_Mode) {
2085 free(pCalibdbV2->TuningPara.Setting[i].SNR_Mode);
2086 }
2087 if(pCalibdbV2->TuningPara.Setting[i].Sensor_Mode) {
2088 free(pCalibdbV2->TuningPara.Setting[i].Sensor_Mode);
2089 }
2090 }
2091 }
2092 free(pCalibdbV2->TuningPara.Setting);
2093 }
2094
2095 if(pCalibdbV2->TuningPara.Motion.Motion_ISO) {
2096 free(pCalibdbV2->TuningPara.Motion.Motion_ISO);
2097 }
2098
2099 }
2100
2101 }
2102
2103