1 #include "rk_aiq_uapi_anr_int.h"
2 #include "anr/rk_aiq_types_anr_algo_prvt.h"
3 #include "anr/rk_aiq_anr_algo.h"
4 #include "bayernr_xml2json_v1.h"
5 #include "mfnr_xml2json_v1.h"
6 #include "uvnr_xml2json_v1.h"
7 #include "ynr_xml2json_v1.h"
8
9
10
11 #define NR_STRENGTH_MAX_PERCENT (50.0)
12 #define NR_LUMA_TF_STRENGTH_MAX_PERCENT NR_STRENGTH_MAX_PERCENT
13 #define NR_LUMA_SF_STRENGTH_MAX_PERCENT (100.0)
14 #define NR_CHROMA_TF_STRENGTH_MAX_PERCENT NR_STRENGTH_MAX_PERCENT
15 #define NR_CHROMA_SF_STRENGTH_MAX_PERCENT NR_STRENGTH_MAX_PERCENT
16 #define NR_RAWNR_SF_STRENGTH_MAX_PERCENT (80.0)
17
18 XCamReturn
rk_aiq_uapi_anr_SetAttrib(RkAiqAlgoContext * ctx,rk_aiq_nr_attrib_t * attr,bool need_sync)19 rk_aiq_uapi_anr_SetAttrib(RkAiqAlgoContext *ctx,
20 rk_aiq_nr_attrib_t *attr,
21 bool need_sync)
22 {
23
24 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
25
26 pAnrCtx->eMode = attr->eMode;
27 pAnrCtx->stAuto = attr->stAuto;
28 pAnrCtx->stManual = attr->stManual;
29
30 return XCAM_RETURN_NO_ERROR;
31 }
32
33 XCamReturn
rk_aiq_uapi_anr_GetAttrib(const RkAiqAlgoContext * ctx,rk_aiq_nr_attrib_t * attr)34 rk_aiq_uapi_anr_GetAttrib(const RkAiqAlgoContext *ctx,
35 rk_aiq_nr_attrib_t *attr)
36 {
37
38 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
39
40 attr->eMode = pAnrCtx->eMode;
41 memcpy(&attr->stAuto, &pAnrCtx->stAuto, sizeof(ANR_Auto_Attr_t));
42 memcpy(&attr->stManual, &pAnrCtx->stManual, sizeof(ANR_Manual_Attr_t));
43
44 return XCAM_RETURN_NO_ERROR;
45 }
46
47 XCamReturn
rk_aiq_uapi_anr_SetIQPara(RkAiqAlgoContext * ctx,rk_aiq_nr_IQPara_t * pPara,bool need_sync)48 rk_aiq_uapi_anr_SetIQPara(RkAiqAlgoContext *ctx,
49 rk_aiq_nr_IQPara_t *pPara,
50 bool need_sync)
51 {
52 #ifdef RKAIQ_ENABLE_PARSER_V1
53
54 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
55
56 if(pPara->module_bits & (1 << ANR_MODULE_BAYERNR)) {
57 //pAnrCtx->stBayernrCalib = pPara->stBayernrPara;
58 CalibDb_BayerNr_2_t stBayernr;
59 stBayernr.mode_num = sizeof(pPara->stBayernrPara.mode_cell) / sizeof(CalibDb_BayerNr_ModeCell_t);
60 stBayernr.mode_cell = (CalibDb_BayerNr_ModeCell_t *)malloc(stBayernr.mode_num * sizeof(CalibDb_BayerNr_ModeCell_t));
61 stBayernr.enable = pPara->stBayernrPara.enable;
62 strcpy(stBayernr.version, pPara->stBayernrPara.version);
63 for(int i = 0; i < stBayernr.mode_num; i++) {
64 stBayernr.mode_cell[i] = pPara->stBayernrPara.mode_cell[i];
65 }
66
67 #if(ANR_USE_JSON_PARA)
68 bayernrV1_calibdb_to_calibdbV2(&stBayernr, &pAnrCtx->bayernr_v1, 0);
69 #else
70 pAnrCtx->stBayernrCalib.enable = stBayernr.enable;
71 strcpy(pAnrCtx->stBayernrCalib.version, stBayernr.version);
72 for(int i = 0; i < stBayernr.mode_num && i < pAnrCtx->stBayernrCalib.mode_num; i++) {
73 pAnrCtx->stBayernrCalib.mode_cell[i] = stBayernr.mode_cell[i];
74 }
75 pAnrCtx->isIQParaUpdate = true;
76 #endif
77
78 free(stBayernr.mode_cell);
79 }
80
81 if(pPara->module_bits & (1 << ANR_MODULE_MFNR)) {
82 //pAnrCtx->stMfnrCalib = pPara->stMfnrPara;
83 CalibDb_MFNR_2_t stMfnr;
84 stMfnr.mode_num = sizeof(pPara->stMfnrPara.mode_cell) / sizeof(CalibDb_MFNR_ModeCell_t);
85 stMfnr.mode_cell = (CalibDb_MFNR_ModeCell_t *)malloc(stMfnr.mode_num * sizeof(CalibDb_MFNR_ModeCell_t));
86
87 stMfnr.enable = pPara->stMfnrPara.enable;
88 strcpy(stMfnr.version, pPara->stMfnrPara.version);
89 stMfnr.local_gain_en = pPara->stMfnrPara.local_gain_en;
90 stMfnr.motion_detect_en = pPara->stMfnrPara.motion_detect_en;
91 stMfnr.mode_3to1 = pPara->stMfnrPara.mode_3to1;
92 stMfnr.max_level = pPara->stMfnrPara.max_level;
93 stMfnr.max_level_uv = pPara->stMfnrPara.max_level_uv;
94 stMfnr.back_ref_num = pPara->stMfnrPara.back_ref_num;
95 for(int i = 0; i < 4; i++) {
96 stMfnr.uv_ratio[i] = pPara->stMfnrPara.uv_ratio[i];
97 }
98 for(int i = 0; i < stMfnr.mode_num; i++) {
99 stMfnr.mode_cell[i] = pPara->stMfnrPara.mode_cell[i];
100 }
101
102 #if(ANR_USE_JSON_PARA)
103 mfnrV1_calibdb_to_calibdbV2(&stMfnr, &pAnrCtx->mfnr_v1, 0);
104 #else
105 pAnrCtx->stMfnrCalib.enable = stMfnr.enable;
106 strcpy(pAnrCtx->stMfnrCalib.version, stMfnr.version);
107 pAnrCtx->stMfnrCalib.local_gain_en = stMfnr.local_gain_en;
108 pAnrCtx->stMfnrCalib.motion_detect_en = stMfnr.motion_detect_en;
109 pAnrCtx->stMfnrCalib.mode_3to1 = stMfnr.mode_3to1;
110 pAnrCtx->stMfnrCalib.max_level = stMfnr.max_level;
111 pAnrCtx->stMfnrCalib.max_level_uv = stMfnr.max_level_uv;
112 pAnrCtx->stMfnrCalib.back_ref_num = stMfnr.back_ref_num;
113 for(int i = 0; i < 4; i++) {
114 pAnrCtx->stMfnrCalib.uv_ratio[i] = stMfnr.uv_ratio[i];
115 }
116 for(int i = 0; i < stMfnr.mode_num && i < pAnrCtx->stMfnrCalib.mode_num; i++) {
117 pAnrCtx->stMfnrCalib.mode_cell[i] = stMfnr.mode_cell[i];
118 }
119 #endif
120 pAnrCtx->isIQParaUpdate = true;
121
122 free(stMfnr.mode_cell);
123 }
124
125 if(pPara->module_bits & (1 << ANR_MODULE_UVNR)) {
126 //pAnrCtx->stUvnrCalib = pPara->stUvnrPara;
127 CalibDb_UVNR_2_t stUvnr;
128 stUvnr.mode_num = sizeof(pPara->stUvnrPara.mode_cell) / sizeof(CalibDb_UVNR_ModeCell_t);
129 stUvnr.mode_cell = (CalibDb_UVNR_ModeCell_t *)malloc(stUvnr.mode_num * sizeof(CalibDb_UVNR_ModeCell_t));
130 stUvnr.enable = pPara->stUvnrPara.enable;
131 strcpy(stUvnr.version, pPara->stUvnrPara.version);
132 for(int i = 0; i < stUvnr.mode_num; i++) {
133 stUvnr.mode_cell[i] = pPara->stUvnrPara.mode_cell[i];
134 }
135
136 #if(ANR_USE_JSON_PARA)
137 uvnrV1_calibdb_to_calibdbV2(&stUvnr, &pAnrCtx->uvnr_v1, 0);
138 #else
139 pAnrCtx->stUvnrCalib.enable = stUvnr.enable;
140 strcpy(pAnrCtx->stUvnrCalib.version, stUvnr.version);
141 for(int i = 0; i < stUvnr.mode_num && i < pAnrCtx->stUvnrCalib.mode_num; i++) {
142 pAnrCtx->stUvnrCalib.mode_cell[i] = stUvnr.mode_cell[i];
143 }
144 #endif
145 pAnrCtx->isIQParaUpdate = true;
146
147 free(stUvnr.mode_cell);
148 }
149
150 if(pPara->module_bits & (1 << ANR_MODULE_YNR)) {
151 //pAnrCtx->stYnrCalib = pPara->stYnrPara;
152 CalibDb_YNR_2_t stYnr;
153 stYnr.mode_num = sizeof(pPara->stYnrPara.mode_cell) / sizeof(CalibDb_YNR_ModeCell_t);
154 stYnr.mode_cell = (CalibDb_YNR_ModeCell_t *)malloc(stYnr.mode_num * sizeof(CalibDb_YNR_ModeCell_t));
155 stYnr.enable = pPara->stYnrPara.enable;
156 strcpy(stYnr.version, pPara->stYnrPara.version);
157 for(int i = 0; i < stYnr.mode_num; i++) {
158 stYnr.mode_cell[i] = pPara->stYnrPara.mode_cell[i];
159 }
160
161
162 #if(ANR_USE_JSON_PARA)
163 ynrV1_calibdb_to_calibdbV2(&stYnr, &pAnrCtx->ynr_v1, 0);
164 #else
165 pAnrCtx->stYnrCalib.enable = stYnr.enable;
166 strcpy(pAnrCtx->stYnrCalib.version, stYnr.version);
167 for(int i = 0; i < stYnr.mode_num && i < pAnrCtx->stYnrCalib.mode_num; i++) {
168 pAnrCtx->stYnrCalib.mode_cell[i] = stYnr.mode_cell[i];
169 }
170 #endif
171 pAnrCtx->isIQParaUpdate = true;
172
173 free(stYnr.mode_cell);
174 }
175
176 return XCAM_RETURN_NO_ERROR;
177 #else
178 return XCAM_RETURN_ERROR_PARAM;
179 #endif
180 }
181
182
183 XCamReturn
rk_aiq_uapi_anr_GetIQPara(RkAiqAlgoContext * ctx,rk_aiq_nr_IQPara_t * pPara)184 rk_aiq_uapi_anr_GetIQPara(RkAiqAlgoContext *ctx,
185 rk_aiq_nr_IQPara_t *pPara)
186 {
187 #ifdef RKAIQ_ENABLE_PARSER_V1
188
189 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
190
191 //pPara->stBayernrPara = pAnrCtx->stBayernrCalib;
192 CalibDb_BayerNr_2_t stBayernr;
193 stBayernr.mode_num = sizeof(pPara->stBayernrPara.mode_cell) / sizeof(CalibDb_BayerNr_ModeCell_t);
194 stBayernr.mode_cell = (CalibDb_BayerNr_ModeCell_t *)malloc(stBayernr.mode_num * sizeof(CalibDb_BayerNr_ModeCell_t));
195
196 #if(ANR_USE_JSON_PARA)
197 bayernrV1_calibdbV2_to_calibdb(&pAnrCtx->bayernr_v1, &stBayernr, 0);
198 #else
199 stBayernr.enable = pAnrCtx->stBayernrCalib.enable;
200 strcpy(stBayernr.version, pAnrCtx->stBayernrCalib.version);
201 for(int i = 0; i < pAnrCtx->stBayernrCalib.mode_num && i < stBayernr.mode_num; i++) {
202 stBayernr.mode_cell[i] = pAnrCtx->stBayernrCalib.mode_cell[i];
203 }
204 #endif
205
206 memset(&pPara->stBayernrPara, 0x00, sizeof(CalibDb_BayerNr_t));
207 pPara->stBayernrPara.enable = stBayernr.enable;
208 strcpy(pPara->stBayernrPara.version, stBayernr.version);
209 for(int i = 0; i < stBayernr.mode_num; i++) {
210 pPara->stBayernrPara.mode_cell[i] = stBayernr.mode_cell[i];
211 }
212 free(stBayernr.mode_cell);
213
214
215 //pPara->stMfnrPara = pAnrCtx->stMfnrCalib;
216 CalibDb_MFNR_2_t stMfnr;
217 stMfnr.mode_num = sizeof(pPara->stMfnrPara.mode_cell) / sizeof(CalibDb_MFNR_ModeCell_t);
218 stMfnr.mode_cell = (CalibDb_MFNR_ModeCell_t *)malloc(stMfnr.mode_num * sizeof(CalibDb_MFNR_ModeCell_t));
219 #if(ANR_USE_JSON_PARA)
220 mfnrV1_calibdbV2_to_calibdb(&pAnrCtx->mfnr_v1, &stMfnr, 0);
221 #else
222 stMfnr.enable = pAnrCtx->stMfnrCalib.enable;
223 strcpy(stMfnr.version, pAnrCtx->stMfnrCalib.version);
224 stMfnr.local_gain_en = pAnrCtx->stMfnrCalib.local_gain_en;
225 stMfnr.motion_detect_en = pAnrCtx->stMfnrCalib.motion_detect_en;
226 stMfnr.mode_3to1 = pAnrCtx->stMfnrCalib.mode_3to1;
227 stMfnr.max_level = pAnrCtx->stMfnrCalib.max_level;
228 stMfnr.max_level_uv = pAnrCtx->stMfnrCalib.max_level_uv;
229 stMfnr.back_ref_num = pAnrCtx->stMfnrCalib.back_ref_num;
230 for(int i = 0; i < 4; i++) {
231 stMfnr.uv_ratio[i] = pAnrCtx->stMfnrCalib.uv_ratio[i];
232 }
233 for(int i = 0; i < stMfnr.mode_num && i < pAnrCtx->stMfnrCalib.mode_num; i++) {
234 stMfnr.mode_cell[i] = pAnrCtx->stMfnrCalib.mode_cell[i];
235 }
236 #endif
237
238 memset(&pPara->stMfnrPara, 0x00, sizeof(CalibDb_MFNR_t));
239 pPara->stMfnrPara.enable = stMfnr.enable;
240 strcpy(pPara->stMfnrPara.version, stMfnr.version);
241 pPara->stMfnrPara.local_gain_en = stMfnr.local_gain_en;
242 pPara->stMfnrPara.motion_detect_en = stMfnr.motion_detect_en;
243 pPara->stMfnrPara.mode_3to1 = stMfnr.mode_3to1;
244 pPara->stMfnrPara.max_level = stMfnr.max_level;
245 pPara->stMfnrPara.max_level_uv = stMfnr.max_level_uv;
246 pPara->stMfnrPara.back_ref_num = stMfnr.back_ref_num;
247 for(int i = 0; i < 4; i++) {
248 pPara->stMfnrPara.uv_ratio[i] = stMfnr.uv_ratio[i];
249 }
250 for(int i = 0; i < stMfnr.mode_num; i++) {
251 pPara->stMfnrPara.mode_cell[i] = stMfnr.mode_cell[i];
252 }
253 free(stMfnr.mode_cell);
254
255
256 //pPara->stUvnrPara = pAnrCtx->stUvnrCalib;
257 CalibDb_UVNR_2_t stUvnr;
258 stUvnr.mode_num = sizeof(pPara->stUvnrPara.mode_cell) / sizeof(CalibDb_UVNR_ModeCell_t);
259 stUvnr.mode_cell = (CalibDb_UVNR_ModeCell_t *)malloc(stUvnr.mode_num * sizeof(CalibDb_UVNR_ModeCell_t));
260 #if(ANR_USE_JSON_PARA)
261 uvnrV1_calibdbV2_to_calibdb(&pAnrCtx->uvnr_v1, &stUvnr, 0);
262 #else
263 stUvnr.enable = pAnrCtx->stUvnrCalib.enable;
264 strcpy(stUvnr.version, pAnrCtx->stUvnrCalib.version);
265 for(int i = 0; i < stUvnr.mode_num && i < pAnrCtx->stUvnrCalib.mode_num; i++) {
266 stUvnr.mode_cell[i] = pAnrCtx->stUvnrCalib.mode_cell[i];
267 }
268 #endif
269 memset(&pPara->stUvnrPara, 0x00, sizeof(CalibDb_UVNR_t));
270 pPara->stUvnrPara.enable = stUvnr.enable;
271 memcpy(pPara->stUvnrPara.version, stUvnr.version, sizeof(pPara->stUvnrPara.version));
272 for(int i = 0; i < stUvnr.mode_num; i++) {
273 pPara->stUvnrPara.mode_cell[i] = stUvnr.mode_cell[i];
274 }
275 free(stUvnr.mode_cell);
276
277
278 //pPara->stYnrPara = pAnrCtx->stYnrCalib;
279 CalibDb_YNR_2_t stYnr;
280 stYnr.mode_num = sizeof(pPara->stYnrPara.mode_cell) / sizeof(CalibDb_YNR_ModeCell_t);
281 stYnr.mode_cell = (CalibDb_YNR_ModeCell_t *)malloc(stYnr.mode_num * sizeof(CalibDb_YNR_ModeCell_t));
282 #if(ANR_USE_JSON_PARA)
283 ynrV1_calibdbV2_to_calibdb(&pAnrCtx->ynr_v1, &stYnr, 0);
284 #else
285 stYnr.enable = pAnrCtx->stYnrCalib.enable;
286 strcpy(stYnr.version, pAnrCtx->stYnrCalib.version);
287 for(int i = 0; i < stYnr.mode_num && i < pAnrCtx->stYnrCalib.mode_num; i++) {
288 stYnr.mode_cell[i] = pAnrCtx->stYnrCalib.mode_cell[i];
289 }
290 #endif
291 memset(&pPara->stYnrPara, 0x00, sizeof(CalibDb_YNR_t));
292 pPara->stYnrPara.enable = stYnr.enable;
293 memcpy(pPara->stYnrPara.version, stYnr.version, sizeof(pPara->stYnrPara.version));
294 for(int i = 0; i < stYnr.mode_num; i++) {
295 pPara->stYnrPara.mode_cell[i] = stYnr.mode_cell[i];
296 }
297 free(stYnr.mode_cell);
298
299 return XCAM_RETURN_NO_ERROR;
300 #else
301 return XCAM_RETURN_ERROR_PARAM;
302 #endif
303 }
304
305
306 XCamReturn
rk_aiq_uapi_anr_SetLumaSFStrength(const RkAiqAlgoContext * ctx,float fPercent)307 rk_aiq_uapi_anr_SetLumaSFStrength(const RkAiqAlgoContext *ctx,
308 float fPercent)
309 {
310 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
311
312 float fStrength = 1.0f;
313 float fMax = NR_LUMA_SF_STRENGTH_MAX_PERCENT;
314
315
316 if(fPercent <= 0.5) {
317 fStrength = fPercent / 0.5;
318 } else {
319 fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
320 }
321
322 if(fStrength > 1) {
323 pAnrCtx->fRawnr_SF_Strength = fStrength;
324 pAnrCtx->fLuma_SF_Strength = 1;
325 } else {
326 pAnrCtx->fRawnr_SF_Strength = fStrength;
327 pAnrCtx->fLuma_SF_Strength = fStrength;
328 }
329
330 return XCAM_RETURN_NO_ERROR;
331 }
332
333
334 XCamReturn
rk_aiq_uapi_anr_SetLumaTFStrength(const RkAiqAlgoContext * ctx,float fPercent)335 rk_aiq_uapi_anr_SetLumaTFStrength(const RkAiqAlgoContext *ctx,
336 float fPercent)
337 {
338 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
339
340 float fStrength = 1.0;
341 float fMax = NR_LUMA_TF_STRENGTH_MAX_PERCENT;
342
343 if(fPercent <= 0.5) {
344 fStrength = fPercent / 0.5;
345 } else {
346 fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
347 }
348
349 pAnrCtx->fLuma_TF_Strength = fStrength;
350
351 return XCAM_RETURN_NO_ERROR;
352 }
353
354
355 XCamReturn
rk_aiq_uapi_anr_GetLumaSFStrength(const RkAiqAlgoContext * ctx,float * pPercent)356 rk_aiq_uapi_anr_GetLumaSFStrength(const RkAiqAlgoContext *ctx,
357 float *pPercent)
358 {
359 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
360
361 float fStrength = 1.0f;
362 float fMax = NR_LUMA_SF_STRENGTH_MAX_PERCENT;
363
364
365 fStrength = pAnrCtx->fRawnr_SF_Strength;
366
367 if(fStrength <= 1) {
368 *pPercent = fStrength * 0.5;
369 } else {
370 *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
371 }
372
373 return XCAM_RETURN_NO_ERROR;
374 }
375
376
377 XCamReturn
rk_aiq_uapi_anr_GetLumaTFStrength(const RkAiqAlgoContext * ctx,float * pPercent)378 rk_aiq_uapi_anr_GetLumaTFStrength(const RkAiqAlgoContext *ctx,
379 float *pPercent)
380 {
381 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
382
383 float fStrength = 1.0;
384 float fMax = NR_LUMA_TF_STRENGTH_MAX_PERCENT;
385
386 fStrength = pAnrCtx->fLuma_TF_Strength;
387
388 if(fStrength <= 1) {
389 *pPercent = fStrength * 0.5;
390 } else {
391 *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
392 }
393
394 return XCAM_RETURN_NO_ERROR;
395 }
396
397
398 XCamReturn
rk_aiq_uapi_anr_SetChromaSFStrength(const RkAiqAlgoContext * ctx,float fPercent)399 rk_aiq_uapi_anr_SetChromaSFStrength(const RkAiqAlgoContext *ctx,
400 float fPercent)
401 {
402 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
403
404 float fStrength = 1.0f;
405 float fMax = NR_CHROMA_SF_STRENGTH_MAX_PERCENT;
406
407 if(fPercent <= 0.5) {
408 fStrength = fPercent / 0.5;
409 } else {
410 fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
411 }
412
413 pAnrCtx->fChroma_SF_Strength = fStrength;
414
415 return XCAM_RETURN_NO_ERROR;
416 }
417
418
419 XCamReturn
rk_aiq_uapi_anr_SetChromaTFStrength(const RkAiqAlgoContext * ctx,float fPercent)420 rk_aiq_uapi_anr_SetChromaTFStrength(const RkAiqAlgoContext *ctx,
421 float fPercent)
422 {
423 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
424
425 float fStrength = 1.0;
426 float fMax = NR_CHROMA_TF_STRENGTH_MAX_PERCENT;
427
428 if(fPercent <= 0.5) {
429 fStrength = fPercent / 0.5;
430 } else {
431 fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
432 }
433
434 pAnrCtx->fChroma_TF_Strength = fStrength;
435
436 return XCAM_RETURN_NO_ERROR;
437 }
438
439
440 XCamReturn
rk_aiq_uapi_anr_GetChromaSFStrength(const RkAiqAlgoContext * ctx,float * pPercent)441 rk_aiq_uapi_anr_GetChromaSFStrength(const RkAiqAlgoContext *ctx,
442 float *pPercent)
443 {
444 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
445
446 float fStrength = 1.0f;
447 float fMax = NR_CHROMA_SF_STRENGTH_MAX_PERCENT;
448
449 fStrength = pAnrCtx->fChroma_SF_Strength;
450
451
452 if(fStrength <= 1) {
453 *pPercent = fStrength * 0.5;
454 } else {
455 *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
456 }
457
458
459 return XCAM_RETURN_NO_ERROR;
460 }
461
462
463 XCamReturn
rk_aiq_uapi_anr_GetChromaTFStrength(const RkAiqAlgoContext * ctx,float * pPercent)464 rk_aiq_uapi_anr_GetChromaTFStrength(const RkAiqAlgoContext *ctx,
465 float *pPercent)
466 {
467 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
468
469 float fStrength = 1.0;
470 float fMax = NR_CHROMA_TF_STRENGTH_MAX_PERCENT;
471
472 fStrength = pAnrCtx->fChroma_TF_Strength;
473
474 if(fStrength <= 1) {
475 *pPercent = fStrength * 0.5;
476 } else {
477 *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
478 }
479
480 return XCAM_RETURN_NO_ERROR;
481 }
482
483
484 XCamReturn
rk_aiq_uapi_anr_SetRawnrSFStrength(const RkAiqAlgoContext * ctx,float fPercent)485 rk_aiq_uapi_anr_SetRawnrSFStrength(const RkAiqAlgoContext *ctx,
486 float fPercent)
487 {
488 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
489
490 float fStrength = 1.0;
491 float fMax = NR_RAWNR_SF_STRENGTH_MAX_PERCENT;
492
493 if(fPercent <= 0.5) {
494 fStrength = fPercent / 0.5;
495 } else {
496 fStrength = (fPercent - 0.5) * (fMax - 1) * 2 + 1;
497 }
498
499 pAnrCtx->fRawnr_SF_Strength = fStrength;
500
501 return XCAM_RETURN_NO_ERROR;
502 }
503
504
505 XCamReturn
rk_aiq_uapi_anr_GetRawnrSFStrength(const RkAiqAlgoContext * ctx,float * pPercent)506 rk_aiq_uapi_anr_GetRawnrSFStrength(const RkAiqAlgoContext *ctx,
507 float *pPercent)
508 {
509 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
510
511 float fStrength = 1.0f;
512 float fMax = NR_RAWNR_SF_STRENGTH_MAX_PERCENT;
513
514 fStrength = pAnrCtx->fRawnr_SF_Strength;
515
516
517 if(fStrength <= 1) {
518 *pPercent = fStrength * 0.5;
519 } else {
520 *pPercent = (fStrength - 1) / ((fMax - 1) * 2) + 0.5;
521 }
522
523
524 return XCAM_RETURN_NO_ERROR;
525 }
526
527
528 XCamReturn
rk_aiq_uapi_anr_SetJsonPara(RkAiqAlgoContext * ctx,rk_aiq_nr_JsonPara_t * pPara,bool need_sync)529 rk_aiq_uapi_anr_SetJsonPara(RkAiqAlgoContext *ctx,
530 rk_aiq_nr_JsonPara_t *pPara,
531 bool need_sync)
532 {
533
534 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
535
536 if(pPara->module_bits & (1 << ANR_MODULE_BAYERNR)) {
537 //pAnrCtx->stBayernrCalib = pPara->stBayernrPara;
538 bayernr_calibdbV2_assign(&pAnrCtx->bayernr_v1, &pPara->bayernr_v1);
539 pAnrCtx->isIQParaUpdate = true;
540 }
541
542 if(pPara->module_bits & (1 << ANR_MODULE_MFNR)) {
543 //pAnrCtx->stMfnrCalib = pPara->stMfnrPara;
544 mfnr_calibdbV2_assign(&pAnrCtx->mfnr_v1, &pPara->mfnr_v1);
545 pAnrCtx->isIQParaUpdate = true;
546 }
547
548 if(pPara->module_bits & (1 << ANR_MODULE_UVNR)) {
549 //pAnrCtx->stUvnrCalib = pPara->stUvnrPara;
550 uvnr_calibdbV2_assign(&pAnrCtx->uvnr_v1, &pPara->uvnr_v1);
551 pAnrCtx->isIQParaUpdate = true;
552 }
553
554 if(pPara->module_bits & (1 << ANR_MODULE_YNR)) {
555 //pAnrCtx->stYnrCalib = pPara->stYnrPara;
556 ynr_calibdbV2_assign(&pAnrCtx->ynr_v1, &pPara->ynr_v1);
557 pAnrCtx->isIQParaUpdate = true;
558 }
559
560 return XCAM_RETURN_NO_ERROR;
561 }
562
563
564
565 XCamReturn
rk_aiq_uapi_anr_GetJsonPara(RkAiqAlgoContext * ctx,rk_aiq_nr_JsonPara_t * pPara)566 rk_aiq_uapi_anr_GetJsonPara(RkAiqAlgoContext *ctx,
567 rk_aiq_nr_JsonPara_t *pPara)
568 {
569
570 ANRContext_t* pAnrCtx = (ANRContext_t*)ctx;
571
572 //pPara->stBayernrPara = pAnrCtx->stBayernrCalib;
573 bayernr_calibdbV2_assign(&pPara->bayernr_v1, &pAnrCtx->bayernr_v1);
574 mfnr_calibdbV2_assign(&pPara->mfnr_v1, &pAnrCtx->mfnr_v1);
575 uvnr_calibdbV2_assign(&pPara->uvnr_v1, &pAnrCtx->uvnr_v1);
576 ynr_calibdbV2_assign(&pPara->ynr_v1, &pAnrCtx->ynr_v1);
577
578 return XCAM_RETURN_NO_ERROR;
579 }
580
581
582