1 /*
2 * rk_aiq_asharp_algo_sharp_v33.cpp
3 *
4 * Copyright (c) 2022 Rockchip Corporation
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 */
19
20 #include "rk_aiq_asharp_algo_sharp_v33.h"
21
22 RKAIQ_BEGIN_DECLARE
23
sharp_select_params_by_ISO_V33(void * pParams_v,void * pSelect_v,Asharp_ExpInfo_V33_t * pExpInfo)24 Asharp_result_V33_t sharp_select_params_by_ISO_V33(void* pParams_v, void* pSelect_v,
25 Asharp_ExpInfo_V33_t* pExpInfo) {
26 Asharp_result_V33_t res = ASHARP_V33_RET_SUCCESS;
27 #if RKAIQ_HAVE_SHARP_V33
28 RK_SHARP_Params_V33_t* pParams = (RK_SHARP_Params_V33_t*)pParams_v;
29 RK_SHARP_Params_V33_Select_t* pSelect = (RK_SHARP_Params_V33_Select_t*)pSelect_v;
30 #else
31 RK_SHARP_Params_V33LT_t* pParams = (RK_SHARP_Params_V33LT_t*)pParams_v;
32 RK_SHARP_Params_V33LT_Select_t* pSelect = (RK_SHARP_Params_V33LT_Select_t*)pSelect_v;
33 #endif
34
35 int i;
36 int iso = 50;
37 int iso_div = 50;
38 float ratio = 0.0f;
39 int iso_low = iso, iso_high = iso;
40 int gain_high = 0, gain_low = 0;
41 int max_iso_step = RK_SHARP_V33_MAX_ISO_NUM;
42 int sum_coeff, offset;
43
44 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
45
46 if (pParams == NULL) {
47 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
48 return ASHARP_V33_RET_NULL_POINTER;
49 }
50
51 if (pSelect == NULL) {
52 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
53 return ASHARP_V33_RET_NULL_POINTER;
54 }
55
56 if (pExpInfo == NULL) {
57 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
58 return ASHARP_V33_RET_NULL_POINTER;
59 }
60
61 iso = pExpInfo->arIso[pExpInfo->hdr_mode];
62
63 #ifndef RK_SIMULATOR_HW
64 for (i = 0; i < max_iso_step - 1; i++) {
65 if (iso >= pParams->iso[i] && iso <= pParams->iso[i + 1]) {
66 iso_low = pParams->iso[i];
67 iso_high = pParams->iso[i + 1];
68 gain_low = i;
69 gain_high = i + 1;
70 ratio = (float)(iso - iso_low) / (iso_high - iso_low);
71 break;
72 }
73 }
74
75 if (iso < pParams->iso[0]) {
76 iso_low = pParams->iso[0];
77 iso_high = pParams->iso[1];
78 gain_low = 0;
79 gain_high = 1;
80 ratio = 0;
81 }
82
83 if (iso > pParams->iso[max_iso_step - 1]) {
84 iso_low = pParams->iso[max_iso_step - 2];
85 iso_high = pParams->iso[max_iso_step - 1];
86 gain_low = max_iso_step - 2;
87 gain_high = max_iso_step - 1;
88 ratio = 1;
89 }
90 #else
91 for (i = max_iso_step - 1; i >= 0; i--) {
92 if (iso < iso_div * (2 << i)) {
93 iso_low = iso_div * (2 << (i)) / 2;
94 iso_high = iso_div * (2 << i);
95 }
96 }
97
98 ratio = (float)(iso - iso_low) / (iso_high - iso_low);
99 if (iso_low == iso) {
100 iso_high = iso;
101 ratio = 0;
102 }
103 if (iso_high == iso) {
104 iso_low = iso;
105 ratio = 1;
106 }
107 gain_high = (int)(log((float)iso_high / 50) / log((float)2));
108 gain_low = (int)(log((float)iso_low / 50) / log((float)2));
109
110 gain_low = MIN(MAX(gain_low, 0), max_iso_step - 1);
111 gain_high = MIN(MAX(gain_high, 0), max_iso_step - 1);
112 #endif
113
114 LOGD_ASHARP("%s:%d iso:%d gainlow:%d gian_high:%d\n", __FUNCTION__, __LINE__, iso, gain_high,
115 gain_high);
116
117 pExpInfo->isoLevelLow = gain_low;
118 pExpInfo->isoLevelHig = gain_high;
119 pSelect->enable = pParams->enable;
120
121 pSelect->Center_Mode = pParams->Center_Mode;
122 pSelect->kernel_sigma_enable = pParams->kernel_sigma_enable;
123 pSelect->sharp_ratio_seperate_en = pParams->sharp_ratio_seperate_en;
124 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
125 pSelect->luma_point[i] =
126 pParams->sharpParamsISO[gain_low].luma_point[i];
127 pSelect->luma_sigma[i] =
128 INTERP_V4(pParams->sharpParamsISO[gain_low].luma_sigma[i],
129 pParams->sharpParamsISO[gain_high].luma_sigma[i], ratio);
130 pSelect->hf_clip[i] =
131 (uint16_t)ROUND_F(INTERP_V4(pParams->sharpParamsISO[gain_low].hf_clip[i],
132 pParams->sharpParamsISO[gain_high].hf_clip[i], ratio));
133 #if RKAIQ_HAVE_SHARP_V33_LITE
134 pSelect->hf_clip_neg[i] =
135 (uint16_t)ROUND_F(INTERP_V4(pParams->sharpParamsISO[gain_low].hf_clip_neg[i],
136 pParams->sharpParamsISO[gain_high].hf_clip_neg[i], ratio));
137 pSelect->local_sharp_strength[i] =
138 INTERP_V4(pParams->sharpParamsISO[gain_low].local_sharp_strength[i],
139 pParams->sharpParamsISO[gain_high].local_sharp_strength[i], ratio);
140 #endif
141 }
142
143 if (iso - iso_low <= iso_high - iso) {
144 pSelect->GaussianFilter_radius_0 = pParams->sharpParamsISO[gain_low].GaussianFilter_radius_0;
145 pSelect->GaussianFilter_radius_1 = pParams->sharpParamsISO[gain_low].GaussianFilter_radius_1;
146 pSelect->GaussianFilter_radius = pParams->sharpParamsISO[gain_low].GaussianFilter_radius;
147 #if RKAIQ_HAVE_SHARP_V33
148 pSelect->global_hf_clip_pos = pParams->sharpParamsISO[gain_low].global_hf_clip_pos;
149 pSelect->noiseclip_mode = pParams->sharpParamsISO[gain_low].noiseclip_mode;
150 #endif
151 #if RKAIQ_HAVE_SHARP_V33_LITE
152 pSelect->clip_hf_mode = pParams->sharpParamsISO[gain_low].clip_hf_mode;
153 pSelect->add_mode = pParams->sharpParamsISO[gain_low].add_mode;
154 #endif
155 } else {
156 pSelect->GaussianFilter_radius_0 = pParams->sharpParamsISO[gain_high].GaussianFilter_radius_0;
157 pSelect->GaussianFilter_radius_1 = pParams->sharpParamsISO[gain_high].GaussianFilter_radius_1;
158 pSelect->GaussianFilter_radius = pParams->sharpParamsISO[gain_high].GaussianFilter_radius;
159 #if RKAIQ_HAVE_SHARP_V33
160 pSelect->global_hf_clip_pos = pParams->sharpParamsISO[gain_high].global_hf_clip_pos;
161 pSelect->noiseclip_mode = pParams->sharpParamsISO[gain_high].noiseclip_mode;
162 #endif
163 #if RKAIQ_HAVE_SHARP_V33_LITE
164 pSelect->clip_hf_mode = pParams->sharpParamsISO[gain_high].clip_hf_mode;
165 pSelect->add_mode = pParams->sharpParamsISO[gain_high].add_mode;
166 #endif
167 }
168
169 pSelect->prefilter_sigma =
170 INTERP_V4(pParams->sharpParamsISO[gain_low].prefilter_sigma,
171 pParams->sharpParamsISO[gain_high].prefilter_sigma, ratio);
172 pSelect->hfBilateralFilter_sigma =
173 INTERP_V4(pParams->sharpParamsISO[gain_low].hfBilateralFilter_sigma,
174 pParams->sharpParamsISO[gain_high].hfBilateralFilter_sigma, ratio);
175 pSelect->GaussianFilter_sigma_0 =
176 INTERP_V4(pParams->sharpParamsISO[gain_low].GaussianFilter_sigma_0,
177 pParams->sharpParamsISO[gain_high].GaussianFilter_sigma_0, ratio);
178 pSelect->GaussianFilter_sigma_1 =
179 INTERP_V4(pParams->sharpParamsISO[gain_low].GaussianFilter_sigma_1,
180 pParams->sharpParamsISO[gain_high].GaussianFilter_sigma_1, ratio);
181 pSelect->GaussianFilter_sigma =
182 INTERP_V4(pParams->sharpParamsISO[gain_low].GaussianFilter_sigma,
183 pParams->sharpParamsISO[gain_high].GaussianFilter_sigma, ratio);
184
185 pSelect->pbf_gain =
186 INTERP_V4(pParams->sharpParamsISO[gain_low].pbf_gain,
187 pParams->sharpParamsISO[gain_high].pbf_gain, ratio);
188 pSelect->pbf_add =
189 INTERP_V4(pParams->sharpParamsISO[gain_low].pbf_add,
190 pParams->sharpParamsISO[gain_high].pbf_add, ratio);
191 pSelect->pbf_ratio =
192 INTERP_V4(pParams->sharpParamsISO[gain_low].pbf_ratio,
193 pParams->sharpParamsISO[gain_high].pbf_ratio, ratio);
194
195 pSelect->gaus_ratio =
196 INTERP_V4(pParams->sharpParamsISO[gain_low].gaus_ratio,
197 pParams->sharpParamsISO[gain_high].gaus_ratio, ratio);
198
199 pSelect->sharp_ratio_0 =
200 INTERP_V4(pParams->sharpParamsISO[gain_low].sharp_ratio_0,
201 pParams->sharpParamsISO[gain_high].sharp_ratio_0, ratio);
202 pSelect->sharp_ratio_1 =
203 INTERP_V4(pParams->sharpParamsISO[gain_low].sharp_ratio_1,
204 pParams->sharpParamsISO[gain_high].sharp_ratio_1, ratio);
205 pSelect->sharp_ratio =
206 INTERP_V4(pParams->sharpParamsISO[gain_low].sharp_ratio,
207 pParams->sharpParamsISO[gain_high].sharp_ratio, ratio);
208
209
210 pSelect->bf_gain =
211 INTERP_V4(pParams->sharpParamsISO[gain_low].bf_gain,
212 pParams->sharpParamsISO[gain_high].bf_gain, ratio);
213 pSelect->bf_add = INTERP_V4(
214 pParams->sharpParamsISO[gain_low].bf_add, pParams->sharpParamsISO[gain_high].bf_add, ratio);
215 pSelect->bf_ratio =
216 INTERP_V4(pParams->sharpParamsISO[gain_low].bf_ratio,
217 pParams->sharpParamsISO[gain_high].bf_ratio, ratio);
218
219 for (int i = 0; i < 3; i++) {
220 pSelect->prefilter_coeff[i] =
221 INTERP_V4(pParams->sharpParamsISO[gain_low].prefilter_coeff[i],
222 pParams->sharpParamsISO[gain_high].prefilter_coeff[i], ratio);
223 }
224
225 for (int i = 0; i < 6; i++) {
226 pSelect->GaussianFilter_coeff_0[i] =
227 INTERP_V4(pParams->sharpParamsISO[gain_low].GaussianFilter_coeff_0[i],
228 pParams->sharpParamsISO[gain_high].GaussianFilter_coeff_0[i], ratio);
229 pSelect->GaussianFilter_coeff_1[i] =
230 INTERP_V4(pParams->sharpParamsISO[gain_low].GaussianFilter_coeff_1[i],
231 pParams->sharpParamsISO[gain_high].GaussianFilter_coeff_1[i], ratio);
232 pSelect->GaussianFilter_coeff[i] =
233 INTERP_V4(pParams->sharpParamsISO[gain_low].GaussianFilter_coeff[i],
234 pParams->sharpParamsISO[gain_high].GaussianFilter_coeff[i], ratio);
235
236 }
237
238 for (int i = 0; i < 3; i++) {
239 pSelect->hfBilateralFilter_coeff[i] =
240 INTERP_V4(pParams->sharpParamsISO[gain_low].hfBilateralFilter_coeff[i],
241 pParams->sharpParamsISO[gain_high].hfBilateralFilter_coeff[i], ratio);
242 }
243
244 pSelect->global_gain =
245 INTERP_V4(pParams->sharpParamsISO[gain_low].global_gain,
246 pParams->sharpParamsISO[gain_high].global_gain, ratio);
247 pSelect->global_gain_alpha =
248 INTERP_V4(pParams->sharpParamsISO[gain_low].global_gain_alpha,
249 pParams->sharpParamsISO[gain_high].global_gain_alpha, ratio);
250 pSelect->local_gainscale =
251 INTERP_V4(pParams->sharpParamsISO[gain_low].local_gainscale,
252 pParams->sharpParamsISO[gain_high].local_gainscale, ratio);
253
254 for (int i = 0; i < RK_SHARP_V33_SHARP_ADJ_GAIN_TABLE_LEN; i++) {
255 pSelect->gain_adj_sharp_strength[i] =
256 INTERP_V4(pParams->sharpParamsISO[gain_low].gain_adj_sharp_strength[i],
257 pParams->sharpParamsISO[gain_high].gain_adj_sharp_strength[i], ratio);
258 }
259 pSelect->exgain_bypass =
260 INTERP_V4(pParams->sharpParamsISO[gain_low].exgain_bypass,
261 pParams->sharpParamsISO[gain_high].exgain_bypass, ratio);
262
263 for (int i = 0; i < RK_SHARP_V33_STRENGTH_TABLE_LEN; i++) {
264 pSelect->dis_adj_sharp_strength[i] =
265 INTERP_V4(pParams->sharpParamsISO[gain_low].dis_adj_sharp_strength[i],
266 pParams->sharpParamsISO[gain_high].dis_adj_sharp_strength[i], ratio);
267 }
268
269 #if RKAIQ_HAVE_SHARP_V33
270 pSelect->noiseclip_strength =
271 INTERP_V4(pParams->sharpParamsISO[gain_low].noiseclip_strength,
272 pParams->sharpParamsISO[gain_high].noiseclip_strength, ratio);
273 pSelect->enhance_bit =
274 INTERP_V4(pParams->sharpParamsISO[gain_low].enhance_bit,
275 pParams->sharpParamsISO[gain_high].enhance_bit, ratio);
276 pSelect->noise_sigma_clip =
277 INTERP_V4(pParams->sharpParamsISO[gain_low].noise_sigma_clip,
278 pParams->sharpParamsISO[gain_high].noise_sigma_clip, ratio);
279 #endif
280
281 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
282 return res;
283 }
284
sharp_fix_transfer_V33(void * pSelect_v,RK_SHARP_Fix_V33_t * pFix,rk_aiq_sharp_strength_v33_t * pStrength,Asharp_ExpInfo_V33_t * pExpInfo)285 Asharp_result_V33_t sharp_fix_transfer_V33(void* pSelect_v, RK_SHARP_Fix_V33_t* pFix,
286 rk_aiq_sharp_strength_v33_t* pStrength,
287 Asharp_ExpInfo_V33_t* pExpInfo) {
288 int sum_coeff, offset;
289 int pbf_sigma_shift = 0;
290 int bf_sigma_shift = 0;
291 Asharp_result_V33_t res = ASHARP_V33_RET_SUCCESS;
292 int tmp = 0;
293
294 #if RKAIQ_HAVE_SHARP_V33
295 RK_SHARP_Params_V33_Select_t* pSelect = (RK_SHARP_Params_V33_Select_t*)pSelect_v;
296 #else
297 RK_SHARP_Params_V33LT_Select_t* pSelect = (RK_SHARP_Params_V33LT_Select_t*)pSelect_v;
298 #endif
299
300 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
301
302 if (pSelect == NULL) {
303 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
304 return ASHARP_V33_RET_NULL_POINTER;
305 }
306
307 if (pFix == NULL) {
308 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
309 return ASHARP_V33_RET_NULL_POINTER;
310 }
311
312 if (pStrength == NULL) {
313 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
314 return ASHARP_V33_RET_NULL_POINTER;
315 }
316
317 if(pExpInfo == NULL) {
318 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
319 return ASHARP_V33_RET_NULL_POINTER;
320 }
321
322 float fPercent = 1.0f;
323
324 if(pStrength->strength_enable) {
325 fPercent = pStrength->percent;
326 }
327 if(fPercent <= 0.0) {
328 fPercent = 0.000001;
329 }
330
331 LOGD_ASHARP("strength_enable:%d fPercent: %f \n", pStrength->strength_enable, fPercent);
332
333 LOGD_ASHARP("%s:%d strength:%f raw:width:%d height:%d\n",
334 __FUNCTION__, __LINE__,
335 fPercent, pExpInfo->rawHeight, pExpInfo->rawWidth);
336
337 int rows = pExpInfo->rawHeight; //raw height
338 int cols = pExpInfo->rawWidth; //raw width
339
340 // SHARP_EN (0x0000)
341 pFix->sharp_exgain_bypass = pSelect->exgain_bypass;
342 pFix->sharp_center_mode = 0;
343 #if RKAIQ_HAVE_SHARP_V33
344 pFix->sharp_noiseclip_mode = pSelect->noiseclip_mode;
345 #else
346 pFix->sharp_noiseclip_mode = 0;
347 #endif
348 pFix->sharp_bypass = !pSelect->enable;
349 pFix->sharp_en = pSelect->enable;
350
351 #if RKAIQ_HAVE_SHARP_V33_LITE
352 pFix->sharp_clip_hf_mode = pSelect->clip_hf_mode;
353 pFix->sharp_add_mode = pSelect->add_mode;
354 #else
355 pFix->sharp_clip_hf_mode = 0;
356 pFix->sharp_add_mode = 0;
357 #endif
358
359 if (cols > 3072 && rows > 1728) {
360 pFix->sharp_radius_ds_mode = 1;
361 } else {
362 pFix->sharp_radius_ds_mode = 0;
363 }
364 #if RKAIQ_HAVE_SHARP_V33
365 LOGD_ASHARP("sharp_noiseclip_mode:%d \n", pFix->sharp_noiseclip_mode);
366 #endif
367
368 // CENTER
369 pFix->sharp_center_mode = pSelect->Center_Mode;
370 tmp = cols / 2;
371 pFix->sharp_center_wid = CLIP(tmp, 0, 8191);
372 tmp = rows / 2;
373 pFix->sharp_center_het = CLIP(tmp, 0, 8191);
374
375 // SHARP_RATIO (0x0004)
376 tmp = (int)ROUND_F(pSelect->pbf_ratio / fPercent *
377 (1 << RK_SHARP_V33_BF_RATIO_FIX_BITS));
378 pFix->sharp_pbf_ratio = CLIP(tmp, 0, 0x80);
379 tmp = (int)ROUND_F(pSelect->gaus_ratio / fPercent *
380 (1 << RK_SHARP_V33_GAUS_RATIO_FIX_BITS));
381 pFix->sharp_gaus_ratio = CLIP(tmp, 0, 0x80);
382 if(pSelect->sharp_ratio_seperate_en) {
383 tmp = (int)ROUND_F( (pSelect->sharp_ratio_0 + pSelect->sharp_ratio_1) * fPercent *
384 (1 << RK_SHARP_V33_SHARP_RATIO_FIX_BITS));
385 } else {
386 tmp = (int)ROUND_F(pSelect->sharp_ratio * fPercent *
387 (1 << RK_SHARP_V33_SHARP_RATIO_FIX_BITS));
388 }
389
390 pFix->sharp_sharp_ratio = CLIP(tmp, 0, 127);
391 tmp = (int)ROUND_F(pSelect->bf_ratio / fPercent *
392 (1 << RK_SHARP_V33_BF_RATIO_FIX_BITS));
393 pFix->sharp_bf_ratio = CLIP(tmp, 0, 0x80);
394
395 // SHARP_LUMA_DX (0x0008)
396 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM - 1; i++) {
397 tmp = (int16_t)LOG2(pSelect->luma_point[i + 1] -
398 pSelect->luma_point[i]);
399 pFix->sharp_luma_dx[i] = CLIP(tmp, 0, 15);
400 }
401
402 // SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
403 // pre bf sigma inv
404 int sigma_deci_bits = 9;
405 int sigma_inte_bits = 1;
406 int max_val = 0;
407 int min_val = 65536;
408 int shf_bits = 0;
409 short sigma_bits[3];
410 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
411 int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->pbf_gain +
412 pSelect->pbf_add) / fPercent);
413 if (max_val < cur_sigma) max_val = cur_sigma;
414 if (min_val > cur_sigma) min_val = cur_sigma;
415 }
416 sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
417 sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
418 sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
419 pbf_sigma_shift = sigma_bits[2] - 5;
420 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
421 tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->pbf_gain +
422 pSelect->pbf_add) * fPercent * (1 << sigma_bits[2]));
423 pFix->sharp_pbf_sigma_inv[i] = CLIP(tmp, 0, 4095);
424 }
425
426 // SHARP_BF_SIGMA_INV_0 (0x0018 - 0x0020)
427 // bf sigma inv
428 sigma_deci_bits = 9;
429 sigma_inte_bits = 1;
430 max_val = 0;
431 min_val = 65536;
432 shf_bits = 0;
433 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
434 int cur_sigma = FLOOR((pSelect->luma_sigma[i] * pSelect->bf_gain
435 + pSelect->bf_add) / fPercent);
436 if (max_val < cur_sigma) max_val = cur_sigma;
437 if (min_val > cur_sigma) min_val = cur_sigma;
438 }
439 sigma_bits[0] = FLOOR(log((float)min_val) / log((float)2));
440 sigma_bits[1] = MAX(sigma_inte_bits - sigma_bits[0], 0);
441 sigma_bits[2] = sigma_deci_bits + sigma_bits[0];
442 bf_sigma_shift = sigma_bits[2] - 5;
443 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
444 tmp = (int16_t)ROUND_F((float)1 / (pSelect->luma_sigma[i] * pSelect->bf_gain +
445 pSelect->bf_add) * fPercent * (1 << sigma_bits[2]));
446 pFix->sharp_bf_sigma_inv[i] = CLIP(tmp, 0, 4095);
447 }
448
449 // SHARP_SIGMA_SHIFT (0x00024)
450 pFix->sharp_pbf_sigma_shift = CLIP(pbf_sigma_shift, 0, 15);
451 pFix->sharp_bf_sigma_shift = CLIP(bf_sigma_shift, 0, 15);
452
453 // SHARP_SHARP_CLIP_HF_0 (0x0034 - 0x003c)
454 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
455 tmp = (int)(pSelect->hf_clip[i] * fPercent);
456 pFix->sharp_clip_hf[i] = CLIP(tmp, 0, 1023);
457 #if RKAIQ_HAVE_SHARP_V33_LITE
458 tmp = (int)(pSelect->hf_clip_neg[i] * fPercent);
459 pFix->sharp_clip_neg[i] = CLIP(tmp, 0, 1023);
460 #else
461 pFix->sharp_clip_neg[i] = 0;
462 #endif
463 }
464
465 // SHARP_SHARP_PBF_COEF (0x00040)
466 // filter coeff
467 // bf coeff
468 // rk_sharp_V33_pbfCoeff : [4], [1], [0]
469 float pre_bila_filter[3];
470 if (pSelect->kernel_sigma_enable) {
471 float dis_table_3x3[3] = {0.0, 1.0, 2.0};
472 double e = 2.71828182845905;
473 float sigma = pSelect->prefilter_sigma;
474 float sum_gauss_coeff = 0.0;
475 for (int i = 0; i < 3; i++) {
476 float tmp = pow(e, -dis_table_3x3[i] / 2.0 / sigma / sigma);
477 pre_bila_filter[i] = tmp;
478 }
479 sum_gauss_coeff = pre_bila_filter[0] + 4 * pre_bila_filter[1] + 4 * pre_bila_filter[2];
480 for (int i = 0; i < 3; i++) {
481 pre_bila_filter[i] = pre_bila_filter[i] / sum_gauss_coeff;
482 LOGD_ASHARP("kernel_sigma_enable:%d pre_bila_filter[%d]:%f\n",
483 pSelect->kernel_sigma_enable, i, pre_bila_filter[i]);
484 }
485 } else {
486 for (int i = 0; i < 3; i++) {
487 pre_bila_filter[i] = pSelect->prefilter_coeff[i];
488 LOGD_ASHARP("kernel_sigma_enable:%d pre_bila_filter[%d]:%f\n",
489 pSelect->kernel_sigma_enable, i, pre_bila_filter[i]);
490 }
491 }
492 tmp = (int)ROUND_F(pre_bila_filter[0] * (1 << RK_SHARP_V33_PBFCOEFF_FIX_BITS));
493 pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);
494 tmp = (int)ROUND_F(pre_bila_filter[1] * (1 << RK_SHARP_V33_PBFCOEFF_FIX_BITS));
495 pFix->sharp_pbf_coef[1] = CLIP(tmp, 0, 127);
496 tmp = (int)ROUND_F(pre_bila_filter[2] * (1 << RK_SHARP_V33_PBFCOEFF_FIX_BITS));
497 pFix->sharp_pbf_coef[2] = CLIP(tmp, 0, 127);
498
499 sum_coeff = pFix->sharp_pbf_coef[0] + 4 * pFix->sharp_pbf_coef[1] + 4 * pFix->sharp_pbf_coef[2];
500 offset = (1 << RK_SHARP_V33_PBFCOEFF_FIX_BITS) - sum_coeff;
501 tmp = (int)(pFix->sharp_pbf_coef[0] + offset);
502 pFix->sharp_pbf_coef[0] = CLIP(tmp, 0, 127);
503
504 // SHARP_SHARP_GAUS_COEF (0x00048)
505 // rk_sharp_V33_rfCoeff : [4], [1], [0]
506 float bila_filter[3];
507 if (pSelect->kernel_sigma_enable) {
508 float dis_table_3x3[3] = {0.0, 1.0, 2.0};
509 double e = 2.71828182845905;
510 float sigma = pSelect->hfBilateralFilter_sigma;
511 float sum_gauss_coeff = 0.0;
512 for (int i = 0; i < 3; i++) {
513 float tmp = pow(e, -dis_table_3x3[i] / 2.0 / sigma / sigma);
514 bila_filter[i] = tmp;
515 }
516 sum_gauss_coeff = bila_filter[0] + 4 * bila_filter[1] + 4 * bila_filter[2];
517 for (int i = 0; i < 3; i++) {
518 bila_filter[i] = bila_filter[i] / sum_gauss_coeff;
519 LOGD_ASHARP("kernel_sigma_enable:%d bila_filter[%d]:%f\n", pSelect->kernel_sigma_enable,
520 i, bila_filter[i]);
521 }
522 } else {
523 for (int i = 0; i < 3; i++) {
524 bila_filter[i] = pSelect->hfBilateralFilter_coeff[i];
525 LOGD_ASHARP("kernel_sigma_enable:%d bila_filter[%d]:%f\n", pSelect->kernel_sigma_enable,
526 i, bila_filter[i]);
527 }
528 }
529 tmp = (int)ROUND_F(bila_filter[0] * (1 << RK_SHARP_V33_RFCOEFF_FIX_BITS));
530 pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);
531 tmp = (int)ROUND_F(bila_filter[1] * (1 << RK_SHARP_V33_RFCOEFF_FIX_BITS));
532 pFix->sharp_bf_coef[1] = CLIP(tmp, 0, 127);
533 tmp = (int)ROUND_F(bila_filter[2] * (1 << RK_SHARP_V33_RFCOEFF_FIX_BITS));
534 pFix->sharp_bf_coef[2] = CLIP(tmp, 0, 127);
535
536 sum_coeff = pFix->sharp_bf_coef[0] + 4 * pFix->sharp_bf_coef[1] + 4 * pFix->sharp_bf_coef[2];
537 offset = (1 << RK_SHARP_V33_PBFCOEFF_FIX_BITS) - sum_coeff;
538 tmp = (int)(pFix->sharp_bf_coef[0] + offset);
539 pFix->sharp_bf_coef[0] = CLIP(tmp, 0, 127);
540
541 // SHARP_SHARP_BF_COEF (0x00044)
542 // bf coeff
543 // rk_sharp_V33_rfCoeff : [4], [1], [0]
544 float range_filter[6];
545 float kernel0_ratio = 0, kernel1_ratio = 0;
546 if(pSelect->sharp_ratio_seperate_en) {
547 kernel0_ratio = pSelect->sharp_ratio_0 / (pSelect->sharp_ratio_0 + pSelect->sharp_ratio_1);
548 kernel1_ratio = pSelect->sharp_ratio_1 / (pSelect->sharp_ratio_0 + pSelect->sharp_ratio_1);
549 LOGD_ASHARP("GaussianFilter_sigma = %f %f ,GaussianFilter_radius %f %f \n",
550 pSelect->GaussianFilter_sigma_0, pSelect->GaussianFilter_sigma_1,
551 pSelect->GaussianFilter_radius_0, pSelect->GaussianFilter_radius_1);
552 } else {
553 LOGD_ASHARP("GaussianFilter_sigma = %f ,GaussianFilter_radius %f \n",
554 pSelect->GaussianFilter_sigma,
555 pSelect->GaussianFilter_radius);
556 }
557 if (pSelect->kernel_sigma_enable) {
558 float gauss_dis_table_5x5[6] = {0.0, 1.0, 2.0, 4.0, 5.0, 8.0};
559 float gauss_dis_table_3x3[6] = {0.0, 1.0, 2.0, 1000, 1000, 1000};
560 double e = 2.71828182845905;
561 if(pSelect->sharp_ratio_seperate_en) {
562 float sigma = pSelect->GaussianFilter_sigma_0;
563 float sigma1 = pSelect->GaussianFilter_sigma_1;
564 float range_filter_1[6];
565 float sum_gauss_coeff = 0.0;
566 float sum_gauss_coeff_1 = 0.0;
567 if (pSelect->GaussianFilter_radius_0 == 2) {
568 for (int i = 0; i < 6; i++) {
569 float tmp = pow(e, -gauss_dis_table_5x5[i] / 2.0 / sigma / sigma);
570 range_filter[i] = tmp;
571 }
572 } else {
573 for (int i = 0; i < 6; i++) {
574 float tmp = pow(e, -gauss_dis_table_3x3[i] / 2.0 / sigma / sigma);
575 range_filter[i] = tmp;
576 }
577 }
578
579 if (pSelect->GaussianFilter_radius_1 == 2) {
580 for (int i = 0; i < 6; i++) {
581 float tmp = pow(e, -gauss_dis_table_5x5[i] / 2.0 / sigma1 / sigma1);
582 range_filter_1[i] = tmp;
583 }
584 } else {
585 for (int i = 0; i < 6; i++) {
586 float tmp = pow(e, -gauss_dis_table_3x3[i] / 2.0 / sigma1 / sigma1);
587 range_filter_1[i] = tmp;
588 }
589 }
590
591 sum_gauss_coeff = range_filter[0] + 4 * range_filter[1] + 4 * range_filter[2] +
592 4 * range_filter[3] + 8 * range_filter[4] + 4 * range_filter[5];
593 for (int i = 0; i < 6; i++) {
594 range_filter[i] = range_filter[i] / sum_gauss_coeff;
595 }
596
597 sum_gauss_coeff_1 = range_filter_1[0] + 4 * range_filter_1[1] + 4 * range_filter_1[2] +
598 4 * range_filter_1[3] + 8 * range_filter_1[4] + 4 * range_filter_1[5];
599 for (int i = 0; i < 6; i++) {
600 range_filter_1[i] = range_filter_1[i] / sum_gauss_coeff_1;
601 }
602
603
604 for (int i = 0; i < 6; i++) {
605 range_filter[i] = kernel0_ratio * range_filter[i] + kernel1_ratio * range_filter_1[i];
606 LOGD_ASHARP("kernel_sigma_enable:%d range_filter_combine[%d]:%f\n",
607 pSelect->kernel_sigma_enable, i, range_filter[i]);
608 }
609 } else {
610 float sigma = pSelect->GaussianFilter_sigma;
611 float sum_gauss_coeff = 0.0;
612 if (pSelect->GaussianFilter_radius == 2) {
613 for (int i = 0; i < 6; i++) {
614 float tmp = pow(e, -gauss_dis_table_5x5[i] / 2.0 / sigma / sigma);
615 range_filter[i] = tmp;
616 }
617 } else {
618 for (int i = 0; i < 6; i++) {
619 float tmp = pow(e, -gauss_dis_table_3x3[i] / 2.0 / sigma / sigma);
620 range_filter[i] = tmp;
621 }
622 }
623
624 sum_gauss_coeff = range_filter[0] + 4 * range_filter[1] + 4 * range_filter[2] +
625 4 * range_filter[3] + 8 * range_filter[4] + 4 * range_filter[5];
626 for (int i = 0; i < 6; i++) {
627 range_filter[i] = range_filter[i] / sum_gauss_coeff;
628 LOGD_ASHARP("kernel_sigma_enable:%d range_filter[%d]:%f\n",
629 pSelect->kernel_sigma_enable, i, range_filter[i]);
630 }
631 }
632 } else {
633 for (int i = 0; i < 6; i++) {
634 if(pSelect->sharp_ratio_seperate_en) {
635 range_filter[i] = kernel0_ratio * pSelect->GaussianFilter_coeff_0[i]
636 + kernel1_ratio * pSelect->GaussianFilter_coeff_1[i];
637 } else {
638 range_filter[i] = pSelect->GaussianFilter_coeff[i];
639 }
640 LOGD_ASHARP("kernel_sigma_enable:%d range_filter[%d]:%f\n",
641 pSelect->kernel_sigma_enable, i, range_filter[i]);
642 }
643 }
644 tmp = (int)ROUND_F(range_filter[0] * (1 << RK_SHARP_V33_HBFCOEFF_FIX_BITS));
645 pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);
646 tmp = (int)ROUND_F(range_filter[1] * (1 << RK_SHARP_V33_HBFCOEFF_FIX_BITS));
647 pFix->sharp_gaus_coef[1] = CLIP(tmp, 0, 127);
648 tmp = (int)ROUND_F(range_filter[2] * (1 << RK_SHARP_V33_HBFCOEFF_FIX_BITS));
649 pFix->sharp_gaus_coef[2] = CLIP(tmp, 0, 127);
650 tmp = (int)ROUND_F(range_filter[3] * (1 << RK_SHARP_V33_HBFCOEFF_FIX_BITS));
651 pFix->sharp_gaus_coef[3] = CLIP(tmp, 0, 127);
652 tmp = (int)ROUND_F(range_filter[4] * (1 << RK_SHARP_V33_HBFCOEFF_FIX_BITS));
653 pFix->sharp_gaus_coef[4] = CLIP(tmp, 0, 127);
654 tmp = (int)ROUND_F(range_filter[5] * (1 << RK_SHARP_V33_HBFCOEFF_FIX_BITS));
655 pFix->sharp_gaus_coef[5] = CLIP(tmp, 0, 127);
656
657 sum_coeff = pFix->sharp_gaus_coef[0] +
658 4 * pFix->sharp_gaus_coef[1] +
659 4 * pFix->sharp_gaus_coef[2] +
660 4 * pFix->sharp_gaus_coef[3] +
661 8 * pFix->sharp_gaus_coef[4] +
662 4 * pFix->sharp_gaus_coef[5];
663 offset = (1 << RK_SHARP_V33_RFCOEFF_FIX_BITS) - sum_coeff;
664 tmp = (int)(pFix->sharp_gaus_coef[0] + offset);
665 pFix->sharp_gaus_coef[0] = CLIP(tmp, 0, 127);
666
667 // gain
668 tmp = pSelect->global_gain * (1 << RK_SHARP_V33_GLOBAL_GAIN_FIX_BITS);
669 pFix->sharp_global_gain = CLIP(tmp, 0, 1023);
670 tmp = pSelect->global_gain_alpha *
671 (1 << RK_SHARP_V33_GLOBAL_GAIN_ALPHA_FIX_BITS);
672 pFix->sharp_global_gain_alpha = CLIP(tmp, 0, 8);
673 tmp = pSelect->local_gainscale *
674 (1 << RK_SHARP_V33_LOCAL_GAIN_SACLE_FIX_BITS);
675 pFix->sharp_local_gainscale = CLIP(tmp, 0, 128);
676
677 // gain adjust strength
678 for (int i = 0; i < RK_SHARP_V33_SHARP_ADJ_GAIN_TABLE_LEN; i++) {
679 tmp = ROUND_F(pSelect->gain_adj_sharp_strength[i] *
680 (1 << RK_SHARP_V33_ADJ_GAIN_FIX_BITS));
681 pFix->sharp_gain_adj[i] = CLIP(tmp, 0, 16384);
682 }
683
684 // gain dis strength
685 for (int i = 0; i < RK_SHARP_V33_STRENGTH_TABLE_LEN; i++) {
686 tmp = ROUND_F(pSelect->dis_adj_sharp_strength[i] *
687 (1 << RK_SHARP_V33_STRENGTH_TABLE_FIX_BITS));
688 pFix->sharp_strength[i] = CLIP(tmp, 0, 128);
689 }
690
691 // isp32 only: use sw_sharp_strength21 bit [7:6] to clip over shoot.
692 // 2'b00: No clip
693 // 2'b10: Use 512 to clip
694 // 2'b01: Use 256 to clip
695 // 2'b11: Reserved
696 #if RKAIQ_HAVE_SHARP_V33
697 if (pSelect->global_hf_clip_pos == 1) {
698 pFix->sharp_strength[RK_SHARP_V33_STRENGTH_TABLE_LEN - 1] = 0x40;
699 } else if (pSelect->global_hf_clip_pos == 2) {
700 pFix->sharp_strength[RK_SHARP_V33_STRENGTH_TABLE_LEN - 1] = 0x80;
701 } else {
702 pFix->sharp_strength[RK_SHARP_V33_STRENGTH_TABLE_LEN - 1] = 0;
703 }
704 #endif
705
706 // texture: sharp enhence strength
707 #if RKAIQ_HAVE_SHARP_V33
708 tmp = ROUND_F(pSelect->noiseclip_strength *
709 (1 << RK_SHARP_V33_ADJ_GAIN_FIX_BITS));
710 pFix->sharp_noise_strength = CLIP(tmp, 0, 16383);
711 tmp = ROUND_F(pSelect->enhance_bit);
712 pFix->sharp_enhance_bit = CLIP(tmp, 0, 9);
713 tmp = ROUND_F(pSelect->noise_sigma_clip);
714 pFix->sharp_noise_sigma = CLIP(tmp, 0, 1023);
715 #else
716 pFix->sharp_noise_strength = 0;
717 pFix->sharp_enhance_bit = 0;
718 pFix->sharp_noise_sigma = 0;
719 #endif
720
721 #if RKAIQ_HAVE_SHARP_V33_LITE
722 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
723 tmp = ROUND_F(pSelect->local_sharp_strength[i]);
724 pFix->sharp_ehf_th[i] = CLIP(tmp, 0, 1023);
725 }
726 #else
727 for (int i = 0; i < RK_SHARP_V33_LUMA_POINT_NUM; i++) {
728 pFix->sharp_ehf_th[i] = 0;
729 }
730 #endif
731
732 #if 1
733 sharp_fix_printf_V33(pFix);
734 #endif
735
736 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
737 return res;
738 }
739
sharp_fix_printf_V33(RK_SHARP_Fix_V33_t * pFix)740 Asharp_result_V33_t sharp_fix_printf_V33(RK_SHARP_Fix_V33_t* pFix) {
741 int i = 0;
742 Asharp_result_V33_t res = ASHARP_V33_RET_SUCCESS;
743
744 LOGD_ASHARP("%s:(%d) enter \n", __FUNCTION__, __LINE__);
745
746 if (pFix == NULL) {
747 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
748 return ASHARP_V33_RET_NULL_POINTER;
749 }
750
751 // SHARP_SHARP_EN (0X0000)
752 LOGD_ASHARP("(0x0000) sahrp_Center_Mode:0x%x sharp_bypass:0x%x sharp_en:0x%x \n",
753 pFix->sharp_center_mode, pFix->sharp_bypass, pFix->sharp_en);
754
755 #if RKAIQ_HAVE_SHARP_V33_LITE
756 // SHARP_SHARP_EN (0X0000)
757 LOGD_ASHARP("(0x0000) sharp_clip_hf_mode:0x%x sharp_add_mode:0x%x \n",
758 pFix->sharp_clip_hf_mode, pFix->sharp_add_mode);
759 #endif
760
761 // SHARP_SHARP_RATIO (0x0004)
762 LOGD_ASHARP(
763 "(0x0004) sharp_sharp_ratio:0x%x sharp_bf_ratio:0x%x sharp_gaus_ratio:0x%x "
764 "sharp_pbf_ratio:0x%x \n",
765 pFix->sharp_sharp_ratio, pFix->sharp_bf_ratio, pFix->sharp_gaus_ratio,
766 pFix->sharp_pbf_ratio);
767
768 // SHARP_SHARP_LUMA_DX (0x0008)
769 for (int i = 0; i < 7; i++) {
770 LOGD_ASHARP("(0x0008) sharp_luma_dx[%d]:0x%x \n", i, pFix->sharp_luma_dx[i]);
771 }
772
773 // SHARP_SHARP_PBF_SIGMA_INV_0 (0x000c - 0x0014)
774 for (int i = 0; i < 8; i++) {
775 LOGD_ASHARP("(0x000c - 0x0014) sharp_pbf_sigma_inv[%d]:0x%x \n", i,
776 pFix->sharp_pbf_sigma_inv[i]);
777 }
778
779 // SHARP_SHARP_BF_SIGMA_INV_0 (0x0018 - 0x0020)
780 for (int i = 0; i < 8; i++) {
781 LOGD_ASHARP("(0x0018 - 0x0020) sharp_bf_sigma_inv[%d]:0x%x \n", i,
782 pFix->sharp_bf_sigma_inv[i]);
783 }
784
785 // SHARP_SHARP_SIGMA_SHIFT (0x00024)
786 LOGD_ASHARP("(0x00024) sharp_bf_sigma_shift:0x%x sharp_pbf_sigma_shift:0x%x \n",
787 pFix->sharp_bf_sigma_shift, pFix->sharp_pbf_sigma_shift);
788
789 // SHARP_SHARP_CLIP_HF_0 (0x0034 - 0x003c)
790 for (int i = 0; i < 8; i++) {
791 LOGD_ASHARP("(0x0034 - 0x003c) sharp_clip_hf[%d]:0x%x \n", i, pFix->sharp_clip_hf[i]);
792 }
793
794 // SHARP_SHARP_PBF_COEF (0x00040)
795 for (int i = 0; i < 3; i++) {
796 LOGD_ASHARP("(0x00040) sharp_pbf_coef[%d]:0x%x \n", i, pFix->sharp_pbf_coef[i]);
797 }
798
799 // SHARP_SHARP_BF_COEF (0x00044)
800 for (int i = 0; i < 3; i++) {
801 LOGD_ASHARP("(0x00044) sharp_bf_coef[%d]:0x%x \n", i, pFix->sharp_bf_coef[i]);
802 }
803
804 // SHARP_SHARP_GAUS_COEF (0x00048)
805 for (int i = 0; i < 6; i++) {
806 LOGD_ASHARP("(0x00048) sharp_gaus_coef[%d]:0x%x \n", i, pFix->sharp_gaus_coef[i]);
807 }
808
809 // SHARP_GAIN (0x0050)
810 LOGD_ASHARP(
811 "(0x0050) sharp_global_gain:0x%x sharp_global_gain_alpha:0x%x sharp_local_gaincale:0x%x \n",
812 pFix->sharp_global_gain, pFix->sharp_global_gain_alpha, pFix->sharp_local_gainscale);
813
814 // SHARP_GAIN_ADJUST (0x54)
815 for (int i = 0; i < 14; i++) {
816 LOGD_ASHARP("(0x00048) sharp_gain_adj[%d]:0x%x \n", i, pFix->sharp_gain_adj[i]);
817 }
818
819 // SHARP_CENTER (0x70)
820 LOGD_ASHARP("(0x0070) sharp_center_wid:0x%x shrap_center_het:%x \n", pFix->sharp_center_wid,
821 pFix->sharp_center_het);
822
823 // SHARP_GAIN_DIS_STRENGTH (0x74)
824 for (int i = 0; i < 22; i++) {
825 LOGD_ASHARP("(0x00048) sharp_strength[%d]:0x%x \n", i, pFix->sharp_strength[i]);
826 }
827
828 #if RKAIQ_HAVE_SHARP_V33
829 // SHARP_TEXTURE (0x8c)
830 LOGD_ASHARP("(0x0070) sharp_noise_sigma:0x%x sharp_enhance_bit:%x sharp_noise_strength:%x \n",
831 pFix->sharp_noise_sigma, pFix->sharp_enhance_bit, pFix->sharp_noise_strength);
832 #endif
833
834 #if RKAIQ_HAVE_SHARP_V33_LITE
835 // SHARP_TEXTURE (0x28)
836 for (int i = 0; i < 8; i++) {
837 LOGD_ASHARP("(0x00048) sharp_ehf_th[%d]:0x%x \n", i, pFix->sharp_ehf_th[i]);
838 }
839
840 // SHARP_TEXTURE (0x90)
841 for (int i = 0; i < 8; i++) {
842 LOGD_ASHARP("(0x00048) sharp_clip_neg[%d]:0x%x \n", i, pFix->sharp_clip_neg[i]);
843 }
844 #endif
845
846 return res;
847 }
848
sharp_get_setting_by_name_json_V33(void * pCalibdbV2_v,char * name,int * tuning_idx)849 Asharp_result_V33_t sharp_get_setting_by_name_json_V33(void* pCalibdbV2_v, char* name,
850 int* tuning_idx) {
851 int i = 0;
852 Asharp_result_V33_t res = ASHARP_V33_RET_SUCCESS;
853
854 LOGI_ASHARP("%s(%d): enter \n", __FUNCTION__, __LINE__);
855
856 #if RKAIQ_HAVE_SHARP_V33
857 CalibDbV2_SharpV33_t* pCalibdbV2 = (CalibDbV2_SharpV33_t*)pCalibdbV2_v;
858 #else
859 CalibDbV2_SharpV33Lite_t* pCalibdbV2 = (CalibDbV2_SharpV33Lite_t*)pCalibdbV2_v;
860 #endif
861
862 if(pCalibdbV2 == NULL || name == NULL || tuning_idx == NULL) {
863 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
864 return ASHARP_V33_RET_NULL_POINTER;
865 }
866
867 for(i = 0; i < pCalibdbV2->TuningPara.Setting_len; i++) {
868 if(strncmp(name, pCalibdbV2->TuningPara.Setting[i].SNR_Mode, strlen(name)*sizeof(char)) == 0) {
869 break;
870 }
871 }
872
873 if(i < pCalibdbV2->TuningPara.Setting_len) {
874 *tuning_idx = i;
875 } else {
876 *tuning_idx = 0;
877 }
878
879 LOGI_ASHARP("%s:%d snr_name:%s snr_idx:%d i:%d \n",
880 __FUNCTION__, __LINE__,
881 name, *tuning_idx, i);
882 return res;
883 }
884
sharp_init_params_json_V33(void * pSharpParams_v,void * pCalibdbV2_v,int tuning_idx)885 Asharp_result_V33_t sharp_init_params_json_V33(void* pSharpParams_v, void* pCalibdbV2_v,
886 int tuning_idx) {
887 Asharp_result_V33_t res = ASHARP_V33_RET_SUCCESS;
888 int i = 0;
889 int j = 0;
890 short isoCurveSectValue;
891 short isoCurveSectValue1;
892 float ave1, ave2, ave3, ave4;
893 int bit_calib = 12;
894 int bit_proc;
895 int bit_shift;
896 #if RKAIQ_HAVE_SHARP_V33
897 CalibDbV2_SharpV33_t* pCalibdbV2 = (CalibDbV2_SharpV33_t*)pCalibdbV2_v;
898 RK_SHARP_Params_V33_t* pSharpParams = (RK_SHARP_Params_V33_t*)pSharpParams_v;
899 CalibDbV2_SharpV33_T_ISO_t* pTuningISO;
900 #else
901 CalibDbV2_SharpV33Lite_t* pCalibdbV2 = (CalibDbV2_SharpV33Lite_t*)pCalibdbV2_v;
902 RK_SHARP_Params_V33LT_t* pSharpParams = (RK_SHARP_Params_V33LT_t*)pSharpParams_v;
903 CalibDbV2_SharpV33LT_T_ISO_t* pTuningISO;
904 #endif
905
906 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
907
908 if (pSharpParams == NULL || pCalibdbV2 == NULL) {
909 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
910 return ASHARP_V33_RET_NULL_POINTER;
911 }
912
913 pSharpParams->enable = pCalibdbV2->TuningPara.enable;
914 pSharpParams->kernel_sigma_enable = pCalibdbV2->TuningPara.kernel_sigma_enable;
915 pSharpParams->sharp_ratio_seperate_en = pCalibdbV2->TuningPara.sharp_ratio_seperate_en;
916 pSharpParams->Center_Mode = pCalibdbV2->TuningPara.Center_Mode;
917 for (i = 0; i < pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO_len &&
918 i < RK_SHARP_V33_MAX_ISO_NUM;
919 i++) {
920 pTuningISO = &pCalibdbV2->TuningPara.Setting[tuning_idx].Tuning_ISO[i];
921 pSharpParams->iso[i] = pTuningISO->iso;
922 #if RKAIQ_HAVE_SHARP_V33_LITE
923 pSharpParams->sharpParamsISO[i].clip_hf_mode = pTuningISO->clip_hf_mode;
924 pSharpParams->sharpParamsISO[i].add_mode = pTuningISO->add_mode;
925 #endif
926
927 for (j = 0; j < RK_SHARP_V33_LUMA_POINT_NUM; j++) {
928 pSharpParams->sharpParamsISO[i].luma_point[j] = pTuningISO->luma_para.luma_point[j];
929 pSharpParams->sharpParamsISO[i].luma_sigma[j] = pTuningISO->luma_para.luma_sigma[j];
930 pSharpParams->sharpParamsISO[i].hf_clip[j] = pTuningISO->luma_para.hf_clip[j];
931 #if RKAIQ_HAVE_SHARP_V33_LITE
932 pSharpParams->sharpParamsISO[i].hf_clip_neg[j] = pTuningISO->luma_para.hf_clip_neg[j];
933 pSharpParams->sharpParamsISO[i].local_sharp_strength[j] =
934 pTuningISO->luma_para.local_sharp_strength[j];
935 #endif
936 }
937
938 pSharpParams->sharpParamsISO[i].pbf_gain = pTuningISO->pbf_gain;
939 pSharpParams->sharpParamsISO[i].pbf_add = pTuningISO->pbf_add;
940 pSharpParams->sharpParamsISO[i].pbf_ratio = pTuningISO->pbf_ratio;
941 pSharpParams->sharpParamsISO[i].gaus_ratio = pTuningISO->gaus_ratio;
942 pSharpParams->sharpParamsISO[i].sharp_ratio_0 = pTuningISO->sharp_ratio_0;
943 pSharpParams->sharpParamsISO[i].sharp_ratio_1 = pTuningISO->sharp_ratio_1;
944 pSharpParams->sharpParamsISO[i].sharp_ratio = pTuningISO->sharp_ratio;
945
946 pSharpParams->sharpParamsISO[i].bf_gain = pTuningISO->bf_gain;
947 pSharpParams->sharpParamsISO[i].bf_add = pTuningISO->bf_add;
948 pSharpParams->sharpParamsISO[i].bf_ratio = pTuningISO->bf_ratio;
949 #if RKAIQ_HAVE_SHARP_V33
950 pSharpParams->sharpParamsISO[i].global_hf_clip_pos = pTuningISO->global_hf_clip_pos;
951 #endif
952
953 for (j = 0; j < 3; j++) {
954 pSharpParams->sharpParamsISO[i].prefilter_coeff[j] =
955 pTuningISO->kernel_para.prefilter_coeff[j];
956 pSharpParams->sharpParamsISO[i].hfBilateralFilter_coeff[j] =
957 pTuningISO->kernel_para.hfBilateralFilter_coeff[j];
958 LOGD_ASHARP("kernel_pbf: index[%d][%d] = %f\n", i, j,
959 pSharpParams->sharpParamsISO[i].prefilter_coeff[j]);
960 LOGD_ASHARP("kernel_bf: index[%d][%d] = %f\n", i, j,
961 pSharpParams->sharpParamsISO[i].hfBilateralFilter_coeff[j]);
962 }
963
964 for (j = 0; j < 6; j++) {
965 pSharpParams->sharpParamsISO[i].GaussianFilter_coeff_0[j] =
966 pTuningISO->kernel_para.GaussianFilter_coeff_0[j];
967 pSharpParams->sharpParamsISO[i].GaussianFilter_coeff_1[j] =
968 pTuningISO->kernel_para.GaussianFilter_coeff_1[j];
969 pSharpParams->sharpParamsISO[i].GaussianFilter_coeff[j] =
970 pTuningISO->kernel_para.GaussianFilter_coeff[j];
971 LOGD_ASHARP("kernel: index[%d][%d] = %f\n", i, j,
972 pSharpParams->sharpParamsISO[i].GaussianFilter_coeff[j]);
973
974 }
975
976 pSharpParams->sharpParamsISO[i].global_gain = pTuningISO->global_gain;
977 pSharpParams->sharpParamsISO[i].global_gain_alpha = pTuningISO->global_gain_alpha;
978 pSharpParams->sharpParamsISO[i].local_gainscale = pTuningISO->local_gainscale;
979
980 for (int j = 0; j < 14; j++) {
981 pSharpParams->sharpParamsISO[i].gain_adj_sharp_strength[j] =
982 pTuningISO->gain_adj_sharp_strength[j];
983 }
984
985 pSharpParams->sharpParamsISO[i].exgain_bypass = pTuningISO->exgain_bypass;
986
987 for (int j = 0; j < 22; j++) {
988 pSharpParams->sharpParamsISO[i].dis_adj_sharp_strength[j] =
989 pTuningISO->dis_adj_sharp_strength[j];
990 }
991
992 #if RKAIQ_HAVE_SHARP_V33
993 pSharpParams->sharpParamsISO[i].noiseclip_strength = pTuningISO->noiseclip_strength;
994 pSharpParams->sharpParamsISO[i].enhance_bit = pTuningISO->enhance_bit;
995 pSharpParams->sharpParamsISO[i].noiseclip_mode = pTuningISO->noiseclip_mode;
996 pSharpParams->sharpParamsISO[i].noise_sigma_clip = pTuningISO->noise_sigma_clip;
997 #endif
998
999 pSharpParams->sharpParamsISO[i].prefilter_sigma = pTuningISO->kernel_sigma.prefilter_sigma;
1000 pSharpParams->sharpParamsISO[i].hfBilateralFilter_sigma = pTuningISO->kernel_sigma.hfBilateralFilter_sigma;
1001
1002 pSharpParams->sharpParamsISO[i].GaussianFilter_sigma_0 = pTuningISO->kernel_sigma.GaussianFilter_sigma_0;
1003 pSharpParams->sharpParamsISO[i].GaussianFilter_radius_0 = pTuningISO->kernel_sigma.GaussianFilter_radius_0;
1004 pSharpParams->sharpParamsISO[i].GaussianFilter_sigma_1 = pTuningISO->kernel_sigma.GaussianFilter_sigma_1;
1005 pSharpParams->sharpParamsISO[i].GaussianFilter_radius_1 = pTuningISO->kernel_sigma.GaussianFilter_radius_1;
1006 pSharpParams->sharpParamsISO[i].GaussianFilter_sigma = pTuningISO->kernel_sigma.GaussianFilter_sigma;
1007 pSharpParams->sharpParamsISO[i].GaussianFilter_radius = pTuningISO->kernel_sigma.GaussianFilter_radius;
1008
1009 }
1010
1011 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
1012 return res;
1013 }
1014
sharp_config_setting_param_json_V33(void * pParams_v,void * pCalibdbV2_v,char * param_mode,char * snr_name)1015 Asharp_result_V33_t sharp_config_setting_param_json_V33(void* pParams_v, void* pCalibdbV2_v,
1016 char* param_mode, char* snr_name) {
1017 Asharp_result_V33_t res = ASHARP_V33_RET_SUCCESS;
1018 int tuning_idx = 0;
1019 #if RKAIQ_HAVE_SHARP_V33
1020 CalibDbV2_SharpV33_t* pCalibdbV2 = (CalibDbV2_SharpV33_t*)pCalibdbV2_v;
1021 RK_SHARP_Params_V33_t* pParams = (RK_SHARP_Params_V33_t*)pParams_v;
1022 #else
1023 CalibDbV2_SharpV33Lite_t* pCalibdbV2 = (CalibDbV2_SharpV33Lite_t*)pCalibdbV2_v;
1024 RK_SHARP_Params_V33LT_t* pParams = (RK_SHARP_Params_V33LT_t*)pParams_v;
1025 #endif
1026
1027 LOGI_ASHARP("%s(%d): enter\n", __FUNCTION__, __LINE__);
1028
1029 if (pParams == NULL || pCalibdbV2 == NULL || param_mode == NULL || snr_name == NULL) {
1030 LOGE_ASHARP("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
1031 pParams->enable = false;
1032 return ASHARP_V33_RET_NULL_POINTER;
1033 }
1034
1035 res = sharp_get_setting_by_name_json_V33(pCalibdbV2, snr_name, &tuning_idx);
1036 if(res != ASHARP_V33_RET_SUCCESS) {
1037 LOGW_ASHARP("%s(%d): error!!! can't find setting in iq files, use 0 instead\n", __FUNCTION__, __LINE__);
1038 }
1039
1040 res = sharp_init_params_json_V33(pParams, pCalibdbV2, tuning_idx);
1041 pParams->enable = pCalibdbV2->TuningPara.enable;
1042
1043 LOGI_ASHARP("%s(%d): exit\n", __FUNCTION__, __LINE__);
1044
1045 return res;
1046 }
1047
1048 RKAIQ_END_DECLARE
1049