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