1
2 #include "rk_aiq_asharp_algo_sharp_v4.h"
3
4 RKAIQ_BEGIN_DECLARE
5
sharp_select_params_by_ISO_V4(RK_SHARP_Params_V4_t * pParams,RK_SHARP_Params_V4_Select_t * pSelect,Asharp4_ExpInfo_t * pExpInfo)6 Asharp4_result_t sharp_select_params_by_ISO_V4(
7 RK_SHARP_Params_V4_t *pParams,
8 RK_SHARP_Params_V4_Select_t *pSelect,
9 Asharp4_ExpInfo_t *pExpInfo
10 )
11 {
12 Asharp4_result_t res = ASHARP4_RET_SUCCESS;
13
14 int i;
15 int iso = 50;
16 int iso_div = 50;
17 float ratio = 0.0f;
18 int iso_low = iso, iso_high = iso;
19 int gain_high = 0, gain_low = 0;
20 int max_iso_step = RK_SHARP_V4_MAX_ISO_NUM;
21 int sum_coeff, offset;
22
23 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
24
25 if(pParams == NULL) {
26 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
27 return ASHARP4_RET_NULL_POINTER;
28 }
29
30 if(pSelect == NULL) {
31 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
32 return ASHARP4_RET_NULL_POINTER;
33 }
34
35 if(pExpInfo == NULL) {
36 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
37 return ASHARP4_RET_NULL_POINTER;
38 }
39
40 iso = pExpInfo->arIso[pExpInfo->hdr_mode];
41
42 #ifndef RK_SIMULATOR_HW
43 for (i = 0; i < max_iso_step - 1; i++) {
44 if (iso >= pParams->iso[i] && iso <= pParams->iso[i + 1] ) {
45 iso_low = pParams->iso[i] ;
46 iso_high = pParams->iso[i + 1];
47 gain_low = i;
48 gain_high = i + 1;
49 ratio = (float)(iso - iso_low) / (iso_high - iso_low);
50 break;
51 }
52 }
53
54 if(iso < pParams->iso[0] ) {
55 iso_low = pParams->iso[0] ;
56 iso_high = pParams->iso[1];
57 gain_low = 0;
58 gain_high = 1;
59 ratio = 0;
60 }
61
62 if(iso > pParams->iso[max_iso_step - 1] ) {
63 iso_low = pParams->iso[max_iso_step - 2] ;
64 iso_high = pParams->iso[max_iso_step - 1];
65 gain_low = max_iso_step - 2;
66 gain_high = max_iso_step - 1;
67 ratio = 1;
68 }
69 #else
70 for (i = max_iso_step - 1; i >= 0; i--)
71 {
72 if (iso < iso_div * (2 << i))
73 {
74 iso_low = iso_div * (2 << (i)) / 2;
75 iso_high = iso_div * (2 << i);
76 }
77 }
78
79 ratio = (float)(iso - iso_low) / (iso_high - iso_low);
80 if (iso_low == iso)
81 {
82 iso_high = iso;
83 ratio = 0;
84 }
85 if (iso_high == iso )
86 {
87 iso_low = iso;
88 ratio = 1;
89 }
90 gain_high = (int)(log((float)iso_high / 50) / log((float)2));
91 gain_low = (int)(log((float)iso_low / 50) / log((float)2));
92
93
94 gain_low = MIN(MAX(gain_low, 0), max_iso_step - 1);
95 gain_high = MIN(MAX(gain_high, 0), max_iso_step - 1);
96 #endif
97
98 pExpInfo->isoHigh = pParams->iso[gain_high];
99 pExpInfo->isoLow = pParams->iso[gain_low];
100
101
102 LOGD_ASHARP("%s:%d iso:%d gainlow:%d gian_high:%d\n", __FUNCTION__, __LINE__, iso, gain_high, gain_high);
103
104 pSelect->enable = pParams->enable;
105 pSelect->kernel_sigma_enable = pParams->kernel_sigma_enable;
106 pSelect->pbf_gain = INTERP_V4(pParams->pbf_gain[gain_low], pParams->pbf_gain[gain_high], ratio);
107 pSelect->pbf_add = INTERP_V4(pParams->pbf_add[gain_low], pParams->pbf_add[gain_high], ratio);
108 pSelect->pbf_ratio = INTERP_V4(pParams->pbf_ratio[gain_low], pParams->pbf_ratio[gain_high], ratio);
109
110 pSelect->gaus_ratio = INTERP_V4(pParams->gaus_ratio[gain_low], pParams->gaus_ratio[gain_high], ratio);
111 pSelect->sharp_ratio = INTERP_V4(pParams->sharp_ratio[gain_low], pParams->sharp_ratio[gain_high], ratio);
112
113 pSelect->bf_gain = INTERP_V4(pParams->bf_gain[gain_low], pParams->bf_gain[gain_high], ratio);
114 pSelect->bf_add = INTERP_V4(pParams->bf_add[gain_low], pParams->bf_add[gain_high], ratio);
115 pSelect->bf_ratio = INTERP_V4(pParams->bf_ratio[gain_low], pParams->bf_ratio[gain_high], ratio);
116
117 for(int i = 0; i < 3; i++) {
118 pSelect->prefilter_coeff[i] = INTERP_V4(pParams->prefilter_coeff [gain_low][i], pParams->prefilter_coeff[gain_high][i], ratio);
119 }
120
121 for(int i = 0; i < 6; i++) {
122 pSelect->GaussianFilter_coeff[i] = INTERP_V4(pParams->GaussianFilter_coeff [gain_low][i], pParams->GaussianFilter_coeff[gain_high][i], ratio);
123 }
124
125 for(int i = 0; i < 3; i++) {
126 pSelect->hfBilateralFilter_coeff[i] = INTERP_V4(pParams->hfBilateralFilter_coeff [gain_low][i], pParams->hfBilateralFilter_coeff[gain_high][i], ratio);
127 }
128
129 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM; i++) {
130 pSelect->luma_point[i] = pParams->luma_point[i];
131 pSelect->luma_sigma[i] = INTERP_V4(pParams->luma_sigma[gain_low][i], pParams->luma_sigma[gain_high][i], ratio);
132 pSelect->hf_clip[i] = (int16_t)ROUND_F(INTERP_V4(pParams->hf_clip[gain_low][i], pParams->hf_clip[gain_high][i], ratio));
133 pSelect->local_sharp_strength[i] = (int16_t)ROUND_F(INTERP_V4(pParams->local_sharp_strength[gain_low][i], pParams->local_sharp_strength[gain_high][i], ratio));
134 }
135
136 pSelect->prefilter_sigma = INTERP_V4(pParams->prefilter_sigma[gain_low], pParams->prefilter_sigma[gain_high], ratio);
137 pSelect->GaussianFilter_sigma = INTERP_V4(pParams->GaussianFilter_sigma[gain_low], pParams->GaussianFilter_sigma[gain_high], ratio);
138 float tmpf = INTERP_V4(pParams->GaussianFilter_radius[gain_low], pParams->GaussianFilter_radius[gain_high], ratio);
139 pSelect->GaussianFilter_radius = (tmpf > 1.5) ? 2 : 1;
140 pSelect->hfBilateralFilter_sigma = INTERP_V4(pParams->hfBilateralFilter_sigma[gain_low], pParams->hfBilateralFilter_sigma[gain_high], ratio);
141
142 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
143 return res;
144 }
145
146
147
sharp_fix_transfer_V4(RK_SHARP_Params_V4_Select_t * pSelect,RK_SHARP_Fix_V4_t * pFix,rk_aiq_sharp_strength_v4_t * pStrength)148 Asharp4_result_t sharp_fix_transfer_V4(RK_SHARP_Params_V4_Select_t *pSelect, RK_SHARP_Fix_V4_t* pFix, rk_aiq_sharp_strength_v4_t *pStrength)
149 {
150 int sum_coeff, offset;
151 int pbf_sigma_shift = 0;
152 int bf_sigma_shift = 0;
153 Asharp4_result_t res = ASHARP4_RET_SUCCESS;
154 int tmp = 0;
155
156 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
157
158 if(pSelect == NULL) {
159 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
160 return ASHARP4_RET_NULL_POINTER;
161 }
162
163 if(pFix == NULL) {
164 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
165 return ASHARP4_RET_NULL_POINTER;
166 }
167
168 if(pStrength == NULL) {
169 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
170 return ASHARP4_RET_NULL_POINTER;
171 }
172
173
174 float fPercent = 1.0;
175
176 if(pStrength->strength_enable) {
177 fPercent = pStrength->percent;
178 }
179 if(fPercent <= 0.0) {
180 fPercent = 0.000001;
181 }
182
183 LOGD_ASHARP("strength_enable:%d percent:%f %f\n",
184 pStrength->strength_enable,
185 pStrength->percent,
186 fPercent);
187
188 // SHARP_SHARP_EN (0x0000)
189 pFix->sharp_clk_dis = 0;
190 pFix->sharp_exgain_bypass = 0;
191 pFix->sharp_center_mode = 0;
192 pFix->sharp_bypass = 0;
193 pFix->sharp_en = pSelect->enable;
194
195 // SHARP_SHARP_RATIO (0x0004)
196 tmp = (int)ROUND_F(pSelect->sharp_ratio * fPercent * (1 << rk_sharp_V4_sharp_ratio_fix_bits));
197 pFix->sharp_sharp_ratio = CLIP(tmp, 0, 127);
198 tmp = (int)ROUND_F(pSelect->bf_ratio / fPercent * (1 << rk_sharp_V4_bf_ratio_fix_bits));
199 pFix->sharp_bf_ratio = CLIP(tmp, 0, 128);
200 tmp = (int)ROUND_F(pSelect->gaus_ratio / fPercent * (1 << rk_sharp_V4_gaus_ratio_fix_bits));
201 pFix->sharp_gaus_ratio = CLIP(tmp, 0, 128);
202 tmp = (int)ROUND_F(pSelect->pbf_ratio / fPercent * (1 << rk_sharp_V4_bf_ratio_fix_bits));
203 pFix->sharp_pbf_ratio = CLIP(tmp, 0, 128);
204
205 // SHARP_SHARP_LUMA_DX (0x0008)
206 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM - 1; i++)
207 {
208 //tmp = (int16_t)(pSelect->luma_point[i]);
209 tmp = ( log((float)(pSelect->luma_point[i + 1] - pSelect->luma_point[i])) / log((float)2) );
210 pFix->sharp_luma_dx[i] = CLIP(tmp, 0, 15);
211 }
212
213 // SHARP_SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
214 // pre bf sigma inv
215 int sigma_deci_bits = 9;
216 int sigma_inte_bits = 1;
217 int max_val = 0;
218 int min_val = 65536;
219 int shf_bits = 0;
220 short sigma_bits[3];
221 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM; i++)
222 {
223 int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->pbf_gain + pSelect->pbf_add) / fPercent );
224 if(max_val < cur_sigma)
225 max_val = cur_sigma;
226 if(min_val > cur_sigma)
227 min_val = cur_sigma;
228 }
229 sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
230 sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
231 sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
232 pbf_sigma_shift = sigma_bits[2] - 5;
233 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM; i++)
234 {
235 tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->pbf_gain + pSelect->pbf_add) * fPercent * (1 << sigma_bits[2]));
236 pFix->sharp_pbf_sigma_inv[i] = CLIP(tmp, 0, 1023);
237 }
238
239 // SHARP_SHARP_BF_SIGMA_INV_0 (0x0018 - 0x0020)
240 // bf sigma inv
241 sigma_deci_bits = 9;
242 sigma_inte_bits = 1;
243 max_val = 0;
244 min_val = 65536;
245 shf_bits = 0;
246 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM; i++)
247 {
248 int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->bf_gain + pSelect->bf_add) / fPercent );
249 if(max_val < cur_sigma)
250 max_val = cur_sigma;
251 if(min_val > cur_sigma)
252 min_val = cur_sigma;
253 }
254 sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
255 sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
256 sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
257 bf_sigma_shift = sigma_bits[2] - 5;
258 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM; i++)
259 {
260 tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->bf_gain + pSelect->bf_add) * fPercent * (1 << sigma_bits[2]));
261 pFix->sharp_bf_sigma_inv[i] = CLIP(tmp, 0, 1023);
262 }
263
264 // SHARP_SHARP_SIGMA_SHIFT (0x00024)
265 pFix->sharp_pbf_sigma_shift = CLIP(pbf_sigma_shift, 0, 15);
266 pFix->sharp_bf_sigma_shift = CLIP(bf_sigma_shift, 0, 15);
267
268 // SHARP_SHARP_EHF_TH_0 (0x0028 - 0x0030)
269 // wgt = hf * local_sharp_strength
270 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM; i++)
271 {
272 tmp = (int)(pSelect->local_sharp_strength[i] * fPercent);
273 pFix->sharp_ehf_th[i] = CLIP(tmp, 0, 1023);
274 }
275
276 // SHARP_SHARP_CLIP_HF_0 (0x0034 - 0x003c)
277 for(int i = 0; i < RK_SHARP_V4_LUMA_POINT_NUM; i++)
278 {
279 tmp = (int)(pSelect->hf_clip[i] * fPercent);
280 pFix->sharp_clip_hf[i] = CLIP(tmp, 0, 1023);
281 }
282
283 // SHARP_SHARP_PBF_COEF (0x00040)
284 // filter coeff
285 // bf coeff
286 // rk_sharp_V4_pbfCoeff : [4], [1], [0]
287 float prefilter_coeff[3];
288 if(pSelect->kernel_sigma_enable) {
289 float dis_table_3x3[3] = {0.0, 1.0, 2.0};
290 double e = 2.71828182845905;
291 float sigma = pSelect->prefilter_sigma;
292 float sum_gauss_coeff = 0.0;
293 for(int i = 0; i < 3; i++) {
294 float tmp = pow(e, -dis_table_3x3[i] / 2.0 / sigma / sigma );
295 prefilter_coeff[i] = tmp;
296 }
297 sum_gauss_coeff = prefilter_coeff[0] + 4 * prefilter_coeff[1] + 4 * prefilter_coeff[2];
298 for(int i = 0; i < 3; i++) {
299 prefilter_coeff[i] = prefilter_coeff[i] / sum_gauss_coeff;
300 LOGD_ASHARP("kernel_sigma_enable:%d prefilter_coeff[%d]:%f\n", pSelect->kernel_sigma_enable, i, prefilter_coeff[i]);
301 }
302 } else {
303 for(int i = 0; i < 3; i++) {
304 prefilter_coeff[i] = pSelect->prefilter_coeff[i];
305 LOGD_ASHARP("kernel_sigma_enable:%d prefilter_coeff[%d]:%f\n", pSelect->kernel_sigma_enable, i, prefilter_coeff[i]);
306 }
307 }
308 tmp = (int)ROUND_F(prefilter_coeff[0] * (1 << rk_sharp_V4_pbfCoeff_fix_bits));
309 pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);
310 tmp = (int)ROUND_F(prefilter_coeff[1] * (1 << rk_sharp_V4_pbfCoeff_fix_bits));
311 pFix->sharp_pbf_coef[1] = CLIP(tmp, 0, 127);
312 tmp = (int)ROUND_F(prefilter_coeff[2] * (1 << rk_sharp_V4_pbfCoeff_fix_bits));
313 pFix->sharp_pbf_coef[2] = CLIP(tmp, 0, 127);
314 sum_coeff = pFix->sharp_pbf_coef[0] + 4 * pFix->sharp_pbf_coef[1] + 4 * pFix->sharp_pbf_coef[2];
315 offset = (1 << rk_sharp_V4_pbfCoeff_fix_bits) - sum_coeff;
316 tmp = (int)(pFix->sharp_pbf_coef[0] + offset);
317 pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);
318
319 // SHARP_SHARP_BF_COEF (0x00044)
320 // bf coeff
321 // rk_sharp_V4_bfCoeff : [4], [1], [0]
322 float hfBilateralFilter_coeff[3];
323 if(pSelect->kernel_sigma_enable) {
324 float dis_table_3x3[3] = {0.0, 1.0, 2.0};
325 double e = 2.71828182845905;
326 float sigma = pSelect->hfBilateralFilter_sigma;
327 float sum_gauss_coeff = 0.0;
328 for(int i = 0; i < 3; i++) {
329 float tmp = pow(e, -dis_table_3x3[i] / 2.0 / sigma / sigma );
330 hfBilateralFilter_coeff[i] = tmp;
331 }
332 sum_gauss_coeff = hfBilateralFilter_coeff[0] + 4 * hfBilateralFilter_coeff[1] + 4 * hfBilateralFilter_coeff[2];
333 for(int i = 0; i < 3; i++) {
334 hfBilateralFilter_coeff[i] = hfBilateralFilter_coeff[i] / sum_gauss_coeff;
335 LOGD_ASHARP("kernel_sigma_enable:%d hfBilateralFilter_coeff[%d]:%f\n", pSelect->kernel_sigma_enable, i, hfBilateralFilter_coeff[i]);
336 }
337 } else {
338 for(int i = 0; i < 3; i++) {
339 hfBilateralFilter_coeff[i] = pSelect->hfBilateralFilter_coeff[i];
340 LOGD_ASHARP("kernel_sigma_enable:%d hfBilateralFilter_coeff[%d]:%f\n", pSelect->kernel_sigma_enable, i, hfBilateralFilter_coeff[i]);
341 }
342 }
343 tmp = (int)ROUND_F(hfBilateralFilter_coeff[0] * (1 << rk_sharp_V4_hbfCoeff_fix_bits));
344 pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);
345 tmp = (int)ROUND_F(hfBilateralFilter_coeff[1] * (1 << rk_sharp_V4_hbfCoeff_fix_bits));
346 pFix->sharp_bf_coef[1] = CLIP(tmp, 0, 127);
347 tmp = (int)ROUND_F(hfBilateralFilter_coeff[2] * (1 << rk_sharp_V4_hbfCoeff_fix_bits));
348 pFix->sharp_bf_coef[2] = CLIP(tmp, 0, 127);
349 sum_coeff = pFix->sharp_bf_coef[0] + 4 * pFix->sharp_bf_coef[1] + 4 * pFix->sharp_bf_coef[2];
350 offset = (1 << rk_sharp_V4_hbfCoeff_fix_bits) - sum_coeff;
351 tmp = (int)(pFix->sharp_bf_coef[0] + offset);
352 pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);
353
354 // SHARP_SHARP_GAUS_COEF (0x00048)
355 // rk_sharp_V4_rfCoeff : [4], [1], [0]
356 float GaussianFilter_coeff[6];
357 if(pSelect->kernel_sigma_enable) {
358 float gauss_dis_table_5x5[6] = {0.0, 1.0, 2.0, 4.0, 5.0, 8.0};
359 float gauss_dis_table_3x3[6] = {0.0, 1.0, 2.0, 1000, 1000, 1000};
360 double e = 2.71828182845905;
361 float sigma = pSelect->hfBilateralFilter_sigma;
362 float sum_gauss_coeff = 0.0;
363 sigma = pSelect->GaussianFilter_sigma;
364 if(pSelect->GaussianFilter_radius == 2) {
365 for(int i = 0; i < 6; i++) {
366 float tmp = pow(e, -gauss_dis_table_5x5[i] / 2.0 / sigma / sigma );
367 GaussianFilter_coeff[i] = tmp;
368 }
369 } else {
370 for(int i = 0; i < 6; i++) {
371 float tmp = pow(e, -gauss_dis_table_3x3[i] / 2.0 / sigma / sigma );
372 GaussianFilter_coeff[i] = tmp;
373 }
374 }
375
376 sum_gauss_coeff = GaussianFilter_coeff[0]
377 + 4 * GaussianFilter_coeff[1]
378 + 4 * GaussianFilter_coeff[2]
379 + 4 * GaussianFilter_coeff[3]
380 + 8 * GaussianFilter_coeff[4]
381 + 4 * GaussianFilter_coeff[5];
382 for(int i = 0; i < 6; i++) {
383 GaussianFilter_coeff[i] = GaussianFilter_coeff[i] / sum_gauss_coeff;
384 LOGD_ASHARP("kernel_sigma_enable:%d GaussianFilter_coeff[%d]:%f\n", pSelect->kernel_sigma_enable, i, GaussianFilter_coeff[i]);
385 }
386 } else {
387 for(int i = 0; i < 6; i++) {
388 GaussianFilter_coeff[i] = pSelect->GaussianFilter_coeff[i];
389 LOGD_ASHARP("kernel_sigma_enable:%d GaussianFilter_coeff[%d]:%f\n", pSelect->kernel_sigma_enable, i, GaussianFilter_coeff[i]);
390 }
391 }
392 tmp = (int)ROUND_F(GaussianFilter_coeff[0] * (1 << rk_sharp_V4_rfCoeff_fix_bits));
393 pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);
394 tmp = (int)ROUND_F(GaussianFilter_coeff[1] * (1 << rk_sharp_V4_rfCoeff_fix_bits));
395 pFix->sharp_gaus_coef[1] = CLIP(tmp, 0, 127);
396 tmp = (int)ROUND_F(GaussianFilter_coeff[2] * (1 << rk_sharp_V4_rfCoeff_fix_bits));
397 pFix->sharp_gaus_coef[2] = CLIP(tmp, 0, 127);
398 tmp = (int)ROUND_F(GaussianFilter_coeff[3] * (1 << rk_sharp_V4_rfCoeff_fix_bits));
399 pFix->sharp_gaus_coef[3] = CLIP(tmp, 0, 127);
400 tmp = (int)ROUND_F(GaussianFilter_coeff[4] * (1 << rk_sharp_V4_rfCoeff_fix_bits));
401 pFix->sharp_gaus_coef[4] = CLIP(tmp, 0, 127);
402 tmp = (int)ROUND_F(GaussianFilter_coeff[5] * (1 << rk_sharp_V4_rfCoeff_fix_bits));
403 pFix->sharp_gaus_coef[5] = CLIP(tmp, 0, 127);
404 sum_coeff = pFix->sharp_gaus_coef[0]
405 + 4 * pFix->sharp_gaus_coef[1]
406 + 4 * pFix->sharp_gaus_coef[2]
407 + 4 * pFix->sharp_gaus_coef[3]
408 + 8 * pFix->sharp_gaus_coef[4]
409 + 4 * pFix->sharp_gaus_coef[5];
410 offset = (1 << rk_sharp_V4_rfCoeff_fix_bits) - sum_coeff;
411 tmp = (int)(pFix->sharp_gaus_coef[0] + offset);
412 pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);
413
414
415 #if 1
416 sharp_fix_printf_V4(pFix);
417 #endif
418
419 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
420 return res;
421 }
422
423
sharp_fix_printf_V4(RK_SHARP_Fix_V4_t * pFix)424 Asharp4_result_t sharp_fix_printf_V4(RK_SHARP_Fix_V4_t * pFix)
425 {
426 int i = 0;
427 Asharp4_result_t res = ASHARP4_RET_SUCCESS;
428
429 LOGI_ASHARP("%s:(%d) enter \n", __FUNCTION__, __LINE__);
430
431 if(pFix == NULL) {
432 LOGI_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
433 return ASHARP4_RET_NULL_POINTER;
434 }
435
436 // SHARP_SHARP_EN (0x0000)
437 LOGD_ASHARP("(0x0000) sharp_bypass:0x%x sharp_en:0x%x \n",
438 pFix->sharp_bypass,
439 pFix->sharp_en);
440
441
442 // SHARP_SHARP_RATIO (0x0004)
443 LOGD_ASHARP("(0x0004) sharp_sharp_ratio:0x%x sharp_bf_ratio:0x%x sharp_gaus_ratio:0x%x sharp_pbf_ratio:0x%x \n",
444 pFix->sharp_sharp_ratio,
445 pFix->sharp_bf_ratio,
446 pFix->sharp_gaus_ratio,
447 pFix->sharp_pbf_ratio);
448
449 // SHARP_SHARP_LUMA_DX (0x0008)
450 for(int i = 0; i < 7; i++) {
451 LOGD_ASHARP("(0x0008) sharp_luma_dx[%d]:0x%x \n",
452 i, pFix->sharp_luma_dx[i]);
453 }
454
455 // SHARP_SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
456 for(int i = 0; i < 8; i++) {
457 LOGD_ASHARP("(0x000c - 0x0014) sharp_pbf_sigma_inv[%d]:0x%x \n",
458 i, pFix->sharp_pbf_sigma_inv[i]);
459 }
460
461 // SHARP_SHARP_BF_SIGMA_INV_0 (0x0018 - 0x0020)
462 for(int i = 0; i < 8; i++) {
463 LOGD_ASHARP("(0x0018 - 0x0020) sharp_bf_sigma_inv[%d]:0x%x \n",
464 i, pFix->sharp_bf_sigma_inv[i]);
465 }
466
467 // SHARP_SHARP_SIGMA_SHIFT (0x00024)
468 LOGD_ASHARP("(0x00024) sharp_bf_sigma_shift:0x%x sharp_pbf_sigma_shift:0x%x \n",
469 pFix->sharp_bf_sigma_shift,
470 pFix->sharp_pbf_sigma_shift);
471
472 // SHARP_SHARP_EHF_TH_0 (0x0028 - 0x0030)
473 for(int i = 0; i < 8; i++) {
474 LOGD_ASHARP("(0x0028 - 0x0030) sharp_ehf_th[%d]:0x%x \n",
475 i, pFix->sharp_ehf_th[i]);
476 }
477
478 // SHARP_SHARP_CLIP_HF_0 (0x0034 - 0x003c)
479 for(int i = 0; i < 8; i++) {
480 LOGD_ASHARP("(0x0034 - 0x003c) sharp_clip_hf[%d]:0x%x \n",
481 i, pFix->sharp_clip_hf[i]);
482 }
483
484 // SHARP_SHARP_PBF_COEF (0x00040)
485 for(int i = 0; i < 3; i++) {
486 LOGD_ASHARP("(0x00040) sharp_pbf_coef[%d]:0x%x \n",
487 i, pFix->sharp_pbf_coef[i]);
488 }
489
490 // SHARP_SHARP_BF_COEF (0x00044)
491 for(int i = 0; i < 3; i++) {
492 LOGD_ASHARP("(0x00044) sharp_bf_coef[%d]:0x%x \n",
493 i, pFix->sharp_bf_coef[i]);
494 }
495
496 // SHARP_SHARP_GAUS_COEF (0x00048)
497 for(int i = 0; i < 6; i++) {
498 LOGD_ASHARP("(0x00048) sharp_gaus_coef[%d]:0x%x \n",
499 i, pFix->sharp_gaus_coef[i]);
500 }
501
502 return res;
503 }
504
505
506
507
sharp_get_setting_by_name_json_V4(CalibDbV2_SharpV4_t * pCalibdbV2,char * name,int * tuning_idx)508 Asharp4_result_t sharp_get_setting_by_name_json_V4(CalibDbV2_SharpV4_t *pCalibdbV2, char *name, int *tuning_idx)
509 {
510 int i = 0;
511 Asharp4_result_t res = ASHARP4_RET_SUCCESS;
512
513 LOGI_ASHARP("%s(%d): enter \n", __FUNCTION__, __LINE__);
514
515 if(pCalibdbV2 == NULL || name == NULL || tuning_idx == NULL) {
516 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
517 return ASHARP4_RET_NULL_POINTER;
518 }
519
520 for(i = 0; i < pCalibdbV2->TuningPara.Setting_len; i++) {
521 if(strncmp(name, pCalibdbV2->TuningPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
522 break;
523 }
524 }
525
526 if(i < pCalibdbV2->TuningPara.Setting_len) {
527 *tuning_idx = i;
528 } else {
529 *tuning_idx = 0;
530 }
531
532 LOGI_ASHARP("%s:%d snr_name:%s snr_idx:%d i:%d \n",
533 __FUNCTION__, __LINE__,
534 name, *tuning_idx, i);
535 return res;
536 }
537
538
sharp_init_params_json_V4(RK_SHARP_Params_V4_t * pSharpParams,CalibDbV2_SharpV4_t * pCalibdbV2,int tuning_idx)539 Asharp4_result_t sharp_init_params_json_V4(RK_SHARP_Params_V4_t *pSharpParams, CalibDbV2_SharpV4_t *pCalibdbV2, int tuning_idx)
540 {
541 Asharp4_result_t res = ASHARP4_RET_SUCCESS;
542 int i = 0;
543 int j = 0;
544 short isoCurveSectValue;
545 short isoCurveSectValue1;
546 float ave1, ave2, ave3, ave4;
547 int bit_calib = 12;
548 int bit_proc;
549 int bit_shift;
550 CalibDbV2_SharpV4_Set_ISO_t *pTuningISO;
551
552 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
553
554 if(pSharpParams == NULL || pCalibdbV2 == NULL) {
555 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
556 return ASHARP4_RET_NULL_POINTER;
557 }
558
559 pSharpParams->enable = pCalibdbV2->TuningPara.enable;
560 pSharpParams->kernel_sigma_enable = pCalibdbV2->TuningPara.kernel_sigma_enable;
561 for(i = 0; i < pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO_len && i < RK_SHARP_V4_MAX_ISO_NUM; i++) {
562 pTuningISO = &pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO[i];
563 pSharpParams->iso[i] = pTuningISO->iso;
564
565 for(j = 0; j < RK_SHARP_V4_LUMA_POINT_NUM; j++) {
566 pSharpParams->luma_point[j] = pTuningISO->luma_para.luma_point[j];
567 pSharpParams->luma_sigma[i][j] = pTuningISO->luma_para.luma_sigma[j];
568 pSharpParams->hf_clip[i][j] = pTuningISO->luma_para.hf_clip[j];
569 pSharpParams->local_sharp_strength[i][j] = pTuningISO->luma_para.local_sharp_strength[j];
570 }
571
572 pSharpParams->pbf_gain[i] = pTuningISO->pbf_gain;
573 pSharpParams->pbf_add[i] = pTuningISO->pbf_add;
574 pSharpParams->pbf_ratio[i] = pTuningISO->pbf_ratio;
575 pSharpParams->gaus_ratio[i] = pTuningISO->gaus_ratio;
576 pSharpParams->sharp_ratio[i] = pTuningISO->sharp_ratio;
577 pSharpParams->bf_gain[i] = pTuningISO->bf_gain;
578 pSharpParams->bf_add[i] = pTuningISO->bf_add;
579 pSharpParams->bf_ratio[i] = pTuningISO->bf_ratio;
580
581 for(j = 0; j < 3; j++) {
582 pSharpParams->prefilter_coeff[i][j] = pTuningISO->kernel_para.prefilter_coeff[j];
583 pSharpParams->hfBilateralFilter_coeff[i][j] = pTuningISO->kernel_para.hfBilateralFilter_coeff[j];
584 LOGD_ASHARP("kernel: index[%d][%d] = %f\n", i, j, pSharpParams->hfBilateralFilter_coeff[i][j]);
585 }
586
587 for(j = 0; j < 6; j++) {
588 pSharpParams->GaussianFilter_coeff[i][j] = pTuningISO->kernel_para.GaussianFilter_coeff[j];
589 LOGD_ASHARP("kernel: index[%d][%d] = %f\n", i, j, pSharpParams->GaussianFilter_coeff[i][j]);
590 }
591
592 pSharpParams->prefilter_sigma[i] = pTuningISO->kernel_sigma.prefilter_sigma;
593 pSharpParams->hfBilateralFilter_sigma[i] = pTuningISO->kernel_sigma.hfBilateralFilter_sigma;
594 pSharpParams->GaussianFilter_sigma[i] = pTuningISO->kernel_sigma.GaussianFilter_sigma;
595 pSharpParams->GaussianFilter_radius[i] = pTuningISO->kernel_sigma.GaussianFilter_radius;
596 }
597
598 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
599 return res;
600 }
601
602
sharp_config_setting_param_json_V4(RK_SHARP_Params_V4_t * pParams,CalibDbV2_SharpV4_t * pCalibdbV2,char * param_mode,char * snr_name)603 Asharp4_result_t sharp_config_setting_param_json_V4(RK_SHARP_Params_V4_t *pParams, CalibDbV2_SharpV4_t *pCalibdbV2, char* param_mode, char * snr_name)
604 {
605 Asharp4_result_t res = ASHARP4_RET_SUCCESS;
606 int tuning_idx = 0;
607
608 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
609
610 if(pParams == NULL || pCalibdbV2 == NULL || param_mode == NULL || snr_name == NULL) {
611 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
612 return ASHARP4_RET_NULL_POINTER;
613 }
614
615 LOGD_ASHARP("%s(%d): mode:%s setting:%s \n", __FUNCTION__, __LINE__, param_mode, snr_name);
616
617 res = sharp_get_setting_by_name_json_V4(pCalibdbV2, snr_name, &tuning_idx);
618 if(res != ASHARP4_RET_SUCCESS) {
619 LOGW_ASHARP("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
620 }
621
622 res = sharp_init_params_json_V4(pParams, pCalibdbV2, tuning_idx);
623 pParams->enable = pCalibdbV2->TuningPara.enable;
624
625 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
626
627 return res;
628
629 }
630
631 RKAIQ_END_DECLARE
632
633