1
2 #include "rk_aiq_asharp_algo_sharp_v3.h"
3 #include "RkAiqCalibDbV2Helper.h"
4
5 RKAIQ_BEGIN_DECLARE
6
7
sharp_get_mode_by_name_V3(struct list_head * pCalibdbList,char * name,Calibdb_Sharp_V3_t ** ppProfile)8 Asharp3_result_t sharp_get_mode_by_name_V3(struct list_head* pCalibdbList, char *name, Calibdb_Sharp_V3_t** ppProfile)
9 {
10 int i = 0;
11 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
12 LOGI_ASHARP("%s(%d): enter \n", __FUNCTION__, __LINE__);
13
14 if(pCalibdbList == NULL) {
15 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
16 return ASHARP3_RET_NULL_POINTER;
17 }
18
19 if(name == NULL) {
20 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
21 return ASHARP3_RET_NULL_POINTER;
22 }
23
24 if(ppProfile == NULL) {
25 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
26 return ASHARP3_RET_NULL_POINTER;
27 }
28
29 LOGD_ASHARP("%s(%d): moden:%s \n", __FUNCTION__, __LINE__, name);
30
31 #if 1
32 *ppProfile = NULL;
33 struct list_head* p;
34 p = pCalibdbList->next;
35
36 int num = get_list_num(pCalibdbList);
37 LOGD_ASHARP("%s(%d): list num:%d list:%p \n", __FUNCTION__, __LINE__, num, pCalibdbList);
38
39
40 while (p != pCalibdbList)
41 {
42 Calibdb_Sharp_V3_t* pProfile = container_of(p, Calibdb_Sharp_V3_t, listItem);
43 LOGD_ASHARP("%s:%d %s %p \n",
44 __FUNCTION__, __LINE__, pProfile->modeName, p);
45 if (!strncmp(pProfile->modeName, name, sizeof(pProfile->modeName))) {
46 *ppProfile = pProfile;
47 return res;
48 }
49 p = p->next;
50 }
51
52 if(pCalibdbList->next != pCalibdbList) {
53 Calibdb_Sharp_V3_t* pProfile = container_of(pCalibdbList->next, Calibdb_Sharp_V3_t, listItem);
54 *ppProfile = pProfile;
55 }
56 #else
57
58
59 #endif
60
61 LOGI_ASHARP("%s(%d): exit \n", __FUNCTION__, __LINE__);
62 return res;
63
64 }
65
66
sharp_get_setting_by_name_V3(struct list_head * pSettingList,char * name,Calibdb_Sharp_params_V3_t ** ppSetting)67 Asharp3_result_t sharp_get_setting_by_name_V3(struct list_head *pSettingList, char *name, Calibdb_Sharp_params_V3_t** ppSetting)
68 {
69 int i = 0;
70 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
71
72 LOGI_ASHARP("%s(%d): enter \n", __FUNCTION__, __LINE__);
73
74 if(pSettingList == NULL) {
75 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
76 return ASHARP3_RET_NULL_POINTER;
77 }
78
79 if(name == NULL) {
80 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
81 return ASHARP3_RET_NULL_POINTER;
82 }
83
84 if(ppSetting == NULL) {
85 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
86 return ASHARP3_RET_NULL_POINTER;
87 }
88
89 LOGD_ASHARP("%s(%d): name:%s \n", __FUNCTION__, __LINE__, name);
90
91 *ppSetting = NULL;
92
93 struct list_head* p;
94 p = pSettingList->next;
95
96 int num = get_list_num(pSettingList);
97 LOGD_ASHARP("%s(%d): list num:%d list:%p \n", __FUNCTION__, __LINE__, num, pSettingList);
98
99 while (p != pSettingList)
100 {
101 Calibdb_Sharp_params_V3_t* pSetting = container_of(p, Calibdb_Sharp_params_V3_t, listItem);
102 LOGD_ASHARP("%s:%d: %s %p \n",
103 __FUNCTION__, __LINE__, pSetting->snr_mode, p);
104 if (!strncmp(pSetting->snr_mode, name, sizeof(pSetting->snr_mode))) {
105 *ppSetting = pSetting;
106 return res;
107 }
108 p = p->next;
109 }
110
111 if(pSettingList->next != pSettingList) {
112 Calibdb_Sharp_params_V3_t* pSetting = container_of(pSettingList->next, Calibdb_Sharp_params_V3_t, listItem);
113 *ppSetting = pSetting;
114 }
115
116 LOGI_ASHARP("%s(%d): exit \n", __FUNCTION__, __LINE__);
117
118 return res;
119 }
120
121
122
sharp_config_setting_param_V3(RK_SHARP_Params_V3_t * pParams,struct list_head * pCalibdbList,char * param_mode,char * snr_name)123 Asharp3_result_t sharp_config_setting_param_V3(RK_SHARP_Params_V3_t *pParams, struct list_head *pCalibdbList, char* param_mode, char * snr_name)
124 {
125 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
126 Calibdb_Sharp_V3_t *pProfile;
127 Calibdb_Sharp_params_V3_t *pCalibParms;
128
129 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
130
131 if(pParams == NULL) {
132 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
133 return ASHARP3_RET_NULL_POINTER;
134 }
135
136 if(pCalibdbList == NULL) {
137 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
138 return ASHARP3_RET_NULL_POINTER;
139 }
140
141 if(param_mode == NULL) {
142 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
143 return ASHARP3_RET_NULL_POINTER;
144 }
145
146 if(snr_name == NULL) {
147 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
148 return ASHARP3_RET_NULL_POINTER;
149 }
150
151 LOGD_ASHARP("%s(%d): mode:%s setting:%s \n", __FUNCTION__, __LINE__, param_mode, snr_name);
152
153 res = sharp_get_mode_by_name_V3(pCalibdbList, param_mode, &pProfile);
154 if(res != ASHARP3_RET_SUCCESS) {
155 LOGW_ASHARP("%s(%d): error!!! can't find mode name in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
156 }
157
158 res = sharp_get_setting_by_name_V3(&pProfile->listHead, snr_name, &pCalibParms);
159 if(res != ASHARP3_RET_SUCCESS) {
160 LOGW_ASHARP("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
161 }
162
163 res = sharp_init_params_V3(pParams, pCalibParms);
164 pParams->enable = pProfile->enable;
165
166 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
167
168 return res;
169
170 }
171
sharp_init_params_V3(RK_SHARP_Params_V3_t * pSharpParams,Calibdb_Sharp_params_V3_t * pCalibParms)172 Asharp3_result_t sharp_init_params_V3(RK_SHARP_Params_V3_t *pSharpParams, Calibdb_Sharp_params_V3_t* pCalibParms)
173 {
174 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
175 int i = 0;
176 int j = 0;
177 short isoCurveSectValue;
178 short isoCurveSectValue1;
179 float ave1, ave2, ave3, ave4;
180 int bit_calib = 12;
181 int bit_proc;
182 int bit_shift;
183
184 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
185
186 if(pSharpParams == NULL) {
187 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
188 return ASHARP3_RET_NULL_POINTER;
189 }
190
191 if(pCalibParms == NULL) {
192 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
193 return ASHARP3_RET_NULL_POINTER;
194 }
195
196 for(i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++) {
197 pSharpParams->luma_point[i] = pCalibParms->luma_point[i];
198 }
199
200 for(i = 0; i < RK_SHARP_V3_MAX_ISO_NUM; i++) {
201 pSharpParams->iso[i] = pCalibParms->iso[i];
202
203 for(j = 0; j < RK_SHARP_V3_LUMA_POINT_NUM; j++) {
204 pSharpParams->luma_sigma[i][j] = pCalibParms->luma_sigma[i][j];
205 pSharpParams->lum_clip_h[i][j] = pCalibParms->lum_clip_h[i][j];
206 pSharpParams->ehf_th[i][j] = pCalibParms->ehf_th[i][j];
207 pSharpParams->clip_hf[i][j] = pCalibParms->clip_hf[i][j];
208 pSharpParams->clip_mf[i][j] = pCalibParms->clip_mf[i][j];
209 pSharpParams->clip_lf[i][j] = pCalibParms->clip_lf[i][j];
210 pSharpParams->local_wgt[i][j] = pCalibParms->local_wgt[i][j];
211 }
212
213 pSharpParams->pbf_gain[i] = pCalibParms->pbf_gain[i];
214 pSharpParams->pbf_add[i] = pCalibParms->pbf_add[i];
215 pSharpParams->pbf_ratio[i] = pCalibParms->pbf_ratio[i];
216 pSharpParams->gaus_ratio[i] = pCalibParms->gaus_ratio[i];
217 pSharpParams->sharp_ratio[i] = pCalibParms->sharp_ratio[i];
218 pSharpParams->bf_gain[i] = pCalibParms->bf_gain[i];
219 pSharpParams->bf_add[i] = pCalibParms->bf_add[i];
220 pSharpParams->bf_ratio[i] = pCalibParms->bf_ratio[i];
221
222 for(j = 0; j < 3; j++) {
223 pSharpParams->kernel_bila_filter[i][j] = pCalibParms->kernel_bila_filter[j][i];
224 pSharpParams->kernel_pre_bila_filter[i][j] = pCalibParms->kernel_pre_bila_filter[j][i];
225 pSharpParams->kernel_range_filter[i][j] = pCalibParms->kernel_range_filter[j][i];
226 LOGD_ASHARP("kernel: index[%d][%d] = %f\n", i, j, pSharpParams->kernel_bila_filter[i][j]);
227 }
228
229 pSharpParams->sharp_ratio_h[i] = pCalibParms->sharp_ratio_h[i];
230 pSharpParams->sharp_ratio_m[i] = pCalibParms->sharp_ratio_m[i];
231 pSharpParams->sharp_ratio_l[i] = pCalibParms->sharp_ratio_l[i];
232 }
233
234 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
235 return res;
236 }
237
238
sharp_select_params_by_ISO_V3(RK_SHARP_Params_V3_t * pParams,RK_SHARP_Params_V3_Select_t * pSelect,Asharp3_ExpInfo_t * pExpInfo)239 Asharp3_result_t sharp_select_params_by_ISO_V3(
240 RK_SHARP_Params_V3_t *pParams,
241 RK_SHARP_Params_V3_Select_t *pSelect,
242 Asharp3_ExpInfo_t *pExpInfo
243 )
244 {
245 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
246
247 int i;
248 int iso = 50;
249 int iso_div = 50;
250 float ratio = 0.0f;
251 int iso_low = iso, iso_high = iso;
252 int gain_high = 0, gain_low = 0;
253 int max_iso_step = RK_SHARP_V3_MAX_ISO_NUM;
254 int sum_coeff, offset;
255
256 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
257
258 if(pParams == NULL) {
259 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
260 return ASHARP3_RET_NULL_POINTER;
261 }
262
263 if(pSelect == NULL) {
264 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
265 return ASHARP3_RET_NULL_POINTER;
266 }
267
268 if(pExpInfo == NULL) {
269 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
270 return ASHARP3_RET_NULL_POINTER;
271 }
272
273 iso = pExpInfo->arIso[pExpInfo->hdr_mode];
274
275 #ifndef RK_SIMULATOR_HW
276 for (i = 0; i < max_iso_step - 1; i++) {
277 if (iso >= pParams->iso[i] && iso <= pParams->iso[i + 1] ) {
278 iso_low = pParams->iso[i] ;
279 iso_high = pParams->iso[i + 1];
280 gain_low = i;
281 gain_high = i + 1;
282 ratio = (float)(iso - iso_low) / (iso_high - iso_low);
283 break;
284 }
285 }
286
287 if(iso < pParams->iso[0] ) {
288 iso_low = pParams->iso[0] ;
289 iso_high = pParams->iso[1];
290 gain_low = 0;
291 gain_high = 1;
292 ratio = 0;
293 }
294
295 if(iso > pParams->iso[max_iso_step - 1] ) {
296 iso_low = pParams->iso[max_iso_step - 2] ;
297 iso_high = pParams->iso[max_iso_step - 1];
298 gain_low = max_iso_step - 2;
299 gain_high = max_iso_step - 1;
300 ratio = 1;
301 }
302 #else
303 for (i = max_iso_step - 1; i >= 0; i--)
304 {
305 if (iso < iso_div * (2 << i))
306 {
307 iso_low = iso_div * (2 << (i)) / 2;
308 iso_high = iso_div * (2 << i);
309 }
310 }
311
312 ratio = (float)(iso - iso_low) / (iso_high - iso_low);
313 if (iso_low == iso)
314 {
315 iso_high = iso;
316 ratio = 0;
317 }
318 if (iso_high == iso )
319 {
320 iso_low = iso;
321 ratio = 1;
322 }
323 gain_high = (int)(log((float)iso_high / 50) / log((float)2));
324 gain_low = (int)(log((float)iso_low / 50) / log((float)2));
325
326
327 gain_low = MIN(MAX(gain_low, 0), max_iso_step - 1);
328 gain_high = MIN(MAX(gain_high, 0), max_iso_step - 1);
329 #endif
330
331 LOGD_ASHARP("%s:%d iso:%d gainlow:%d gian_high:%d\n", __FUNCTION__, __LINE__, iso, gain_high, gain_high);
332
333 pSelect->enable = pParams->enable;
334 pSelect->pbf_gain = INTERP_V3(pParams->pbf_gain[gain_low], pParams->pbf_gain[gain_high], ratio);
335 pSelect->pbf_add = INTERP_V3(pParams->pbf_add[gain_low], pParams->pbf_add[gain_high], ratio);
336 pSelect->pbf_ratio = INTERP_V3(pParams->pbf_ratio[gain_low], pParams->pbf_ratio[gain_high], ratio);
337
338 pSelect->gaus_ratio = INTERP_V3(pParams->gaus_ratio[gain_low], pParams->gaus_ratio[gain_high], ratio);
339 pSelect->sharp_ratio = INTERP_V3(pParams->sharp_ratio[gain_low], pParams->sharp_ratio[gain_high], ratio);
340
341 pSelect->bf_gain = INTERP_V3(pParams->bf_gain[gain_low], pParams->bf_gain[gain_high], ratio);
342 pSelect->bf_add = INTERP_V3(pParams->bf_add[gain_low], pParams->bf_add[gain_high], ratio);
343 pSelect->bf_ratio = INTERP_V3(pParams->bf_ratio[gain_low], pParams->bf_ratio[gain_high], ratio);
344
345 for(int i = 0; i < RK_SHARP_V3_PBF_DIAM * RK_SHARP_V3_PBF_DIAM; i++) {
346 pSelect->kernel_pre_bila_filter[i] = INTERP_V3(pParams->kernel_pre_bila_filter [gain_low][i], pParams->kernel_pre_bila_filter[gain_high][i], ratio);
347 }
348
349 for(int i = 0; i < RK_SHARP_V3_RF_DIAM * RK_SHARP_V3_RF_DIAM; i++) {
350 pSelect->kernel_range_filter[i] = INTERP_V3(pParams->kernel_range_filter [gain_low][i], pParams->kernel_range_filter[gain_high][i], ratio);
351 }
352
353 for(int i = 0; i < RK_SHARP_V3_BF_DIAM * RK_SHARP_V3_BF_DIAM; i++) {
354 pSelect->kernel_bila_filter[i] = INTERP_V3(pParams->kernel_bila_filter [gain_low][i], pParams->kernel_bila_filter[gain_high][i], ratio);
355 }
356
357 //////////////////////////////////////////////////////////////////////////
358 // test params
359 pSelect->sharp_ratio_h = INTERP_V3(pParams->sharp_ratio_h[gain_low], pParams->sharp_ratio_h[gain_high], ratio);
360 pSelect->sharp_ratio_m = INTERP_V3(pParams->sharp_ratio_m[gain_low], pParams->sharp_ratio_m[gain_high], ratio);
361 pSelect->sharp_ratio_l = INTERP_V3(pParams->sharp_ratio_l[gain_low], pParams->sharp_ratio_l[gain_high], ratio);
362 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++) {
363 pSelect->luma_point[i] = pParams->luma_point[i];
364 pSelect->luma_sigma[i] = INTERP_V3(pParams->luma_sigma[gain_low][i], pParams->luma_sigma[gain_high][i], ratio);
365 pSelect->lum_clip_h[i] = (int16_t)ROUND_F(INTERP_V3(pParams->lum_clip_h[gain_low][i], pParams->lum_clip_h[gain_high][i], ratio));
366 pSelect->ehf_th[i] = (int16_t)ROUND_F(INTERP_V3(pParams->ehf_th[gain_low][i], pParams->ehf_th[gain_high][i], ratio));
367
368 //////////////////////////////////////////////////////////////////////////
369 pSelect->clip_hf[i] = (int16_t)ROUND_F(INTERP_V3(pParams->clip_hf[gain_low][i], pParams->clip_hf[gain_high][i], ratio));
370 pSelect->clip_mf[i] = (int16_t)ROUND_F(INTERP_V3(pParams->clip_mf[gain_low][i], pParams->clip_mf[gain_high][i], ratio));
371 pSelect->clip_lf[i] = (int16_t)ROUND_F(INTERP_V3(pParams->clip_lf[gain_low][i], pParams->clip_lf[gain_high][i], ratio));
372 pSelect->local_wgt[i] = (int16_t)ROUND_F(INTERP_V3(pParams->local_wgt[gain_low][i], pParams->local_wgt[gain_high][i], ratio));
373 }
374
375 //////////////////////////////////////////////////////////////////////////
376 for(int i = 0; i < RK_SHARP_V3_HF_DIAM * RK_SHARP_V3_HF_DIAM; i++) {
377 pSelect->kernel_hf_filter[i] = INTERP_V3(pParams->kernel_hf_filter[gain_low][i], pParams->kernel_hf_filter[gain_high][i], ratio);
378 }
379
380 for(int i = 0; i < RK_SHARP_V3_MF_DIAM * RK_SHARP_V3_MF_DIAM; i++)
381 {
382 pSelect->kernel_mf_filter[i] = INTERP_V3(pParams->kernel_mf_filter[gain_low][i], pParams->kernel_mf_filter[gain_high][i], ratio);
383 }
384
385 for(int i = 0; i < RK_SHARP_V3_LF_DIAM * RK_SHARP_V3_LF_DIAM; i++)
386 {
387 pSelect->kernel_lf_filter[i] = INTERP_V3(pParams->kernel_lf_filter[gain_low][i], pParams->kernel_lf_filter[gain_high][i], ratio);
388 }
389
390 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
391 return res;
392 }
393
394
395
sharp_fix_transfer_V3(RK_SHARP_Params_V3_Select_t * pSelect,RK_SHARP_Fix_V3_t * pFix,float fPercent)396 Asharp3_result_t sharp_fix_transfer_V3(RK_SHARP_Params_V3_Select_t *pSelect, RK_SHARP_Fix_V3_t* pFix, float fPercent)
397 {
398 int sum_coeff, offset;
399 int pbf_sigma_shift = 0;
400 int bf_sigma_shift = 0;
401 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
402 int tmp = 0;
403
404 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
405
406 if(pSelect == NULL) {
407 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
408 return ASHARP3_RET_NULL_POINTER;
409 }
410
411 if(pFix == NULL) {
412 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
413 return ASHARP3_RET_NULL_POINTER;
414 }
415
416 if(fPercent <= 0.0) {
417 fPercent = 0.000001;
418 }
419
420 // SHARP_SHARP_EN (0x0000)
421 pFix->sharp_bypass = 0;
422 pFix->sharp_en = pSelect->enable;
423
424 // SHARP_SHARP_RATIO (0x0004)
425 tmp = (int)ROUND_F(pSelect->sharp_ratio * fPercent * (1 << rk_sharp_V3_sharp_ratio_fix_bits));
426 pFix->sharp_sharp_ratio = CLIP(tmp, 0, 63);
427 tmp = (int)ROUND_F(pSelect->bf_ratio / fPercent * (1 << rk_sharp_V3_bf_ratio_fix_bits));
428 pFix->sharp_bf_ratio = CLIP(tmp, 0, 128);
429 tmp = (int)ROUND_F(pSelect->gaus_ratio / fPercent * (1 << rk_sharp_V3_gaus_ratio_fix_bits));
430 pFix->sharp_gaus_ratio = CLIP(tmp, 0, 128);
431 tmp = (int)ROUND_F(pSelect->pbf_ratio / fPercent * (1 << rk_sharp_V3_bf_ratio_fix_bits));
432 pFix->sharp_pbf_ratio = CLIP(tmp, 0, 128);
433
434 // SHARP_SHARP_LUMA_DX (0x0008)
435 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM - 1; i++)
436 {
437 tmp = ( log((float)(pSelect->luma_point[i + 1] - pSelect->luma_point[i])) / log((float)2) );
438 pFix->sharp_luma_dx[i] = CLIP(tmp, 0, 15);
439 }
440
441 // SHARP_SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
442 // pre bf sigma inv
443 int sigma_deci_bits = 9;
444 int sigma_inte_bits = 1;
445 int max_val = 0;
446 int min_val = 65536;
447 int shf_bits = 0;
448 short sigma_bits[3];
449 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
450 {
451 int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->pbf_gain + pSelect->pbf_add) / fPercent );
452 if(max_val < cur_sigma)
453 max_val = cur_sigma;
454 if(min_val > cur_sigma)
455 min_val = cur_sigma;
456 }
457 sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
458 sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
459 sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
460 pbf_sigma_shift = sigma_bits[2] - 5;
461 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
462 {
463 tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->pbf_gain + pSelect->pbf_add) * fPercent * (1 << sigma_bits[2]));
464 pFix->sharp_pbf_sigma_inv[i] = CLIP(tmp, 0, 1023);
465 }
466
467 // SHARP_SHARP_BF_SIGMA_INV_0 (0x0018 - 0x0020)
468 // bf sigma inv
469 sigma_deci_bits = 9;
470 sigma_inte_bits = 1;
471 max_val = 0;
472 min_val = 65536;
473 shf_bits = 0;
474 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
475 {
476 int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->bf_gain + pSelect->bf_add) / fPercent );
477 if(max_val < cur_sigma)
478 max_val = cur_sigma;
479 if(min_val > cur_sigma)
480 min_val = cur_sigma;
481 }
482 sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
483 sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
484 sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
485 bf_sigma_shift = sigma_bits[2] - 5;
486 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
487 {
488 tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->bf_gain + pSelect->bf_add) * fPercent * (1 << sigma_bits[2]));
489 pFix->sharp_bf_sigma_inv[i] = CLIP(tmp, 0, 1023);
490 }
491
492 // SHARP_SHARP_SIGMA_SHIFT (0x00024)
493 pFix->sharp_pbf_sigma_shift = CLIP(bf_sigma_shift, 0, 15);
494 pFix->sharp_bf_sigma_shift = CLIP(pbf_sigma_shift, 0, 15);
495
496 // SHARP_SHARP_EHF_TH_0 (0x0028 - 0x0030)
497 // wgt = hf * ehf_th
498 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
499 {
500 tmp = (int)(pSelect->ehf_th[i] * fPercent);
501 pFix->sharp_ehf_th[i] = CLIP(tmp, 0, 1023);
502 }
503
504 // SHARP_SHARP_CLIP_HF_0 (0x0034 - 0x003c)
505 for(int i = 0; i < RK_SHARP_V3_LUMA_POINT_NUM; i++)
506 {
507 tmp = (int)(pSelect->lum_clip_h[i] * fPercent);
508 pFix->sharp_clip_hf[i] = CLIP(tmp, 0, 1023);
509 }
510
511 // SHARP_SHARP_PBF_COEF (0x00040)
512 // filter coeff
513 // bf coeff
514 // rk_sharp_V3_pbfCoeff : [4], [1], [0]
515 tmp = (int)ROUND_F(pSelect->kernel_pre_bila_filter[0] * (1 << rk_sharp_V3_pbfCoeff_fix_bits));
516 pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);
517 tmp = (int)ROUND_F(pSelect->kernel_pre_bila_filter[1] * (1 << rk_sharp_V3_pbfCoeff_fix_bits));
518 pFix->sharp_pbf_coef[1] = CLIP(tmp, 0, 127);
519 tmp = (int)ROUND_F(pSelect->kernel_pre_bila_filter[2] * (1 << rk_sharp_V3_pbfCoeff_fix_bits));
520 pFix->sharp_pbf_coef[2] = CLIP(tmp, 0, 127);
521 sum_coeff = pFix->sharp_pbf_coef[0] + 4 * pFix->sharp_pbf_coef[1] + 4 * pFix->sharp_pbf_coef[2];
522 offset = (1 << rk_sharp_V3_pbfCoeff_fix_bits) - sum_coeff;
523 tmp = (int)(pFix->sharp_pbf_coef[0] + offset);
524 pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);
525
526 // SHARP_SHARP_BF_COEF (0x00044)
527 // bf coeff
528 // rk_sharp_V3_bfCoeff : [4], [1], [0]
529 tmp = (int)ROUND_F(pSelect->kernel_bila_filter[0] * (1 << rk_sharp_V3_hbfCoeff_fix_bits));
530 pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);
531 tmp = (int)ROUND_F(pSelect->kernel_bila_filter[1] * (1 << rk_sharp_V3_hbfCoeff_fix_bits));
532 pFix->sharp_bf_coef[1] = CLIP(tmp, 0, 127);
533 tmp = (int)ROUND_F(pSelect->kernel_bila_filter[2] * (1 << rk_sharp_V3_hbfCoeff_fix_bits));
534 pFix->sharp_bf_coef[2] = CLIP(tmp, 0, 127);
535 sum_coeff = pFix->sharp_bf_coef[0] + 4 * pFix->sharp_bf_coef[1] + 4 * pFix->sharp_bf_coef[2];
536 offset = (1 << rk_sharp_V3_hbfCoeff_fix_bits) - sum_coeff;
537 tmp = (int)(pFix->sharp_bf_coef[0] + offset);
538 pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);
539
540 // SHARP_SHARP_GAUS_COEF (0x00048)
541 // rk_sharp_V3_rfCoeff : [4], [1], [0]
542 tmp = (int)ROUND_F(pSelect->kernel_range_filter[0] * (1 << rk_sharp_V3_rfCoeff_fix_bits));
543 pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);
544 tmp = (int)ROUND_F(pSelect->kernel_range_filter[1] * (1 << rk_sharp_V3_rfCoeff_fix_bits));
545 pFix->sharp_gaus_coef[1] = CLIP(tmp, 0, 127);
546 tmp = (int)ROUND_F(pSelect->kernel_range_filter[2] * (1 << rk_sharp_V3_rfCoeff_fix_bits));
547 pFix->sharp_gaus_coef[2] = CLIP(tmp, 0, 127);
548 sum_coeff = pFix->sharp_gaus_coef[0] + 4 * pFix->sharp_gaus_coef[1] + 4 * pFix->sharp_gaus_coef[2];
549 offset = (1 << rk_sharp_V3_rfCoeff_fix_bits) - sum_coeff;
550 tmp = (int)(pFix->sharp_gaus_coef[0] + offset);
551 pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);
552
553
554 #if 0
555 //////////////////////////////////params clip////////////////////////////////////////
556 pFix->sharp_sharp_ratio = CLIP(pFix->sharp_sharp_ratio, 0, 63);
557 pFix->sharp_bf_ratio = CLIP(pFix->sharp_bf_ratio, 0, 128);
558 pFix->sharp_gaus_ratio = CLIP(pFix->sharp_gaus_ratio, 0, 128);
559 pFix->sharp_pbf_ratio = CLIP(pFix->sharp_pbf_ratio, 0, 128);
560
561 for(int k = 0; k < RK_SHARP_V3_LUMA_POINT_NUM - 1; k ++) {
562 pFix->sharp_luma_dx[k] = CLIP(pFix->sharp_luma_dx[k], 0, 15);
563 }
564
565 for(int k = 0; k < RK_SHARP_V3_LUMA_POINT_NUM; k ++) {
566 pFix->sharp_pbf_sigma_inv[k] = CLIP(pFix->sharp_pbf_sigma_inv[k], 0, 1023);
567 pFix->sharp_bf_sigma_inv[k] = CLIP(pFix->sharp_bf_sigma_inv[k], 0, 1023);
568 pFix->sharp_clip_hf[k] = CLIP(pFix->sharp_clip_hf[k], 0, 1023);
569 pFix->sharp_ehf_th[k] = CLIP(pFix->sharp_ehf_th[k], 0, 1023);
570 }
571
572 for(int k = 0; k < 3; k ++) {
573 pFix->sharp_pbf_coef[k] = CLIP(pFix->sharp_pbf_coef[k], 0, 127);
574 pFix->sharp_gaus_coef[k] = CLIP(pFix->sharp_gaus_coef[k], 0, 127);
575 pFix->sharp_bf_coef[k] = CLIP(pFix->sharp_bf_coef[k], 0, 127);
576 }
577 pFix->sharp_pbf_sigma_shift = CLIP(pFix->sharp_pbf_sigma_shift, 0, 15);
578 pFix->sharp_bf_sigma_shift = CLIP(pFix->sharp_bf_sigma_shift, 0, 15);
579 #endif
580
581 #if 0
582 sharp_fix_printf_V3(pFix);
583 #endif
584
585 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
586 return res;
587 }
588
589
sharp_fix_printf_V3(RK_SHARP_Fix_V3_t * pFix)590 Asharp3_result_t sharp_fix_printf_V3(RK_SHARP_Fix_V3_t * pFix)
591 {
592 int i = 0;
593 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
594
595 LOGI_ASHARP("%s:(%d) enter \n", __FUNCTION__, __LINE__);
596
597 if(pFix == NULL) {
598 LOGI_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
599 return ASHARP3_RET_NULL_POINTER;
600 }
601
602 // SHARP_SHARP_EN (0x0000)
603 LOGD_ASHARP("(0x0000) sharp_bypass:0x%x sharp_en:0x%x \n",
604 pFix->sharp_bypass,
605 pFix->sharp_en);
606
607
608 // SHARP_SHARP_RATIO (0x0004)
609 LOGD_ASHARP("(0x0004) sharp_sharp_ratio:0x%x sharp_bf_ratio:0x%x sharp_gaus_ratio:0x%x sharp_pbf_ratio:0x%x \n",
610 pFix->sharp_sharp_ratio,
611 pFix->sharp_bf_ratio,
612 pFix->sharp_gaus_ratio,
613 pFix->sharp_pbf_ratio);
614
615 // SHARP_SHARP_LUMA_DX (0x0008)
616 for(int i = 0; i < 7; i++) {
617 LOGD_ASHARP("(0x0008) sharp_luma_dx[%d]:0x%x \n",
618 i, pFix->sharp_luma_dx[i]);
619 }
620
621 // SHARP_SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
622 for(int i = 0; i < 8; i++) {
623 LOGD_ASHARP("(0x000c - 0x0014) sharp_pbf_sigma_inv[%d]:0x%x \n",
624 i, pFix->sharp_pbf_sigma_inv[i]);
625 }
626
627 // SHARP_SHARP_BF_SIGMA_INV_0 (0x0018 - 0x0020)
628 for(int i = 0; i < 8; i++) {
629 LOGD_ASHARP("(0x0018 - 0x0020) sharp_bf_sigma_inv[%d]:0x%x \n",
630 i, pFix->sharp_bf_sigma_inv[i]);
631 }
632
633 // SHARP_SHARP_SIGMA_SHIFT (0x00024)
634 LOGD_ASHARP("(0x00024) sharp_bf_sigma_shift:0x%x sharp_pbf_sigma_shift:0x%x \n",
635 pFix->sharp_bf_sigma_shift,
636 pFix->sharp_pbf_sigma_shift);
637
638 // SHARP_SHARP_EHF_TH_0 (0x0028 - 0x0030)
639 for(int i = 0; i < 8; i++) {
640 LOGD_ASHARP("(0x0028 - 0x0030) sharp_ehf_th[%d]:0x%x \n",
641 i, pFix->sharp_ehf_th[i]);
642 }
643
644 // SHARP_SHARP_CLIP_HF_0 (0x0034 - 0x003c)
645 for(int i = 0; i < 8; i++) {
646 LOGD_ASHARP("(0x0034 - 0x003c) sharp_clip_hf[%d]:0x%x \n",
647 i, pFix->sharp_clip_hf[i]);
648 }
649
650 // SHARP_SHARP_PBF_COEF (0x00040)
651 for(int i = 0; i < 3; i++) {
652 LOGD_ASHARP("(0x00040) sharp_pbf_coef[%d]:0x%x \n",
653 i, pFix->sharp_pbf_coef[i]);
654 }
655
656 // SHARP_SHARP_BF_COEF (0x00044)
657 for(int i = 0; i < 3; i++) {
658 LOGD_ASHARP("(0x00044) sharp_bf_coef[%d]:0x%x \n",
659 i, pFix->sharp_bf_coef[i]);
660 }
661
662 // SHARP_SHARP_GAUS_COEF (0x00048)
663 for(int i = 0; i < 3; i++) {
664 LOGD_ASHARP("(0x00048) sharp_gaus_coef[%d]:0x%x \n",
665 i, pFix->sharp_gaus_coef[i]);
666 }
667
668 return res;
669 }
670
671
672
673
sharp_get_setting_by_name_json_V3(CalibDbV2_SharpV3_t * pCalibdbV2,char * name,int * tuning_idx)674 Asharp3_result_t sharp_get_setting_by_name_json_V3(CalibDbV2_SharpV3_t *pCalibdbV2, char *name, int *tuning_idx)
675 {
676 int i = 0;
677 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
678
679 LOGI_ASHARP("%s(%d): enter \n", __FUNCTION__, __LINE__);
680
681 if(pCalibdbV2 == NULL || name == NULL || tuning_idx == NULL) {
682 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
683 return ASHARP3_RET_NULL_POINTER;
684 }
685
686 for(i = 0; i < pCalibdbV2->TuningPara.Setting_len; i++) {
687 if(strncmp(name, pCalibdbV2->TuningPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
688 break;
689 }
690 }
691
692 if(i < pCalibdbV2->TuningPara.Setting_len) {
693 *tuning_idx = i;
694 } else {
695 *tuning_idx = 0;
696 }
697
698 LOGI_ASHARP("%s:%d snr_name:%s snr_idx:%d i:%d \n",
699 __FUNCTION__, __LINE__,
700 name, *tuning_idx, i);
701 return res;
702 }
703
704
sharp_init_params_json_V3(RK_SHARP_Params_V3_t * pSharpParams,CalibDbV2_SharpV3_t * pCalibdbV2,int tuning_idx)705 Asharp3_result_t sharp_init_params_json_V3(RK_SHARP_Params_V3_t *pSharpParams, CalibDbV2_SharpV3_t *pCalibdbV2, int tuning_idx)
706 {
707 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
708 int i = 0;
709 int j = 0;
710 short isoCurveSectValue;
711 short isoCurveSectValue1;
712 float ave1, ave2, ave3, ave4;
713 int bit_calib = 12;
714 int bit_proc;
715 int bit_shift;
716 CalibDbV2_SharpV3_T_ISO_t *pTuningISO;
717
718 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
719
720 if(pSharpParams == NULL || pCalibdbV2 == NULL) {
721 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
722 return ASHARP3_RET_NULL_POINTER;
723 }
724
725
726 for(i = 0; i < pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO_len && i < RK_SHARP_V3_MAX_ISO_NUM; i++) {
727 pTuningISO = &pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO[i];
728 pSharpParams->iso[i] = pTuningISO->iso;
729
730 for(j = 0; j < RK_SHARP_V3_LUMA_POINT_NUM; j++) {
731 pSharpParams->luma_point[j] = pTuningISO->luma_para.luma_point[j];
732 pSharpParams->luma_sigma[i][j] = pTuningISO->luma_para.luma_sigma[j];
733 pSharpParams->lum_clip_h[i][j] = pTuningISO->luma_para.hf_clip[j];
734 pSharpParams->ehf_th[i][j] = pTuningISO->luma_para.local_sharp_strength[j];
735 }
736
737 pSharpParams->pbf_gain[i] = pTuningISO->pbf_gain;
738 pSharpParams->pbf_add[i] = pTuningISO->pbf_add;
739 pSharpParams->pbf_ratio[i] = pTuningISO->pbf_ratio;
740 pSharpParams->gaus_ratio[i] = pTuningISO->gaus_ratio;
741 pSharpParams->sharp_ratio[i] = pTuningISO->sharp_ratio;
742 pSharpParams->bf_gain[i] = pTuningISO->bf_gain;
743 pSharpParams->bf_add[i] = pTuningISO->bf_add;
744 pSharpParams->bf_ratio[i] = pTuningISO->bf_ratio;
745
746 for(j = 0; j < 3; j++) {
747 pSharpParams->kernel_bila_filter[i][j] = pTuningISO->kernel_para.GaussianFilter_coeff[j];
748 pSharpParams->kernel_pre_bila_filter[i][j] = pTuningISO->kernel_para.prefilter_coeff[j];
749 pSharpParams->kernel_range_filter[i][j] = pTuningISO->kernel_para.hfBilateralFilter_coeff[j];
750 LOGD_ASHARP("kernel: index[%d][%d] = %f\n", i, j, pSharpParams->kernel_bila_filter[i][j]);
751 }
752 }
753
754 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
755 return res;
756 }
757
758
sharp_config_setting_param_json_V3(RK_SHARP_Params_V3_t * pParams,CalibDbV2_SharpV3_t * pCalibdbV2,char * param_mode,char * snr_name)759 Asharp3_result_t sharp_config_setting_param_json_V3(RK_SHARP_Params_V3_t *pParams, CalibDbV2_SharpV3_t *pCalibdbV2, char* param_mode, char * snr_name)
760 {
761 Asharp3_result_t res = ASHARP3_RET_SUCCESS;
762 int tuning_idx = 0;
763
764 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
765
766 if(pParams == NULL || pCalibdbV2 == NULL || param_mode == NULL || snr_name == NULL) {
767 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
768 return ASHARP3_RET_NULL_POINTER;
769 }
770
771 LOGD_ASHARP("%s(%d): mode:%s setting:%s \n", __FUNCTION__, __LINE__, param_mode, snr_name);
772
773 res = sharp_get_setting_by_name_json_V3(pCalibdbV2, snr_name, &tuning_idx);
774 if(res != ASHARP3_RET_SUCCESS) {
775 LOGW_ASHARP("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
776 }
777
778 res = sharp_init_params_json_V3(pParams, pCalibdbV2, tuning_idx);
779 pParams->enable = pCalibdbV2->TuningPara.enable;
780
781 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
782
783 return res;
784
785 }
786
787 RKAIQ_END_DECLARE
788
789