1 /*
2 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "rk_aiq_user_api_anr.h"
17
18 #include "algo_handlers/RkAiqAnrHandle.h"
19 #include "algo_handlers/RkAiqArawnrHandle.h"
20 #include "algo_handlers/RkAiqAmfnrHandle.h"
21 #include "algo_handlers/RkAiqAynrHandle.h"
22 #include "algo_handlers/RkAiqAcnrHandle.h"
23
24 RKAIQ_BEGIN_DECLARE
25
26 #ifdef RK_SIMULATOR_HW
27 #define CHECK_USER_API_ENABLE
28 #endif
29
30 #if RKAIQ_HAVE_ANR_V1
31
32 XCamReturn
rk_aiq_user_api_anr_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_nr_attrib_t * attr)33 rk_aiq_user_api_anr_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_attrib_t *attr)
34 {
35 XCamReturn ret = XCAM_RETURN_NO_ERROR;
36
37 #if ANR_NO_SEPERATE_MARCO
38 CHECK_USER_API_ENABLE2(sys_ctx);
39 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ANR);
40 RKAIQ_API_SMART_LOCK(sys_ctx);
41 RkAiqAnrHandleInt* algo_handle =
42 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
43
44 if (algo_handle) {
45 ret = algo_handle->setAttrib(attr);
46 }
47 #else
48
49 CHECK_USER_API_ENABLE2(sys_ctx);
50 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ARAWNR);
51 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AMFNR);
52 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AYNR);
53 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ACNR);
54
55 RKAIQ_API_SMART_LOCK(sys_ctx);
56
57 #if RKAIQ_HAVE_BAYERNR_V1
58 RkAiqArawnrHandleInt* rawnr_algo_handle =
59 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
60 if (rawnr_algo_handle) {
61 rk_aiq_bayernr_attrib_v1_t bayernr_attr;
62 memset(&bayernr_attr, 0x00, sizeof(bayernr_attr));
63 bayernr_attr.eMode = (Abayernr_OPMode_V1_t)attr->eMode;
64 bayernr_attr.stAuto.bayernrEn = attr->stAuto.bayernrEn;
65 memcpy(&bayernr_attr.stAuto.stParams, &attr->stAuto.stBayernrParams, sizeof(bayernr_attr.stAuto.stParams));
66 memcpy(&bayernr_attr.stAuto.stSelect, &attr->stAuto.stBayernrParamSelect, sizeof(bayernr_attr.stAuto.stSelect));
67 bayernr_attr.stManual.bayernrEn = attr->stManual.bayernrEn;
68 memcpy(&bayernr_attr.stManual.stSelect, &attr->stManual.stBayernrParamSelect, sizeof(bayernr_attr.stManual.stSelect));
69 ret = rawnr_algo_handle->setAttrib(&bayernr_attr);
70 }
71 #endif
72
73 #if RKAIQ_HAVE_MFNR_V1
74 RkAiqAmfnrHandleInt* mfnr_algo_handle =
75 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
76 if (mfnr_algo_handle) {
77 rk_aiq_mfnr_attrib_v1_t mfnr_attr;
78 memset(&mfnr_attr, 0x00, sizeof(mfnr_attr));
79 mfnr_attr.eMode = (Amfnr_OPMode_V1_t)(attr->eMode);
80 mfnr_attr.stAuto.mfnrEn = attr->stAuto.mfnrEn;
81 memcpy(&mfnr_attr.stAuto.stParams, &attr->stAuto.stMfnrParams, sizeof(mfnr_attr.stAuto.stParams ));
82 memcpy(&mfnr_attr.stAuto.stSelect, &attr->stAuto.stMfnrParamSelect, sizeof(mfnr_attr.stAuto.stSelect));
83 memcpy(&mfnr_attr.stAuto.stMfnr_dynamic, &attr->stAuto.stMfnr_dynamic, sizeof(mfnr_attr.stAuto.stMfnr_dynamic));
84 mfnr_attr.stManual.mfnrEn = attr->stManual.mfnrEn;
85 memcpy(&mfnr_attr.stManual.stSelect, &attr->stManual.stMfnrParamSelect, sizeof(mfnr_attr.stManual.stSelect));
86 ret = mfnr_algo_handle->setAttrib(&mfnr_attr);
87 }
88 #endif
89
90 #if RKAIQ_HAVE_YNR_V1
91 RkAiqAynrHandleInt* ynr_algo_handle =
92 algoHandle<RkAiqAynrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AYNR);
93 if (ynr_algo_handle) {
94 rk_aiq_ynr_attrib_v1_t ynr_attr;
95 memset(&ynr_attr, 0x00, sizeof(ynr_attr));
96 ynr_attr.eMode = (Aynr_OPMode_V1_t)(attr->eMode);
97 ynr_attr.stAuto.ynrEn = attr->stAuto.ynrEn;
98 memcpy(&ynr_attr.stAuto.stParams, &attr->stAuto.stYnrParams, sizeof(ynr_attr.stAuto.stParams));
99 memcpy(&ynr_attr.stAuto.stSelect, &attr->stAuto.stYnrParamSelect, sizeof(ynr_attr.stAuto.stSelect));
100 ynr_attr.stManual.ynrEn = attr->stManual.ynrEn;
101 memcpy(&ynr_attr.stManual.stSelect, &attr->stManual.stYnrParamSelect, sizeof(ynr_attr.stManual.stSelect));
102 ret = ynr_algo_handle->setAttrib(&ynr_attr);
103 }
104 #endif
105
106 #if RKAIQ_HAVE_CNR_V1
107 RkAiqAcnrHandleInt* uvnr_algo_handle =
108 algoHandle<RkAiqAcnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACNR);
109 if (uvnr_algo_handle) {
110 rk_aiq_uvnr_attrib_v1_t uvnr_attr;
111 memset(&uvnr_attr, 0x00, sizeof(uvnr_attr));
112 uvnr_attr.eMode = (Auvnr_OPMode_t)(attr->eMode);
113 uvnr_attr.stAuto.uvnrEn = attr->stAuto.uvnrEn;
114 memcpy(&uvnr_attr.stAuto.stParams, &attr->stAuto.stUvnrParams, sizeof(uvnr_attr.stAuto.stParams));
115 memcpy(&uvnr_attr.stAuto.stSelect, &attr->stAuto.stUvnrParamSelect, sizeof(uvnr_attr.stAuto.stSelect));
116 uvnr_attr.stManual.uvnrEn = attr->stManual.uvnrEn;
117 memcpy(&uvnr_attr.stManual.stSelect, &attr->stManual.stUvnrParamSelect, sizeof(uvnr_attr.stManual.stSelect));
118 ret = uvnr_algo_handle->setAttrib(&uvnr_attr);
119 }
120 #endif
121
122 #endif
123
124 return ret;
125 }
126
127 XCamReturn
rk_aiq_user_api_anr_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_nr_attrib_t * attr)128 rk_aiq_user_api_anr_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_attrib_t *attr)
129 {
130 XCamReturn ret = XCAM_RETURN_NO_ERROR;
131 RKAIQ_API_SMART_LOCK(sys_ctx);
132
133 #if ANR_NO_SEPERATE_MARCO
134 RkAiqAnrHandleInt* algo_handle =
135 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
136
137 if (algo_handle) {
138 ret = algo_handle->getAttrib(attr);
139 }
140 #else
141
142 #if RKAIQ_HAVE_BAYERNR_V1
143 RkAiqArawnrHandleInt* rawnr_algo_handle =
144 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
145 if (rawnr_algo_handle) {
146 rk_aiq_bayernr_attrib_v1_t bayernr_attr;
147 memset(&bayernr_attr, 0x00, sizeof(bayernr_attr));
148 ret = rawnr_algo_handle->getAttrib(&bayernr_attr);
149 attr->eMode = (ANROPMode_t)(bayernr_attr.eMode);
150 attr->stAuto.bayernrEn = bayernr_attr.stAuto.bayernrEn;
151 memcpy(&attr->stAuto.stBayernrParams, &bayernr_attr.stAuto.stParams, sizeof(attr->stAuto.stBayernrParams));
152 memcpy(&attr->stAuto.stBayernrParamSelect, &bayernr_attr.stAuto.stSelect, sizeof(attr->stAuto.stBayernrParamSelect));
153 attr->stManual.bayernrEn = bayernr_attr.stManual.bayernrEn;
154 memcpy(&attr->stManual.stBayernrParamSelect, &bayernr_attr.stManual.stSelect, sizeof(attr->stManual.stBayernrParamSelect));
155 }
156 #endif
157
158 #if RKAIQ_HAVE_MFNR_V1
159 RkAiqAmfnrHandleInt* mfnr_algo_handle =
160 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
161 if (mfnr_algo_handle) {
162 rk_aiq_mfnr_attrib_v1_t mfnr_attr;
163 memset(&mfnr_attr, 0x00, sizeof(mfnr_attr));
164 ret = mfnr_algo_handle->getAttrib(&mfnr_attr);
165 attr->eMode = (ANROPMode_t)(mfnr_attr.eMode);
166 attr->stAuto.mfnrEn = mfnr_attr.stAuto.mfnrEn;
167 memcpy(&attr->stAuto.stMfnrParams, &mfnr_attr.stAuto.stParams, sizeof(attr->stAuto.stMfnrParams));
168 memcpy(&attr->stAuto.stMfnrParamSelect, &mfnr_attr.stAuto.stSelect, sizeof(attr->stAuto.stMfnrParamSelect));
169 memcpy(&attr->stAuto.stMfnr_dynamic, &mfnr_attr.stAuto.stMfnr_dynamic, sizeof(attr->stAuto.stMfnr_dynamic));
170 attr->stManual.mfnrEn = mfnr_attr.stManual.mfnrEn;
171 memcpy(&attr->stManual.stMfnrParamSelect, &mfnr_attr.stManual.stSelect, sizeof(attr->stManual.stMfnrParamSelect));
172 }
173 #endif
174
175 #if RKAIQ_HAVE_YNR_V1
176 RkAiqAynrHandleInt* ynr_algo_handle =
177 algoHandle<RkAiqAynrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AYNR);
178 if (ynr_algo_handle) {
179 rk_aiq_ynr_attrib_v1_t ynr_attr;
180 memset(&ynr_attr, 0x00, sizeof(ynr_attr));
181 ret = ynr_algo_handle->getAttrib(&ynr_attr);
182 attr->eMode = (ANROPMode_t)(ynr_attr.eMode);
183 attr->stAuto.ynrEn = ynr_attr.stAuto.ynrEn;
184 memcpy(&attr->stAuto.stYnrParams, &ynr_attr.stAuto.stParams, sizeof(attr->stAuto.stYnrParams));
185 memcpy(&attr->stAuto.stYnrParamSelect, &ynr_attr.stAuto.stSelect, sizeof(attr->stAuto.stYnrParamSelect));
186 attr->stManual.ynrEn = ynr_attr.stManual.ynrEn;
187 memcpy(&attr->stManual.stYnrParamSelect, &ynr_attr.stManual.stSelect, sizeof(attr->stManual.stYnrParamSelect));
188 }
189 #endif
190
191 #if RKAIQ_HAVE_CNR_V1
192 RkAiqAcnrHandleInt* uvnr_algo_handle =
193 algoHandle<RkAiqAcnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACNR);
194 if (uvnr_algo_handle) {
195 rk_aiq_uvnr_attrib_v1_t uvnr_attr;
196 memset(&uvnr_attr, 0x00, sizeof(uvnr_attr));
197 ret = uvnr_algo_handle->getAttrib(&uvnr_attr);
198 attr->eMode = (ANROPMode_t)(uvnr_attr.eMode);
199 attr->stAuto.uvnrEn = uvnr_attr.stAuto.uvnrEn;
200 memcpy(&attr->stAuto.stUvnrParams, &uvnr_attr.stAuto.stParams, sizeof(attr->stAuto.stUvnrParams));
201 memcpy(&attr->stAuto.stUvnrParamSelect, &uvnr_attr.stAuto.stSelect, sizeof(attr->stAuto.stUvnrParamSelect));
202 attr->stManual.uvnrEn = uvnr_attr.stManual.uvnrEn;
203 memcpy(&attr->stManual.stUvnrParamSelect, &uvnr_attr.stManual.stSelect, sizeof(attr->stManual.stUvnrParamSelect));
204 }
205 #endif
206
207 #endif
208
209 return ret;
210 }
211
212
213 XCamReturn
rk_aiq_user_api_anr_SetIQPara(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_nr_IQPara_t * para)214 rk_aiq_user_api_anr_SetIQPara(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_IQPara_t *para)
215 {
216 XCamReturn ret = XCAM_RETURN_NO_ERROR;
217 RKAIQ_API_SMART_LOCK(sys_ctx);
218
219 #if ANR_NO_SEPERATE_MARCO
220 RkAiqAnrHandleInt* algo_handle =
221 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
222
223 if (algo_handle) {
224 ret = algo_handle->setIQPara(para);
225 }
226 #else
227 printf("%s:%d\n", __FUNCTION__, __LINE__);
228 #if RKAIQ_HAVE_BAYERNR_V1
229 if(para->module_bits & (1 << ANR_MODULE_BAYERNR)) {
230 RkAiqArawnrHandleInt* rawnr_algo_handle =
231 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
232 if (rawnr_algo_handle) {
233 rk_aiq_bayernr_IQPara_V1_t bayernr_para;
234 bayernr_para.stBayernrPara = para->stBayernrPara;
235 ret = rawnr_algo_handle->setIQPara(&bayernr_para);
236 }
237 }
238 #endif
239 printf("%s:%d\n", __FUNCTION__, __LINE__);
240 #if RKAIQ_HAVE_MFNR_V1
241 if(para->module_bits & (1 << ANR_MODULE_MFNR)) {
242 RkAiqAmfnrHandleInt* mfnr_algo_handle =
243 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
244 if (mfnr_algo_handle) {
245 rk_aiq_mfnr_IQPara_V1_t mfnr_para;
246 mfnr_para.stMfnrPara = para->stMfnrPara;
247 ret = mfnr_algo_handle->setIQPara(&mfnr_para);
248 }
249 }
250 #endif
251 printf("%s:%d\n", __FUNCTION__, __LINE__);
252 #if RKAIQ_HAVE_YNR_V1
253 if(para->module_bits & (1 << ANR_MODULE_YNR)) {
254 RkAiqAynrHandleInt* ynr_algo_handle =
255 algoHandle<RkAiqAynrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AYNR);
256 if (ynr_algo_handle) {
257 rk_aiq_ynr_IQPara_V1_t ynr_para;
258 ynr_para.stYnrPara = para->stYnrPara;
259 ret = ynr_algo_handle->setIQPara(&ynr_para);
260 }
261 }
262 #endif
263 printf("%s:%d\n", __FUNCTION__, __LINE__);
264 #if RKAIQ_HAVE_CNR_V1
265 if(para->module_bits & (1 << ANR_MODULE_UVNR)) {
266 RkAiqAcnrHandleInt* uvnr_algo_handle =
267 algoHandle<RkAiqAcnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACNR);
268 if (uvnr_algo_handle) {
269 rk_aiq_uvnr_IQPara_v1_t uvnr_para;
270 uvnr_para.stUvnrPara = para->stUvnrPara;
271 ret = uvnr_algo_handle->setIQPara(&uvnr_para);
272 }
273 }
274 #endif
275
276 printf("%s:%d\n", __FUNCTION__, __LINE__);
277 #endif
278
279 return ret;
280 }
281
282 XCamReturn
rk_aiq_user_api_anr_GetIQPara(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_nr_IQPara_t * para)283 rk_aiq_user_api_anr_GetIQPara(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_IQPara_t *para)
284 {
285 XCamReturn ret = XCAM_RETURN_NO_ERROR;
286 RKAIQ_API_SMART_LOCK(sys_ctx);
287
288 #if ANR_NO_SEPERATE_MARCO
289 RkAiqAnrHandleInt* algo_handle =
290 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
291
292 if (algo_handle) {
293 ret = algo_handle->getIQPara(para);
294 }
295 #else
296 printf("rawnr\n");
297 #if RKAIQ_HAVE_BAYERNR_V1
298 RkAiqArawnrHandleInt* rawnr_algo_handle =
299 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
300 if (rawnr_algo_handle) {
301 printf("rawnr1111\n");
302 rk_aiq_bayernr_IQPara_V1_t bayernr_para;
303 ret = rawnr_algo_handle->getIQPara(&bayernr_para);
304 printf("rawnr2222\n");
305 para->stBayernrPara = bayernr_para.stBayernrPara;
306 }
307 #endif
308
309 printf("mfnr\n");
310 #if RKAIQ_HAVE_MFNR_V1
311 RkAiqAmfnrHandleInt* mfnr_algo_handle =
312 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
313 if (mfnr_algo_handle) {
314 rk_aiq_mfnr_IQPara_V1_t mfnr_para;
315 printf("mfnr 1111\n");
316 ret = mfnr_algo_handle->getIQPara(&mfnr_para);
317 para->stMfnrPara = mfnr_para.stMfnrPara;
318 printf("mfnr 2222\n");
319 }
320 #endif
321
322 printf("ynr\n");
323 #if RKAIQ_HAVE_YNR_V1
324 RkAiqAynrHandleInt* ynr_algo_handle =
325 algoHandle<RkAiqAynrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AYNR);
326 if (ynr_algo_handle) {
327 rk_aiq_ynr_IQPara_V1_t ynr_para;
328 ret = ynr_algo_handle->getIQPara(&ynr_para);
329 para->stYnrPara = ynr_para.stYnrPara;
330 }
331 #endif
332
333 printf("uvnr\n");
334 #if RKAIQ_HAVE_CNR_V1
335 RkAiqAcnrHandleInt* uvnr_algo_handle =
336 algoHandle<RkAiqAcnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACNR);
337 if (uvnr_algo_handle) {
338 rk_aiq_uvnr_IQPara_v1_t uvnr_para;
339 ret = uvnr_algo_handle->getIQPara(&uvnr_para);
340 para->stUvnrPara = uvnr_para.stUvnrPara;
341 }
342 #endif
343
344 printf("exit\n");
345 #endif
346
347 return ret;
348 }
349
350
351 XCamReturn
rk_aiq_user_api_anr_SetLumaSFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float fPercnt)352 rk_aiq_user_api_anr_SetLumaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
353 {
354 XCamReturn ret = XCAM_RETURN_NO_ERROR;
355 RKAIQ_API_SMART_LOCK(sys_ctx);
356
357 #if ANR_NO_SEPERATE_MARCO
358 RkAiqAnrHandleInt* algo_handle =
359 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
360
361 if (algo_handle) {
362 ret = algo_handle->setLumaSFStrength(fPercnt);
363 }
364 #else
365
366 #if RKAIQ_HAVE_BAYERNR_V1
367 RkAiqArawnrHandleInt* rawnr_algo_handle =
368 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
369 if (rawnr_algo_handle) {
370 ret = rawnr_algo_handle->setStrength(fPercnt);
371 }
372 #endif
373
374 #if RKAIQ_HAVE_YNR_V1
375 RkAiqAynrHandleInt* ynr_algo_handle =
376 algoHandle<RkAiqAynrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AYNR);
377 if (ynr_algo_handle) {
378 ret = ynr_algo_handle->setStrength(fPercnt);
379 }
380 #endif
381
382 #endif
383
384 return ret;
385 }
386
387 XCamReturn
rk_aiq_user_api_anr_SetLumaTFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float fPercnt)388 rk_aiq_user_api_anr_SetLumaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
389 {
390 XCamReturn ret = XCAM_RETURN_NO_ERROR;
391 RKAIQ_API_SMART_LOCK(sys_ctx);
392
393 #if ANR_NO_SEPERATE_MARCO
394 RkAiqAnrHandleInt* algo_handle =
395 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
396
397 if (algo_handle) {
398 ret = algo_handle->setLumaTFStrength(fPercnt);
399 }
400 #else
401 #if RKAIQ_HAVE_MFNR_V1
402 RkAiqAmfnrHandleInt* mfnr_algo_handle =
403 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
404 if (mfnr_algo_handle) {
405 ret = mfnr_algo_handle->setLumaStrength(fPercnt);
406 }
407 #endif
408 #endif
409
410 return ret;
411 }
412
413 XCamReturn
rk_aiq_user_api_anr_GetLumaSFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float * pPercnt)414 rk_aiq_user_api_anr_GetLumaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
415 {
416 XCamReturn ret = XCAM_RETURN_NO_ERROR;
417 RKAIQ_API_SMART_LOCK(sys_ctx);
418
419 #if ANR_NO_SEPERATE_MARCO
420 RkAiqAnrHandleInt* algo_handle =
421 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
422
423 if (algo_handle) {
424 ret = algo_handle->getLumaSFStrength(pPercnt);
425 }
426 #else
427 #if RKAIQ_HAVE_BAYERNR_V1
428 RkAiqArawnrHandleInt* rawnr_algo_handle =
429 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
430 if (rawnr_algo_handle) {
431 ret = rawnr_algo_handle->getStrength(pPercnt);
432 }
433 #endif
434
435 #if 0
436 RkAiqAynrHandleInt* ynr_algo_handle =
437 algoHandle<RkAiqAynrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AYNR);
438 if (ynr_algo_handle) {
439 ret = ynr_algo_handle->getStrength(pPercnt);
440 }
441 #endif
442 #endif
443
444 return ret;
445 }
446
447 XCamReturn
rk_aiq_user_api_anr_GetLumaTFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float * pPercnt)448 rk_aiq_user_api_anr_GetLumaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
449 {
450 XCamReturn ret = XCAM_RETURN_NO_ERROR;
451 RKAIQ_API_SMART_LOCK(sys_ctx);
452
453 #if ANR_NO_SEPERATE_MARCO
454 RkAiqAnrHandleInt* algo_handle =
455 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
456
457 if (algo_handle) {
458 ret = algo_handle->getLumaTFStrength(pPercnt);
459 }
460 #else
461 #if RKAIQ_HAVE_MFNR_V1
462 RkAiqAmfnrHandleInt* mfnr_algo_handle =
463 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
464 if (mfnr_algo_handle) {
465 ret = mfnr_algo_handle->getLumaStrength(pPercnt);
466 }
467 #endif
468 #endif
469
470 return ret;
471 }
472
473 XCamReturn
rk_aiq_user_api_anr_SetChromaSFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float fPercnt)474 rk_aiq_user_api_anr_SetChromaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
475 {
476 XCamReturn ret = XCAM_RETURN_NO_ERROR;
477 RKAIQ_API_SMART_LOCK(sys_ctx);
478
479 #if ANR_NO_SEPERATE_MARCO
480 RkAiqAnrHandleInt* algo_handle =
481 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
482
483 if (algo_handle) {
484 ret = algo_handle->setChromaSFStrength(fPercnt);
485 }
486 #else
487 #if RKAIQ_HAVE_CNR_V1
488 RkAiqAcnrHandleInt* uvnr_algo_handle =
489 algoHandle<RkAiqAcnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACNR);
490 if (uvnr_algo_handle) {
491 ret = uvnr_algo_handle->setStrength(fPercnt);
492 }
493 #endif
494 #endif
495
496 return ret;
497 }
498
499 XCamReturn
rk_aiq_user_api_anr_SetChromaTFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float fPercnt)500 rk_aiq_user_api_anr_SetChromaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
501 {
502 XCamReturn ret = XCAM_RETURN_NO_ERROR;
503 RKAIQ_API_SMART_LOCK(sys_ctx);
504
505 #if ANR_NO_SEPERATE_MARCO
506 RkAiqAnrHandleInt* algo_handle =
507 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
508
509 if (algo_handle) {
510 ret = algo_handle->setChromaTFStrength(fPercnt);
511 }
512 #else
513 #if RKAIQ_HAVE_MFNR_V1
514 RkAiqAmfnrHandleInt* mfnr_algo_handle =
515 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
516 if (mfnr_algo_handle) {
517 ret = mfnr_algo_handle->setChromaStrength(fPercnt);
518 }
519 #endif
520 #endif
521
522 return ret;
523 }
524
525 XCamReturn
rk_aiq_user_api_anr_GetChromaSFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float * pPercnt)526 rk_aiq_user_api_anr_GetChromaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
527 {
528 XCamReturn ret = XCAM_RETURN_NO_ERROR;
529 RKAIQ_API_SMART_LOCK(sys_ctx);
530
531 #if ANR_NO_SEPERATE_MARCO
532 RkAiqAnrHandleInt* algo_handle =
533 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
534
535 if (algo_handle) {
536 ret = algo_handle->getChromaSFStrength(pPercnt);
537 }
538 #else
539 #if RKAIQ_HAVE_CNR_V1
540 RkAiqAcnrHandleInt* uvnr_algo_handle =
541 algoHandle<RkAiqAcnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACNR);
542 if (uvnr_algo_handle) {
543 ret = uvnr_algo_handle->getStrength(pPercnt);
544 }
545 #endif
546 #endif
547
548 return ret;
549 }
550
551 XCamReturn
rk_aiq_user_api_anr_GetChromaTFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float * pPercnt)552 rk_aiq_user_api_anr_GetChromaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
553 {
554 XCamReturn ret = XCAM_RETURN_NO_ERROR;
555 RKAIQ_API_SMART_LOCK(sys_ctx);
556
557 #if ANR_NO_SEPERATE_MARCO
558 RkAiqAnrHandleInt* algo_handle =
559 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
560
561 if (algo_handle) {
562 ret = algo_handle->getChromaTFStrength(pPercnt);
563 }
564 #else
565 #if RKAIQ_HAVE_MFNR_V1
566 RkAiqAmfnrHandleInt* mfnr_algo_handle =
567 algoHandle<RkAiqAmfnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMFNR);
568 if (mfnr_algo_handle) {
569 ret = mfnr_algo_handle->getChromaStrength(pPercnt);
570 }
571 #endif
572 #endif
573
574 return ret;
575 }
576
577 XCamReturn
rk_aiq_user_api_anr_SetRawnrSFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float fPercnt)578 rk_aiq_user_api_anr_SetRawnrSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
579 {
580 XCamReturn ret = XCAM_RETURN_NO_ERROR;
581 RKAIQ_API_SMART_LOCK(sys_ctx);
582
583 #if ANR_NO_SEPERATE_MARCO
584 RkAiqAnrHandleInt* algo_handle =
585 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
586
587 if (algo_handle) {
588 ret = algo_handle->setRawnrSFStrength(fPercnt);
589 }
590 #else
591 #if RKAIQ_HAVE_BAYERNR_V1
592 RkAiqArawnrHandleInt* rawnr_algo_handle =
593 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
594 if (rawnr_algo_handle) {
595 ret = rawnr_algo_handle->setStrength(fPercnt);
596 }
597 #endif
598 #endif
599
600 return ret;
601 }
602
603 XCamReturn
rk_aiq_user_api_anr_GetRawnrSFStrength(const rk_aiq_sys_ctx_t * sys_ctx,float * pPercnt)604 rk_aiq_user_api_anr_GetRawnrSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
605 {
606 XCamReturn ret = XCAM_RETURN_NO_ERROR;
607 RKAIQ_API_SMART_LOCK(sys_ctx);
608
609 #if ANR_NO_SEPERATE_MARCO
610 RkAiqAnrHandleInt* algo_handle =
611 algoHandle<RkAiqAnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ANR);
612
613 if (algo_handle) {
614 ret = algo_handle->getRawnrSFStrength(pPercnt);
615 }
616 #else
617 #if RKAIQ_HAVE_BAYERNR_V1
618 RkAiqArawnrHandleInt* rawnr_algo_handle =
619 algoHandle<RkAiqArawnrHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ARAWNR);
620 if (rawnr_algo_handle) {
621 ret = rawnr_algo_handle->getStrength(pPercnt);
622 }
623 #endif
624 #endif
625
626 return XCAM_RETURN_NO_ERROR;
627 }
628 #else
629
630 XCamReturn
631 rk_aiq_user_api_anr_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_attrib_t *attr)
632 {
633 return XCAM_RETURN_ERROR_UNKNOWN;
634 }
635
636 XCamReturn
637 rk_aiq_user_api_anr_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_attrib_t *attr)
638 {
639 return XCAM_RETURN_ERROR_UNKNOWN;
640 }
641
642 XCamReturn
643 rk_aiq_user_api_anr_SetIQPara(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_IQPara_t *para)
644 {
645 return XCAM_RETURN_ERROR_UNKNOWN;
646 }
647
648 XCamReturn
649 rk_aiq_user_api_anr_GetIQPara(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_nr_IQPara_t *para)
650 {
651 return XCAM_RETURN_ERROR_UNKNOWN;
652 }
653
654 XCamReturn
655 rk_aiq_user_api_anr_SetLumaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
656 {
657 return XCAM_RETURN_ERROR_UNKNOWN;
658 }
659
660 XCamReturn
661 rk_aiq_user_api_anr_SetLumaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
662 {
663 return XCAM_RETURN_ERROR_UNKNOWN;
664 }
665
666 XCamReturn
667 rk_aiq_user_api_anr_GetLumaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
668 {
669 return XCAM_RETURN_ERROR_UNKNOWN;
670 }
671
672 XCamReturn
673 rk_aiq_user_api_anr_GetLumaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
674 {
675 return XCAM_RETURN_ERROR_UNKNOWN;
676 }
677
678 XCamReturn
679 rk_aiq_user_api_anr_SetChromaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
680 {
681 return XCAM_RETURN_ERROR_UNKNOWN;
682 }
683
684 XCamReturn
685 rk_aiq_user_api_anr_SetChromaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
686 {
687 return XCAM_RETURN_ERROR_UNKNOWN;
688 }
689
690 XCamReturn
691 rk_aiq_user_api_anr_GetChromaSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
692 {
693 return XCAM_RETURN_ERROR_UNKNOWN;
694 }
695
696 XCamReturn
697 rk_aiq_user_api_anr_GetChromaTFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
698 {
699 return XCAM_RETURN_ERROR_UNKNOWN;
700 }
701
702 XCamReturn
703 rk_aiq_user_api_anr_SetRawnrSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float fPercnt)
704 {
705 return XCAM_RETURN_ERROR_UNKNOWN;
706 }
707
708 XCamReturn
709 rk_aiq_user_api_anr_GetRawnrSFStrength(const rk_aiq_sys_ctx_t* sys_ctx, float *pPercnt)
710 {
711 return XCAM_RETURN_ERROR_UNKNOWN;
712 }
713
714
715
716 #endif
717 RKAIQ_END_DECLARE
718