1 /*
2 * Copyright (c) 2019 Rockchip Corporation
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 */
17
18 #include "rk_aiq_user_api_imgproc.h"
19
20 #ifdef RK_SIMULATOR_HW
21 #define CHECK_USER_API_ENABLE
22 #endif
23
24 #define RKAIQ_IMGPROC_CHECK_RET(ret, format, ...) \
25 if (ret) { \
26 LOGE(format, ##__VA_ARGS__); \
27 return ret; \
28 }
29
30 #define IMGPROC_FUNC_ENTER LOGD("%s: enter", __FUNCTION__);
31 #define IMGPROC_FUNC_EXIT LOGD("%s: exit", __FUNCTION__);
32
33 RKAIQ_BEGIN_DECLARE
34
isHDRmode(const rk_aiq_sys_ctx_t * ctx)35 static bool isHDRmode(const rk_aiq_sys_ctx_t* ctx)
36 {
37 RKAIQ_API_SMART_LOCK(ctx);
38 int mode = RK_AIQ_WORKING_MODE_NORMAL;
39 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
40 #ifdef RKAIQ_ENABLE_CAMGROUP
41 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
42 mode = camgroup_ctx->cam_ctxs_array[0]->_analyzer->mAlogsComSharedParams.working_mode;
43 #endif
44 } else {
45 mode = ctx->_analyzer->mAlogsComSharedParams.working_mode;
46 }
47
48 if (RK_AIQ_WORKING_MODE_NORMAL == mode)
49 return false;
50 else
51 return true;
52 }
53
getHDRFrameNum(const rk_aiq_sys_ctx_t * ctx)54 static int getHDRFrameNum(const rk_aiq_sys_ctx_t* ctx)
55 {
56 RKAIQ_API_SMART_LOCK(ctx);
57 int FrameNum = 1, working_mode = RK_AIQ_WORKING_MODE_NORMAL;
58
59 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
60 #ifdef RKAIQ_ENABLE_CAMGROUP
61 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
62 working_mode = camgroup_ctx->cam_ctxs_array[0]->_analyzer->mAlogsComSharedParams.working_mode;
63 #endif
64 } else {
65 working_mode = ctx->_analyzer->mAlogsComSharedParams.working_mode;
66 }
67
68 switch (working_mode)
69 {
70 case RK_AIQ_WORKING_MODE_NORMAL:
71 FrameNum = 1;
72 break;
73 case RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR:
74 case RK_AIQ_ISP_HDR_MODE_2_LINE_HDR:
75 FrameNum = 2;
76 break;
77 case RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR:
78 case RK_AIQ_ISP_HDR_MODE_3_LINE_HDR:
79 FrameNum = 3;
80 break;
81 default:
82 FrameNum = 1;
83 break;
84 }
85 return FrameNum;
86 }
87
88 /*
89 **********************************************************
90 * API of AEC module of V1
91 **********************************************************
92 */
93
94 /*
95 *****************************
96 *
97 * Desc: set exposure control mode
98 * Argument:
99 * mode: auto: auto exposure
100 * manual: manual exposure
101 *****************************
102 */
rk_aiq_uapi_setExpMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)103 XCamReturn rk_aiq_uapi_setExpMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
104 {
105 IMGPROC_FUNC_ENTER
106 XCamReturn ret = XCAM_RETURN_NO_ERROR;
107 Uapi_ExpSwAttr_t expSwAttr;
108 if (ctx == NULL) {
109 ret = XCAM_RETURN_ERROR_PARAM;
110 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
111 }
112
113 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
114 RKAIQ_IMGPROC_CHECK_RET(ret, "setExpMode failed in getExpSwAttr!");
115 if (mode == OP_AUTO) {
116 expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
117 } else if (mode == OP_MANUAL) {
118 if (isHDRmode(ctx)) {
119 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
120 expSwAttr.stManual.stHdrMe.ManualGainEn = true;
121 expSwAttr.stManual.stHdrMe.ManualTimeEn = true;
122 } else {
123 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
124 expSwAttr.stManual.stLinMe.ManualGainEn = true;
125 expSwAttr.stManual.stLinMe.ManualTimeEn = true;
126 }
127 } else {
128 ret = XCAM_RETURN_ERROR_PARAM;
129 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is not supported!");
130 }
131 ret = rk_aiq_user_api_ae_setExpSwAttr(ctx, expSwAttr);
132 RKAIQ_IMGPROC_CHECK_RET(ret, "setExpMode failed in setExpSwAttr!");
133 IMGPROC_FUNC_EXIT
134 return (ret);
135 }
136
rk_aiq_uapi_getExpMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)137 XCamReturn rk_aiq_uapi_getExpMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
138 {
139 XCamReturn ret = XCAM_RETURN_NO_ERROR;
140 Uapi_ExpSwAttr_t expSwAttr;
141 IMGPROC_FUNC_ENTER
142 if ((ctx == NULL) || (mode == NULL)) {
143 ret = XCAM_RETURN_ERROR_PARAM;
144 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
145 }
146
147 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
148 RKAIQ_IMGPROC_CHECK_RET(ret, "getExpMode failed in getExpSwAttr!");
149 if (expSwAttr.AecOpType == RK_AIQ_OP_MODE_AUTO) {
150 *mode = OP_AUTO;
151 } else if (expSwAttr.AecOpType == RK_AIQ_OP_MODE_MANUAL) {
152 *mode = OP_MANUAL;
153 }
154 IMGPROC_FUNC_EXIT
155 return (ret);
156 }
157
rk_aiq_uapi_setManualExp(const rk_aiq_sys_ctx_t * ctx,float gain,float time)158 XCamReturn rk_aiq_uapi_setManualExp(const rk_aiq_sys_ctx_t* ctx, float gain, float time)
159 {
160 IMGPROC_FUNC_ENTER
161 XCamReturn ret = XCAM_RETURN_NO_ERROR;
162 Uapi_ExpSwAttr_t expSwAttr;
163 if (ctx == NULL) {
164 ret = XCAM_RETURN_ERROR_PARAM;
165 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
166 }
167 if (gain < 0.0f || time < 0.0f) {
168 ret = XCAM_RETURN_NO_ERROR;
169 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
170 }
171 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
172 RKAIQ_IMGPROC_CHECK_RET(ret, "setManualExp failed in getExpSwAttr!");
173 if (isHDRmode(ctx)) {
174 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
175 expSwAttr.stManual.stHdrMe.ManualGainEn = true;
176 expSwAttr.stManual.stHdrMe.ManualTimeEn = true;
177 expSwAttr.stManual.stHdrMe.GainValue.fCoeff[0] = gain;
178 expSwAttr.stManual.stHdrMe.GainValue.fCoeff[1] = gain;
179 expSwAttr.stManual.stHdrMe.GainValue.fCoeff[2] = gain;
180 expSwAttr.stManual.stHdrMe.TimeValue.fCoeff[0] = time;
181 expSwAttr.stManual.stHdrMe.TimeValue.fCoeff[1] = time;
182 expSwAttr.stManual.stHdrMe.TimeValue.fCoeff[2] = time;
183 } else {
184 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
185 expSwAttr.stManual.stLinMe.ManualGainEn = true;
186 expSwAttr.stManual.stLinMe.ManualTimeEn = true;
187 expSwAttr.stManual.stLinMe.GainValue = gain;
188 expSwAttr.stManual.stLinMe.TimeValue = time;
189 }
190 ret = rk_aiq_user_api_ae_setExpSwAttr(ctx, expSwAttr);
191 RKAIQ_IMGPROC_CHECK_RET(ret, "setManualExp failed in setExpSwAttr!");
192 IMGPROC_FUNC_EXIT
193 return (ret);
194 }
195
196 /*
197 *****************************
198 *
199 * Desc: set exposure parameter
200 * Argument:
201 * auto exposure mode:
202 * exposure gain will be adjust between [gain->min, gain->max]锛?* manual exposure mode:
203 * gain->min == gain->max
204 *
205 *****************************
206 */
rk_aiq_uapi_setExpGainRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * gain)207 XCamReturn rk_aiq_uapi_setExpGainRange(const rk_aiq_sys_ctx_t* ctx, paRange_t *gain)
208 {
209 XCamReturn ret = XCAM_RETURN_NO_ERROR;
210 Uapi_ExpSwAttr_t expSwAttr;
211 IMGPROC_FUNC_ENTER
212 if ((ctx == NULL) || (gain == NULL)) {
213 ret = XCAM_RETURN_ERROR_PARAM;
214 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
215 }
216 LOGD("set range: [%f, %f]", gain->min, gain->max);
217
218 if (gain->min < 1.0f || gain->max < 1.0f || (gain->min - gain->max) > 0.0000001 ) {
219 ret = XCAM_RETURN_ERROR_PARAM;
220 RKAIQ_IMGPROC_CHECK_RET(ret, "gain range is wrong!");
221 }
222 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
223 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpGainRange failed!");
224
225 expSwAttr.stAuto.SetAeRangeEn = true;
226 if (isHDRmode(ctx)) {
227 expSwAttr.stAuto.stHdrAeRange.stGainRange[0].Max = gain->max;
228 expSwAttr.stAuto.stHdrAeRange.stGainRange[0].Min = gain->min;
229 expSwAttr.stAuto.stHdrAeRange.stGainRange[1].Max = gain->max;
230 expSwAttr.stAuto.stHdrAeRange.stGainRange[1].Min = gain->min;
231 expSwAttr.stAuto.stHdrAeRange.stGainRange[2].Max = gain->max;
232 expSwAttr.stAuto.stHdrAeRange.stGainRange[2].Min = gain->min;
233 } else {
234 expSwAttr.stAuto.stLinAeRange.stGainRange.Max = gain->max;
235 expSwAttr.stAuto.stLinAeRange.stGainRange.Min = gain->min;
236 }
237 ret = rk_aiq_user_api_ae_setExpSwAttr(ctx, expSwAttr);
238 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpGainRange failed!");
239 IMGPROC_FUNC_EXIT
240 return (ret);
241 }
242
rk_aiq_uapi_getExpGainRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * gain)243 XCamReturn rk_aiq_uapi_getExpGainRange(const rk_aiq_sys_ctx_t* ctx, paRange_t *gain)
244 {
245 XCamReturn ret = XCAM_RETURN_NO_ERROR;
246 Uapi_ExpSwAttr_t expSwAttr;
247 IMGPROC_FUNC_ENTER
248 if ((ctx == NULL) || (gain == NULL)) {
249 ret = XCAM_RETURN_ERROR_PARAM;
250 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
251 }
252
253 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
254 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetExpGainRange failed!");
255 if (isHDRmode(ctx)) {
256 int index = getHDRFrameNum(ctx);
257 gain->max = expSwAttr.stAuto.stHdrAeRange.stGainRange[index - 1].Max;
258 gain->min = expSwAttr.stAuto.stHdrAeRange.stGainRange[index - 1].Min;
259 } else {
260 gain->max = expSwAttr.stAuto.stLinAeRange.stGainRange.Max;
261 gain->min = expSwAttr.stAuto.stLinAeRange.stGainRange.Min;
262 }
263
264 IMGPROC_FUNC_EXIT
265 return (ret);
266 }
267
268 /*
269 *****************************
270 *
271 * Desc: set exposure parameter
272 * Argument:
273 * auto exposure mode:
274 * exposure time will be adjust between [time->min, time->max]锛?* manual exposure mode:
275 * exposure time will be set gain->min == gain->max;
276 *
277 *****************************
278 */
rk_aiq_uapi_setExpTimeRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * time)279 XCamReturn rk_aiq_uapi_setExpTimeRange(const rk_aiq_sys_ctx_t* ctx, paRange_t *time)
280 {
281 XCamReturn ret = XCAM_RETURN_NO_ERROR;
282 Uapi_ExpSwAttr_t expSwAttr;
283 IMGPROC_FUNC_ENTER
284 if ((ctx == NULL) || (time == NULL)) {
285 ret = XCAM_RETURN_ERROR_PARAM;
286 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
287 }
288 if ( (time->min - time->max) > 0.0000001 ) {
289 ret = XCAM_RETURN_ERROR_PARAM;
290 RKAIQ_IMGPROC_CHECK_RET(ret, "time range is wrong!");
291 }
292 LOGD("set range: [%f, %f]", time->min, time->max);
293 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
294 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpTimeRange failed!");
295
296 expSwAttr.stAuto.SetAeRangeEn = true;
297 if (isHDRmode(ctx)) {
298 expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[0].Max = time->max;
299 expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[0].Min = time->min;
300 expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[1].Max = time->max;
301 expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[1].Min = time->min;
302 expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[2].Max = time->max;
303 expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[2].Min = time->min;
304 } else {
305 expSwAttr.stAuto.stLinAeRange.stExpTimeRange.Max = time->max;
306 expSwAttr.stAuto.stLinAeRange.stExpTimeRange.Min = time->min;
307 }
308 ret = rk_aiq_user_api_ae_setExpSwAttr(ctx, expSwAttr);
309 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpTimeRange failed!");
310 IMGPROC_FUNC_EXIT
311 return (ret);
312 }
313
rk_aiq_uapi_getExpTimeRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * time)314 XCamReturn rk_aiq_uapi_getExpTimeRange(const rk_aiq_sys_ctx_t* ctx, paRange_t *time)
315 {
316 XCamReturn ret = XCAM_RETURN_NO_ERROR;
317 Uapi_ExpSwAttr_t expSwAttr;
318 IMGPROC_FUNC_ENTER
319 if ((ctx == NULL) || (time == NULL)) {
320 ret = XCAM_RETURN_ERROR_PARAM;
321 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
322 }
323
324 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
325 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetExpTimeRange failed!");
326 if (isHDRmode(ctx)) {
327 int index = getHDRFrameNum(ctx);
328 time->max = expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[index - 1].Max;
329 time->min = expSwAttr.stAuto.stHdrAeRange.stExpTimeRange[index - 1].Min;
330 } else {
331 time->max = expSwAttr.stAuto.stLinAeRange.stExpTimeRange.Max;
332 time->min = expSwAttr.stAuto.stLinAeRange.stExpTimeRange.Min;
333 }
334
335 IMGPROC_FUNC_EXIT
336 return (ret);
337 }
338
339 /*
340 *****************************
341 *
342 * Desc: backlight compensation
343 * Argument:
344 * on: 1 on
345 * 0 off
346 * areaType: backlight compensation area
347 *
348 *****************************
349 */
rk_aiq_uapi_setBLCMode(const rk_aiq_sys_ctx_t * ctx,bool on,aeMeasAreaType_t areaType)350 XCamReturn rk_aiq_uapi_setBLCMode(const rk_aiq_sys_ctx_t* ctx, bool on, aeMeasAreaType_t areaType)
351 {
352 XCamReturn ret = XCAM_RETURN_NO_ERROR;
353
354 Uapi_LinExpAttr_t lineExpAttr;
355 memset(&lineExpAttr, 0x00, sizeof(Uapi_LinExpAttr_t));
356 IMGPROC_FUNC_ENTER
357 if (ctx == NULL) {
358 ret = XCAM_RETURN_ERROR_PARAM;
359 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
360 }
361 if (isHDRmode(ctx)) {
362 ret = XCAM_RETURN_ERROR_FAILED;
363 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
364 }
365
366 ret = rk_aiq_user_api_ae_getLinExpAttr(ctx, &lineExpAttr);
367 RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!");
368 lineExpAttr.BackLightConf.enable = on ? 1 : 0;
369 lineExpAttr.BackLightConf.MeasArea = (CalibDb_AecMeasAreaMode_t)areaType;
370 lineExpAttr.BackLightConf.StrBias = 0;
371 ret = rk_aiq_user_api_ae_setLinExpAttr(ctx, lineExpAttr);
372 RKAIQ_IMGPROC_CHECK_RET(ret, "setBLCMode error!");
373 IMGPROC_FUNC_EXIT
374 return ret;
375 }
376
377 /*
378 *****************************
379 *
380 * Desc: backlight compensation strength,only available in normal mode
381 * Argument:
382 * strength: [1,100]
383 *****************************
384 */
rk_aiq_uapi_setBLCStrength(const rk_aiq_sys_ctx_t * ctx,int strength)385 XCamReturn rk_aiq_uapi_setBLCStrength(const rk_aiq_sys_ctx_t* ctx, int strength)
386 {
387 XCamReturn ret = XCAM_RETURN_NO_ERROR;
388 Uapi_LinExpAttr_t lineExpAttr;
389 memset(&lineExpAttr, 0x00, sizeof(Uapi_LinExpAttr_t));
390
391 IMGPROC_FUNC_ENTER
392 if (ctx == NULL) {
393 ret = XCAM_RETURN_ERROR_PARAM;
394 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
395 }
396 if (isHDRmode(ctx)) {
397 ret = XCAM_RETURN_ERROR_FAILED;
398 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
399 } else {
400 ret = rk_aiq_user_api_ae_getLinExpAttr(ctx, &lineExpAttr);
401 RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!");
402 if(0 == lineExpAttr.BackLightConf.enable)
403 RKAIQ_IMGPROC_CHECK_RET(ret, "blc mode is not enabled!");
404 lineExpAttr.BackLightConf.StrBias = strength;
405 ret = rk_aiq_user_api_ae_setLinExpAttr(ctx, lineExpAttr);
406 RKAIQ_IMGPROC_CHECK_RET(ret, "setBLCStrength error!");
407 }
408
409 IMGPROC_FUNC_EXIT
410 return ret;
411 }
412
413 /*
414 *****************************
415 *
416 * Desc: highlight compensation
417 * Argument:
418 * on: 1 on
419 * 0 off
420 *****************************
421 */
rk_aiq_uapi_setHLCMode(const rk_aiq_sys_ctx_t * ctx,bool on)422 XCamReturn rk_aiq_uapi_setHLCMode(const rk_aiq_sys_ctx_t* ctx, bool on)
423 {
424 XCamReturn ret = XCAM_RETURN_NO_ERROR;
425 Uapi_LinExpAttr_t linExpAttr;
426 memset(&linExpAttr, 0x00, sizeof(Uapi_LinExpAttr_t));
427 IMGPROC_FUNC_ENTER
428 if (ctx == NULL) {
429 ret = XCAM_RETURN_ERROR_PARAM;
430 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
431 }
432
433 if (isHDRmode(ctx)) {
434 ret = XCAM_RETURN_ERROR_FAILED;
435 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
436 } else {
437 ret = rk_aiq_user_api_ae_getLinExpAttr(ctx, &linExpAttr);
438 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\n setHLCMode failed!");
439 linExpAttr.OverExpCtrl.enable = on ? 1 : 0;
440 linExpAttr.OverExpCtrl.StrBias = 0;
441 ret = rk_aiq_user_api_ae_setLinExpAttr(ctx, linExpAttr);
442 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\n setHLCMode failed!");
443 }
444 IMGPROC_FUNC_EXIT
445 return ret;
446
447 }
448
449 /*
450 *****************************
451 *
452 * Desc: highlight compensation strength
453 * Argument:
454 * strength: [1,100]
455 *****************************
456 */
rk_aiq_uapi_setHLCStrength(const rk_aiq_sys_ctx_t * ctx,int strength)457 XCamReturn rk_aiq_uapi_setHLCStrength(const rk_aiq_sys_ctx_t* ctx, int strength)
458 {
459 XCamReturn ret = XCAM_RETURN_NO_ERROR;
460 Uapi_LinExpAttr_t lineExpAttr;
461 memset(&lineExpAttr, 0x00, sizeof(Uapi_LinExpAttr_t));
462 IMGPROC_FUNC_ENTER
463 if (ctx == NULL) {
464 ret = XCAM_RETURN_ERROR_PARAM;
465 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
466 }
467 if (isHDRmode(ctx)) {
468 ret = XCAM_RETURN_ERROR_FAILED;
469 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
470 } else {
471 ret = rk_aiq_user_api_ae_getLinExpAttr(ctx, &lineExpAttr);
472 RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!");
473 if(0 == lineExpAttr.OverExpCtrl.enable)
474 RKAIQ_IMGPROC_CHECK_RET(ret, "hlc mode is not enabled!");
475 for(int i = 0; i < 6; i++)
476 lineExpAttr.OverExpCtrl.HighLightWeight.fCoeff[i] = (float)strength / 100.0f * lineExpAttr.OverExpCtrl.MaxWeight;
477 ret = rk_aiq_user_api_ae_setLinExpAttr(ctx, lineExpAttr);
478 RKAIQ_IMGPROC_CHECK_RET(ret, "setHLCStrength error!");
479 }
480 IMGPROC_FUNC_EXIT
481 return ret;
482
483 }
484
485 /*
486 *****************************
487 *
488 * Desc: set anti-flicker mode
489 * Argument:
490 * mode
491 *
492 *****************************
493 */
494
rk_aiq_uapi_setAntiFlickerMode(const rk_aiq_sys_ctx_t * ctx,antiFlickerMode_t mode)495 XCamReturn rk_aiq_uapi_setAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx, antiFlickerMode_t mode)
496 {
497 XCamReturn ret = XCAM_RETURN_NO_ERROR;
498 Uapi_ExpSwAttr_t expSwAttr;
499 IMGPROC_FUNC_ENTER
500 if (ctx == NULL) {
501 ret = XCAM_RETURN_ERROR_PARAM;
502 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
503 }
504
505 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
506 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetAntiFlickerMode failed!");
507 if (mode == ANTIFLICKER_AUTO_MODE) {
508 expSwAttr.stAntiFlicker.enable = true;
509 expSwAttr.stAntiFlicker.Mode = AEC_ANTIFLICKER_AUTO_MODE;
510 } else if(mode == ANTIFLICKER_NORMAL_MODE) {
511 expSwAttr.stAntiFlicker.enable = true;
512 expSwAttr.stAntiFlicker.Mode = AEC_ANTIFLICKER_NORMAL_MODE;
513 } else {
514 ret = XCAM_RETURN_ERROR_PARAM;
515 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!");
516 }
517 ret = rk_aiq_user_api_ae_setExpSwAttr(ctx, expSwAttr);
518 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetAntiFlickerMode failed!");
519 IMGPROC_FUNC_EXIT
520 return ret;
521 }
522
rk_aiq_uapi_getAntiFlickerMode(const rk_aiq_sys_ctx_t * ctx,antiFlickerMode_t * mode)523 XCamReturn rk_aiq_uapi_getAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx, antiFlickerMode_t *mode)
524 {
525 XCamReturn ret = XCAM_RETURN_NO_ERROR;
526 Uapi_ExpSwAttr_t expSwAttr;
527 IMGPROC_FUNC_ENTER
528 if (ctx == NULL) {
529 ret = XCAM_RETURN_ERROR_PARAM;
530 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
531 }
532
533 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
534 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetAntiFlickerMode!");
535 if (expSwAttr.stAntiFlicker.Mode == AEC_ANTIFLICKER_AUTO_MODE)
536 *mode = ANTIFLICKER_AUTO_MODE;
537 else if (expSwAttr.stAntiFlicker.Mode == AEC_ANTIFLICKER_NORMAL_MODE)
538 *mode = ANTIFLICKER_NORMAL_MODE;
539 IMGPROC_FUNC_EXIT
540 return ret;
541 }
542
543 /*
544 *****************************
545 *
546 * Desc: set power line frequence
547 * Argument:
548 * freq
549 *
550 *****************************
551 */
rk_aiq_uapi_setExpPwrLineFreqMode(const rk_aiq_sys_ctx_t * ctx,expPwrLineFreq_t freq)552 XCamReturn rk_aiq_uapi_setExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx, expPwrLineFreq_t freq)
553 {
554 XCamReturn ret = XCAM_RETURN_NO_ERROR;
555 Uapi_ExpSwAttr_t expSwAttr;
556 IMGPROC_FUNC_ENTER
557 if (ctx == NULL) {
558 ret = XCAM_RETURN_ERROR_PARAM;
559 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
560 }
561 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
562 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpPwrLineFreqMode failed!");
563 if (freq == EXP_PWR_LINE_FREQ_50HZ) {
564 expSwAttr.stAntiFlicker.enable = true;
565 expSwAttr.stAntiFlicker.Frequency = AEC_FLICKER_FREQUENCY_50HZ;
566 } else if (freq == EXP_PWR_LINE_FREQ_60HZ) {
567 expSwAttr.stAntiFlicker.enable = true;
568 expSwAttr.stAntiFlicker.Frequency = AEC_FLICKER_FREQUENCY_60HZ;
569 } else if (freq == EXP_PWR_LINE_FREQ_DIS) {
570 expSwAttr.stAntiFlicker.enable = true;
571 expSwAttr.stAntiFlicker.Frequency = AEC_FLICKER_FREQUENCY_OFF;
572 } else {
573 ret = XCAM_RETURN_ERROR_PARAM;
574 RKAIQ_IMGPROC_CHECK_RET(ret, "freq is invalid!");
575 }
576 ret = rk_aiq_user_api_ae_setExpSwAttr(ctx, expSwAttr);
577 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpPwrLineFreqMode failed!");
578 IMGPROC_FUNC_EXIT
579 return (ret);
580 }
581
rk_aiq_uapi_getExpPwrLineFreqMode(const rk_aiq_sys_ctx_t * ctx,expPwrLineFreq_t * freq)582 XCamReturn rk_aiq_uapi_getExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx, expPwrLineFreq_t *freq)
583 {
584 XCamReturn ret = XCAM_RETURN_NO_ERROR;
585 Uapi_ExpSwAttr_t expSwAttr;
586 IMGPROC_FUNC_ENTER
587 if (ctx == NULL) {
588 ret = XCAM_RETURN_ERROR_PARAM;
589 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
590 }
591
592 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
593 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpPwrLineFreqMode failed!");
594 if (expSwAttr.stAntiFlicker.Frequency == AEC_FLICKER_FREQUENCY_50HZ) {
595 *freq = EXP_PWR_LINE_FREQ_50HZ;
596 } else if (expSwAttr.stAntiFlicker.Frequency == AEC_FLICKER_FREQUENCY_60HZ) {
597 *freq = EXP_PWR_LINE_FREQ_60HZ;
598 } else if (expSwAttr.stAntiFlicker.Frequency == AEC_FLICKER_FREQUENCY_OFF) {
599 *freq = EXP_PWR_LINE_FREQ_DIS;
600 } else {
601 ret = XCAM_RETURN_ERROR_PARAM;
602 RKAIQ_IMGPROC_CHECK_RET(ret, "freq is invalid!");
603 }
604 IMGPROC_FUNC_EXIT
605 return (ret);
606 }
607
608 /*
609 *****************************
610 *
611 * Desc: set fill light mode
612 * Argument:
613 * mode
614 *
615 *****************************
616 */
rk_aiq_uapi_setFLightMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)617 XCamReturn rk_aiq_uapi_setFLightMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
618 {
619 XCamReturn ret = XCAM_RETURN_NO_ERROR;
620
621 return ret;
622 }
623
rk_aiq_uapi_getFLightMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)624 XCamReturn rk_aiq_uapi_getFLightMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
625 {
626 XCamReturn ret = XCAM_RETURN_NO_ERROR;
627
628 return ret;
629 }
630
631 /*
632 *****************************
633 *
634 * Desc: set maual fill light mode
635 * Argument:
636 * on: 1: on
637 * 0: off
638 *
639 *****************************
640 */
rk_aiq_uapi_setMFLight(const rk_aiq_sys_ctx_t * ctx,bool on)641 XCamReturn rk_aiq_uapi_setMFLight(const rk_aiq_sys_ctx_t* ctx, bool on)
642 {
643 XCamReturn ret = XCAM_RETURN_NO_ERROR;
644
645 return ret;
646 }
647
rk_aiq_uapi_getMFLight(const rk_aiq_sys_ctx_t * ctx,bool * on)648 XCamReturn rk_aiq_uapi_getMFLight(const rk_aiq_sys_ctx_t* ctx, bool *on)
649 {
650 XCamReturn ret = XCAM_RETURN_NO_ERROR;
651
652 return ret;
653 }
654
655
656
657 /*
658 **********************************************************
659 * White balance & Color
660 **********************************************************
661 */
662
663 /*
664 *****************************
665 *
666 * Desc: set white balance mode
667 * Argument:
668 * mode: auto: auto white balance
669 * manual: manual white balance
670 *****************************
671 */
rk_aiq_uapi_setWBMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)672 XCamReturn rk_aiq_uapi_setWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
673 {
674 XCamReturn ret = XCAM_RETURN_NO_ERROR;
675 rk_aiq_wb_attrib_t attr;
676 IMGPROC_FUNC_ENTER
677 if (mode >= OP_INVAL || mode < OP_AUTO) {
678 ret = XCAM_RETURN_ERROR_PARAM;
679 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!");
680 }
681 ret = rk_aiq_user_api_awb_GetAttrib(ctx, &attr);
682 RKAIQ_IMGPROC_CHECK_RET(ret, "setWBMode failed in getting awb attrib!");
683
684 if (mode == OP_AUTO) {
685 attr.mode = RK_AIQ_WB_MODE_AUTO;
686 } else if (mode == OP_MANUAL) {
687 rk_aiq_wb_querry_info_t wb_querry_info;
688 ret = rk_aiq_user_api_awb_QueryWBInfo(ctx, &wb_querry_info);
689 RKAIQ_IMGPROC_CHECK_RET(ret, "setWBMode failed in query info!");
690 attr.mode = RK_AIQ_WB_MODE_MANUAL;
691 attr.stManual.mode = RK_AIQ_MWB_MODE_WBGAIN;
692 attr.stManual.para.gain = wb_querry_info.gain;
693 } else {
694 ret = XCAM_RETURN_ERROR_PARAM;
695 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
696 }
697 ret = rk_aiq_user_api_awb_SetAttrib(ctx, attr);
698 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
699 IMGPROC_FUNC_EXIT
700 return ret;
701 }
702
rk_aiq_uapi_getWBMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)703 XCamReturn rk_aiq_uapi_getWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
704 {
705 XCamReturn ret = XCAM_RETURN_NO_ERROR;
706 rk_aiq_wb_attrib_t attr;
707 IMGPROC_FUNC_ENTER
708 ret = rk_aiq_user_api_awb_GetAttrib(ctx, &attr);
709 RKAIQ_IMGPROC_CHECK_RET(ret, "getWBMode failed!");
710 if (attr.mode == RK_AIQ_WB_MODE_AUTO) {
711 *mode = OP_AUTO;
712 } else if (attr.mode == RK_AIQ_WB_MODE_MANUAL) {
713 *mode = OP_MANUAL;
714 } else {
715 *mode = OP_INVAL;
716 }
717 IMGPROC_FUNC_EXIT
718 return ret;
719 }
720
721
722
723 /*
724 *****************************
725 *
726 * Desc: lock/unlock auto white balance
727 * Argument:
728 *
729 *
730 *****************************
731 */
rk_aiq_uapi_lockAWB(const rk_aiq_sys_ctx_t * ctx)732 XCamReturn rk_aiq_uapi_lockAWB(const rk_aiq_sys_ctx_t* ctx)
733 {
734 XCamReturn ret = XCAM_RETURN_NO_ERROR;
735 IMGPROC_FUNC_ENTER
736 ret = rk_aiq_user_api_awb_Lock(ctx);
737 IMGPROC_FUNC_EXIT
738 return ret;
739 }
740
rk_aiq_uapi_unlockAWB(const rk_aiq_sys_ctx_t * ctx)741 XCamReturn rk_aiq_uapi_unlockAWB(const rk_aiq_sys_ctx_t* ctx)
742 {
743 XCamReturn ret = XCAM_RETURN_NO_ERROR;
744 IMGPROC_FUNC_ENTER
745 ret = rk_aiq_user_api_awb_Unlock(ctx);
746 IMGPROC_FUNC_EXIT
747 return ret;
748 }
749
750 /*
751 *****************************
752 *
753 * Desc: set manual white balance scene mode
754 * Argument:
755 * ct_scene:
756 *
757 *****************************
758 */
rk_aiq_uapi_setMWBScene(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_scene_t scene)759 XCamReturn rk_aiq_uapi_setMWBScene(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_scene_t scene)
760 {
761 XCamReturn ret = XCAM_RETURN_NO_ERROR;
762 rk_aiq_wb_attrib_t attr;
763 IMGPROC_FUNC_ENTER
764 if (ctx == NULL) {
765 ret = XCAM_RETURN_ERROR_PARAM;
766 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBScene failed!");
767 }
768
769 if (scene < RK_AIQ_WBCT_INCANDESCENT || scene > RK_AIQ_WBCT_SHADE) {
770 ret = XCAM_RETURN_ERROR_PARAM;
771 RKAIQ_IMGPROC_CHECK_RET(ret, "invalid scene mode, setMWBScene failed!");
772 }
773
774 ret = rk_aiq_user_api_awb_GetAttrib(ctx, &attr);
775 RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBScene failed!");
776 attr.mode = RK_AIQ_WB_MODE_MANUAL;
777 attr.stManual.mode = RK_AIQ_MWB_MODE_SCENE;
778 attr.stManual.para.scene = scene;
779 ret = rk_aiq_user_api_awb_SetAttrib(ctx, attr);
780 RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBScene failed!");
781 IMGPROC_FUNC_EXIT
782 return ret;
783 }
784
rk_aiq_uapi_getMWBScene(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_scene_t * scene)785 XCamReturn rk_aiq_uapi_getMWBScene(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_scene_t *scene)
786 {
787 XCamReturn ret = XCAM_RETURN_NO_ERROR;
788 rk_aiq_wb_attrib_t attr;
789 IMGPROC_FUNC_ENTER
790 if ((ctx == NULL) || (scene == NULL)) {
791 ret = XCAM_RETURN_ERROR_PARAM;
792 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBScene failed!");
793 }
794 //attr.mode = RK_AIQ_WB_MODE_MANUAL;
795 attr.stManual.mode = RK_AIQ_MWB_MODE_SCENE;
796 ret = rk_aiq_user_api_awb_GetAttrib(ctx, &attr);
797 RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBScene failed!");
798 *scene = attr.stManual.para.scene;
799 IMGPROC_FUNC_EXIT
800 return ret;
801 }
802
803
804 /*
805 *****************************
806 *
807 * Desc: set manual white balance r/b gain
808 * Argument:
809 * ct_scene:
810 *
811 *****************************
812 */
rk_aiq_uapi_setMWBGain(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_gain_t * gain)813 XCamReturn rk_aiq_uapi_setMWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t *gain)
814 {
815 XCamReturn ret = XCAM_RETURN_NO_ERROR;
816 rk_aiq_wb_attrib_t attr;
817 IMGPROC_FUNC_ENTER
818 if ((ctx == NULL) || (gain == NULL)) {
819 ret = XCAM_RETURN_ERROR_PARAM;
820 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBGain failed!");
821 }
822
823 ret = rk_aiq_user_api_awb_GetAttrib(ctx, &attr);
824 RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBGain failed!");
825 attr.mode = RK_AIQ_WB_MODE_MANUAL;
826 attr.stManual.mode = RK_AIQ_MWB_MODE_WBGAIN;
827 attr.stManual.para.gain = *gain;
828 ret = rk_aiq_user_api_awb_SetAttrib(ctx, attr);
829 RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBGain failed!");
830 IMGPROC_FUNC_EXIT
831 return ret;
832 }
833
rk_aiq_uapi_getMWBGain(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_gain_t * gain)834 XCamReturn rk_aiq_uapi_getMWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t *gain)
835 {
836 XCamReturn ret = XCAM_RETURN_NO_ERROR;
837
838 rk_aiq_wb_querry_info_t query_info;
839 IMGPROC_FUNC_ENTER
840 if ((ctx == NULL) || (gain == NULL)) {
841 ret = XCAM_RETURN_ERROR_PARAM;
842 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBGain failed!");
843 }
844 ret = rk_aiq_user_api_awb_QueryWBInfo(ctx, &query_info);
845 RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBGain failed!");
846 *gain = query_info.gain;
847 IMGPROC_FUNC_EXIT
848
849 return ret;
850 }
851
852 /*
853 *****************************
854 *
855 * Desc: set manual white balance color temperature
856 * Argument:
857 * ct: color temperature value [2800, 7500]K
858 *
859 *****************************
860 */
rk_aiq_uapi_setMWBCT(const rk_aiq_sys_ctx_t * ctx,unsigned int ct)861 XCamReturn rk_aiq_uapi_setMWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int ct)
862 {
863 XCamReturn ret = XCAM_RETURN_NO_ERROR;
864 rk_aiq_wb_attrib_t attr;
865 IMGPROC_FUNC_ENTER
866 if (ctx == NULL) {
867 ret = XCAM_RETURN_ERROR_PARAM;
868 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBCT failed!");
869 }
870
871 ret = rk_aiq_user_api_awb_GetAttrib(ctx, &attr);
872 RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBCT failed!");
873 attr.mode = RK_AIQ_WB_MODE_MANUAL;
874 attr.stManual.mode = RK_AIQ_MWB_MODE_CCT;
875 attr.stManual.para.cct.CCT = (float)ct;
876 attr.stManual.para.cct.CCRI = 0.0f;
877 ret = rk_aiq_user_api_awb_SetAttrib(ctx, attr);
878 RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBCT failed!");
879 IMGPROC_FUNC_EXIT
880 return ret;
881
882 }
883
rk_aiq_uapi_getMWBCT(const rk_aiq_sys_ctx_t * ctx,unsigned int * ct)884 XCamReturn rk_aiq_uapi_getMWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int *ct)
885 {
886 XCamReturn ret = XCAM_RETURN_NO_ERROR;
887 rk_aiq_wb_cct_t cct;
888 IMGPROC_FUNC_ENTER
889 if ((ctx == NULL) || (ct == NULL)) {
890 ret = XCAM_RETURN_ERROR_PARAM;
891 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBCT failed!");
892 }
893
894 ret = rk_aiq_user_api_awb_GetCCT(ctx, &cct);
895 RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBCT failed!");
896 *ct = (unsigned int)cct.CCT;
897 IMGPROC_FUNC_EXIT
898 return ret;
899 }
900
901
902 /*
903 *****************************
904 *
905 * Desc: set color supperssion level
906 * Argument:
907 * level: [0, 100]
908 *
909 *****************************
910 */
rk_aiq_uapi_setCrSuppsn(const rk_aiq_sys_ctx_t * ctx,unsigned int level)911 XCamReturn rk_aiq_uapi_setCrSuppsn(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
912 {
913 XCamReturn ret = XCAM_RETURN_NO_ERROR;
914 IMGPROC_FUNC_ENTER
915 #if RKAIQ_HAVE_CCM_V1
916 rk_aiq_ccm_attrib_t ccm;
917 rk_aiq_user_api_accm_GetAttrib(ctx, &ccm);
918 for(int i = 0; i < RK_AIQ_ACCM_COLOR_GAIN_NUM; i++) {
919 ccm.stAuto.color_inhibition.sensorGain[i] = 2.0f;
920 ccm.stAuto.color_inhibition.level[i] = level;
921 }
922 ret = rk_aiq_user_api_accm_SetAttrib(ctx, &ccm);
923 #elif RKAIQ_HAVE_CCM_V2
924 rk_aiq_ccm_v2_attrib_t ccm;
925 rk_aiq_user_api_accm_v2_GetAttrib(ctx, &ccm);
926 for(int i = 0; i < RK_AIQ_ACCM_COLOR_GAIN_NUM; i++) {
927 ccm.stAuto.color_inhibition.sensorGain[i] = 2.0f;
928 ccm.stAuto.color_inhibition.level[i] = level;
929 }
930 ret = rk_aiq_user_api_accm_v2_SetAttrib(ctx, &ccm);
931 #endif
932 RKAIQ_IMGPROC_CHECK_RET(ret, "setCrSuppsn failed!");
933 IMGPROC_FUNC_EXIT
934 return ret;
935 }
936
937
rk_aiq_uapi_getCrSuppsn(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)938 XCamReturn rk_aiq_uapi_getCrSuppsn(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
939 {
940 XCamReturn ret = XCAM_RETURN_NO_ERROR;
941 IMGPROC_FUNC_ENTER
942 rk_aiq_ccm_querry_info_t ccm_querry_info;
943 ret = rk_aiq_user_api_accm_QueryCcmInfo(ctx, &ccm_querry_info);
944 RKAIQ_IMGPROC_CHECK_RET(ret, "getCrSuppsn failed!");
945 *level = (int)ccm_querry_info.color_inhibition_level;
946 IMGPROC_FUNC_EXIT
947 return ret;
948 }
949
950
951 /*
952 **********************************************************
953 * Focus & Zoom
954 **********************************************************
955 */
956 /*
957 *****************************
958 *
959 * Desc: set focus mode
960 * Argument:
961 * mode: auto: auto focus
962 * manual: manual focus
963 * semi-auto: semi-auto focus
964 *****************************
965 */
rk_aiq_uapi_setFocusMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)966 XCamReturn rk_aiq_uapi_setFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
967 {
968 XCamReturn ret = XCAM_RETURN_NO_ERROR;
969
970 rk_aiq_af_attrib_t attr;
971 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
972 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMode failed!");
973 if (mode == OP_AUTO) {
974 attr.AfMode = RKAIQ_AF_MODE_CONTINUOUS_PICTURE;
975 } else if (mode == OP_MANUAL) {
976 attr.AfMode = RKAIQ_AF_MODE_FIXED;
977 } else if (mode == OP_SEMI_AUTO) {
978 attr.AfMode = RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM;
979 } else {
980 ret = XCAM_RETURN_ERROR_PARAM;
981 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
982 }
983
984 ret = rk_aiq_user_api_af_SetAttrib(ctx, &attr);
985 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMode failed!");
986 return ret;
987 }
988
rk_aiq_uapi_getFocusMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)989 XCamReturn rk_aiq_uapi_getFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
990 {
991 XCamReturn ret = XCAM_RETURN_NO_ERROR;
992
993 rk_aiq_af_attrib_t attr;
994 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
995 RKAIQ_IMGPROC_CHECK_RET(ret, "getFocusMode failed!");
996 if (attr.AfMode == RKAIQ_AF_MODE_FIXED) {
997 *mode = OP_MANUAL;
998 } else if (attr.AfMode == RKAIQ_AF_MODE_NOT_SET) {
999 *mode = OP_INVAL;
1000 } else if (attr.AfMode == RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM) {
1001 *mode = OP_SEMI_AUTO;
1002 } else {
1003 *mode = OP_AUTO;
1004 }
1005
1006 return ret;
1007 }
1008
1009 /*
1010 *****************************
1011 *
1012 * Desc: set fixed mode code
1013 * Argument:
1014 *
1015 *****************************
1016 */
rk_aiq_uapi_setFixedModeCode(const rk_aiq_sys_ctx_t * ctx,short code)1017 XCamReturn rk_aiq_uapi_setFixedModeCode(const rk_aiq_sys_ctx_t* ctx, short code)
1018 {
1019 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1020 rk_aiq_af_attrib_t attr;
1021
1022 IMGPROC_FUNC_ENTER
1023 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
1024 RKAIQ_IMGPROC_CHECK_RET(ret, "setFixedModeCode failed!");
1025 attr.fixedModeDefCode = code;
1026 ret = rk_aiq_user_api_af_SetAttrib(ctx, &attr);
1027 RKAIQ_IMGPROC_CHECK_RET(ret, "setFixedModeCode failed!");
1028 IMGPROC_FUNC_EXIT
1029 return ret;
1030 }
1031
rk_aiq_uapi_getFixedModeCode(const rk_aiq_sys_ctx_t * ctx,short * code)1032 XCamReturn rk_aiq_uapi_getFixedModeCode(const rk_aiq_sys_ctx_t* ctx, short *code)
1033 {
1034 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1035 rk_aiq_af_attrib_t attr;
1036 IMGPROC_FUNC_ENTER
1037 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
1038 RKAIQ_IMGPROC_CHECK_RET(ret, "getFixedModeCode failed!");
1039 *code = attr.fixedModeDefCode;
1040 IMGPROC_FUNC_EXIT
1041 return ret;
1042 }
1043
1044 /*
1045 *****************************
1046 *
1047 * Desc: set focus window
1048 * Argument:
1049 *
1050 *****************************
1051 */
1052
rk_aiq_uapi_setFocusWin(const rk_aiq_sys_ctx_t * ctx,paRect_t * rect)1053 XCamReturn rk_aiq_uapi_setFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect)
1054 {
1055 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1056 rk_aiq_af_attrib_t attr;
1057 IMGPROC_FUNC_ENTER
1058 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
1059 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusWin failed!");
1060
1061 attr.h_offs = rect->x;
1062 attr.v_offs = rect->y;
1063 attr.h_size = rect->w;
1064 attr.v_size = rect->h;
1065 ret = rk_aiq_user_api_af_SetAttrib(ctx, &attr);
1066 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusWin failed!");
1067 IMGPROC_FUNC_EXIT
1068 return ret;
1069 }
1070
rk_aiq_uapi_getFocusWin(const rk_aiq_sys_ctx_t * ctx,paRect_t * rect)1071 XCamReturn rk_aiq_uapi_getFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect)
1072 {
1073 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1074 rk_aiq_af_attrib_t attr;
1075 IMGPROC_FUNC_ENTER
1076 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
1077 RKAIQ_IMGPROC_CHECK_RET(ret, "getFocusWin failed!");
1078
1079 rect->x = attr.h_offs;
1080 rect->y = attr.v_offs;
1081 rect->w = attr.h_size;
1082 rect->h = attr.v_size;
1083 IMGPROC_FUNC_EXIT
1084 return ret;
1085 }
1086
1087 /*
1088 *****************************
1089 *
1090 * Desc: set focus meas config
1091 * Argument:
1092 *
1093 *****************************
1094 */
rk_aiq_uapi_setFocusMeasCfg(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_algo_meas_t * meascfg)1095 XCamReturn rk_aiq_uapi_setFocusMeasCfg(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_algo_meas_t* meascfg)
1096 {
1097 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1098
1099 rk_aiq_af_attrib_t attr;
1100 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
1101 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMeasCfg failed!");
1102 attr.manual_meascfg = *meascfg;
1103
1104 ret = rk_aiq_user_api_af_SetAttrib(ctx, &attr);
1105 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMeasCfg failed!");
1106 return ret;
1107 }
1108
rk_aiq_uapi_getFocusMeasCfg(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_algo_meas_t * meascfg)1109 XCamReturn rk_aiq_uapi_getFocusMeasCfg(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_algo_meas_t* meascfg)
1110 {
1111 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1112
1113 rk_aiq_af_attrib_t attr;
1114 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
1115 RKAIQ_IMGPROC_CHECK_RET(ret, "getFocusMeasCfg failed!");
1116 *meascfg = attr.manual_meascfg;
1117
1118 return ret;
1119 }
1120
rk_aiq_uapi_lockFocus(const rk_aiq_sys_ctx_t * ctx)1121 XCamReturn rk_aiq_uapi_lockFocus(const rk_aiq_sys_ctx_t* ctx)
1122 {
1123 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1124 IMGPROC_FUNC_ENTER
1125 ret = rk_aiq_user_api_af_Lock(ctx);
1126 IMGPROC_FUNC_EXIT
1127 return ret;
1128 }
1129
rk_aiq_uapi_unlockFocus(const rk_aiq_sys_ctx_t * ctx)1130 XCamReturn rk_aiq_uapi_unlockFocus(const rk_aiq_sys_ctx_t* ctx)
1131 {
1132 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1133 IMGPROC_FUNC_ENTER
1134 ret = rk_aiq_user_api_af_Unlock(ctx);
1135 IMGPROC_FUNC_EXIT
1136 return ret;
1137 }
1138
rk_aiq_uapi_oneshotFocus(const rk_aiq_sys_ctx_t * ctx)1139 XCamReturn rk_aiq_uapi_oneshotFocus(const rk_aiq_sys_ctx_t* ctx)
1140 {
1141 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1142 IMGPROC_FUNC_ENTER
1143 ret = rk_aiq_user_api_af_Oneshot(ctx);
1144 IMGPROC_FUNC_EXIT
1145 return ret;
1146 }
1147
rk_aiq_uapi_manualTrigerFocus(const rk_aiq_sys_ctx_t * ctx)1148 XCamReturn rk_aiq_uapi_manualTrigerFocus(const rk_aiq_sys_ctx_t* ctx)
1149 {
1150 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1151 IMGPROC_FUNC_ENTER
1152 ret = rk_aiq_user_api_af_ManualTriger(ctx);
1153 IMGPROC_FUNC_EXIT
1154 return ret;
1155 }
1156
rk_aiq_uapi_trackingFocus(const rk_aiq_sys_ctx_t * ctx)1157 XCamReturn rk_aiq_uapi_trackingFocus(const rk_aiq_sys_ctx_t* ctx)
1158 {
1159 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1160 IMGPROC_FUNC_ENTER
1161 ret = rk_aiq_user_api_af_Tracking(ctx);
1162 IMGPROC_FUNC_EXIT
1163 return ret;
1164 }
1165
rk_aiq_uapi_setVcmCfg(const rk_aiq_sys_ctx_t * ctx,rk_aiq_lens_vcmcfg * cfg)1166 XCamReturn rk_aiq_uapi_setVcmCfg(const rk_aiq_sys_ctx_t* ctx, rk_aiq_lens_vcmcfg* cfg)
1167 {
1168 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1169 IMGPROC_FUNC_ENTER
1170 ret = rk_aiq_user_api_af_SetVcmCfg(ctx, cfg);
1171 IMGPROC_FUNC_EXIT
1172
1173 return ret;
1174 }
1175
rk_aiq_uapi_getVcmCfg(const rk_aiq_sys_ctx_t * ctx,rk_aiq_lens_vcmcfg * cfg)1176 XCamReturn rk_aiq_uapi_getVcmCfg(const rk_aiq_sys_ctx_t* ctx, rk_aiq_lens_vcmcfg* cfg)
1177 {
1178 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1179 IMGPROC_FUNC_ENTER
1180 ret = rk_aiq_user_api_af_GetVcmCfg(ctx, cfg);
1181 IMGPROC_FUNC_EXIT
1182
1183 return ret;
1184 }
1185
rk_aiq_uapi_getSearchPath(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_sec_path_t * path)1186 XCamReturn rk_aiq_uapi_getSearchPath(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_sec_path_t* path)
1187 {
1188 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1189 IMGPROC_FUNC_ENTER
1190 ret = rk_aiq_user_api_af_GetSearchPath(ctx, path);
1191 IMGPROC_FUNC_EXIT
1192
1193 return ret;
1194 }
1195
rk_aiq_uapi_getSearchResult(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_result_t * result)1196 XCamReturn rk_aiq_uapi_getSearchResult(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_result_t* result)
1197 {
1198 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1199
1200 IMGPROC_FUNC_ENTER
1201 ret = rk_aiq_user_api_af_GetSearchResult(ctx, result);
1202 IMGPROC_FUNC_EXIT
1203
1204 return ret;
1205 }
1206
rk_aiq_uapi_setOpZoomPosition(const rk_aiq_sys_ctx_t * ctx,int pos)1207 XCamReturn rk_aiq_uapi_setOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int pos)
1208 {
1209 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1210 IMGPROC_FUNC_ENTER
1211 ret = rk_aiq_user_api_af_SetZoomIndex(ctx, pos);
1212 IMGPROC_FUNC_EXIT
1213
1214 return ret;
1215 }
1216
rk_aiq_uapi_getOpZoomPosition(const rk_aiq_sys_ctx_t * ctx,int * pos)1217 XCamReturn rk_aiq_uapi_getOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int *pos)
1218 {
1219 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1220 IMGPROC_FUNC_ENTER
1221 ret = rk_aiq_user_api_af_GetZoomIndex(ctx, pos);
1222 IMGPROC_FUNC_EXIT
1223
1224 return ret;
1225 }
1226
rk_aiq_uapi_endOpZoomChange(const rk_aiq_sys_ctx_t * ctx)1227 XCamReturn rk_aiq_uapi_endOpZoomChange(const rk_aiq_sys_ctx_t* ctx)
1228 {
1229 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1230
1231 IMGPROC_FUNC_ENTER
1232 ret = rk_aiq_user_api_af_EndZoomChg(ctx);
1233 IMGPROC_FUNC_EXIT
1234
1235 return ret;
1236 }
1237
rk_aiq_uapi_getZoomRange(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_zoomrange * range)1238 XCamReturn rk_aiq_uapi_getZoomRange(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_zoomrange * range)
1239 {
1240 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1241 IMGPROC_FUNC_ENTER
1242 ret = rk_aiq_user_api_af_GetZoomRange(ctx, range);
1243 IMGPROC_FUNC_EXIT
1244
1245 return ret;
1246 }
1247
rk_aiq_uapi_getFocusRange(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_focusrange * range)1248 XCamReturn rk_aiq_uapi_getFocusRange(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_focusrange* range)
1249 {
1250 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1251 IMGPROC_FUNC_ENTER
1252 ret = rk_aiq_user_api_af_GetFocusRange(ctx, range);
1253 IMGPROC_FUNC_EXIT
1254
1255 return ret;
1256 }
1257
rk_aiq_uapi_startZoomCalib(const rk_aiq_sys_ctx_t * ctx)1258 XCamReturn rk_aiq_uapi_startZoomCalib(const rk_aiq_sys_ctx_t* ctx)
1259 {
1260 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1261 IMGPROC_FUNC_ENTER
1262 ret = rk_aiq_user_api_af_StartZoomCalib(ctx);
1263 IMGPROC_FUNC_EXIT
1264
1265 return ret;
1266 }
1267
rk_aiq_uapi_resetZoom(const rk_aiq_sys_ctx_t * ctx)1268 XCamReturn rk_aiq_uapi_resetZoom(const rk_aiq_sys_ctx_t* ctx)
1269 {
1270 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1271 IMGPROC_FUNC_ENTER
1272 ret = rk_aiq_user_api_af_resetZoom(ctx);
1273 IMGPROC_FUNC_EXIT
1274
1275 return ret;
1276 }
1277
rk_aiq_uapi_setAngleZ(const rk_aiq_sys_ctx_t * ctx,float angleZ)1278 XCamReturn rk_aiq_uapi_setAngleZ(const rk_aiq_sys_ctx_t* ctx, float angleZ)
1279 {
1280 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1281 IMGPROC_FUNC_ENTER
1282 ret = rk_aiq_user_api_af_setAngleZ(ctx, angleZ);
1283 IMGPROC_FUNC_EXIT
1284
1285 return ret;
1286 }
1287
1288 /*
1289 *****************************
1290 *
1291 * Desc: set minimum focus distance
1292 * Argument:
1293 * disrance: unint is cm
1294 *****************************
1295 */
rk_aiq_uapi_setMinFocusDis(const rk_aiq_sys_ctx_t * ctx,unsigned int distance)1296 XCamReturn rk_aiq_uapi_setMinFocusDis(const rk_aiq_sys_ctx_t* ctx, unsigned int distance)
1297 {
1298 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1299
1300 return ret;
1301 }
1302
rk_aiq_uapi_getMinFocusDis(const rk_aiq_sys_ctx_t * ctx,unsigned int * distance)1303 XCamReturn rk_aiq_uapi_getMinFocusDis(const rk_aiq_sys_ctx_t* ctx, unsigned int *distance)
1304 {
1305 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1306
1307 return ret;
1308 }
1309
1310
1311 /*
1312 *****************************
1313 *
1314 * Desc: set optical zoom range
1315 * Argument:
1316 * range: [1.0, 100.0]
1317 *
1318 *****************************
1319 */
rk_aiq_uapi_setOpZoomRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * range)1320 XCamReturn rk_aiq_uapi_setOpZoomRange(const rk_aiq_sys_ctx_t* ctx, paRange_t *range)
1321 {
1322 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1323 return ret;
1324 }
1325
rk_aiq_uapi_getOpZoomRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * range)1326 XCamReturn rk_aiq_uapi_getOpZoomRange(const rk_aiq_sys_ctx_t* ctx, paRange_t *range)
1327 {
1328 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1329
1330 return ret;
1331 }
1332
1333 /*
1334 *****************************
1335 *
1336 * Desc: set optical zoom speed
1337 * Argument:
1338 * level: [1, 10]
1339 *
1340 *****************************
1341 */
rk_aiq_uapi_setOpZoomSpeed(const rk_aiq_sys_ctx_t * ctx,unsigned int level)1342 XCamReturn rk_aiq_uapi_setOpZoomSpeed(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
1343 {
1344 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1345
1346 return ret;
1347 }
1348
rk_aiq_uapi_getOpZoomSpeed(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)1349 XCamReturn rk_aiq_uapi_getOpZoomSpeed(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
1350 {
1351 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1352
1353 return ret;
1354 }
1355
1356 /*
1357 **********************************************************
1358 * Noise reduction
1359 **********************************************************
1360 */
1361 /*
1362 *****************************
1363 *
1364 * Desc: set noise reduction mode
1365 * Argument:
1366 * mode:
1367 * auto: auto noise reduction
1368 * manual锛歮anual noise reduction
1369 *
1370 *****************************
1371 */
rk_aiq_uapi_setNRMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)1372 XCamReturn rk_aiq_uapi_setNRMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
1373 {
1374 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1375
1376 IMGPROC_FUNC_ENTER
1377
1378 if (CHECK_ISP_HW_V20()) {
1379 rk_aiq_nr_attrib_t attr;
1380 ret = rk_aiq_user_api_anr_GetAttrib(ctx, &attr);
1381 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1382 if (mode == OP_AUTO) {
1383 attr.eMode = ANR_OP_MODE_AUTO;
1384 } else if (mode == OP_MANUAL) {
1385 attr.eMode = ANR_OP_MODE_MANUAL;
1386 } else {
1387 ret = XCAM_RETURN_ERROR_PARAM;
1388 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
1389 }
1390 ret = rk_aiq_user_api_anr_SetAttrib(ctx, &attr);
1391 }
1392
1393 if (CHECK_ISP_HW_V21()) {
1394 rk_aiq_ynr_attrib_v2_t ynrV2_attr;
1395 rk_aiq_bayernr_attrib_v2_t bayernrV2_attr;
1396 rk_aiq_cnr_attrib_v1_t cnrV1_attr;
1397 ret = rk_aiq_user_api_aynrV2_GetAttrib(ctx, &ynrV2_attr);
1398 ret = rk_aiq_user_api_abayernrV2_GetAttrib(ctx, &bayernrV2_attr);
1399 ret = rk_aiq_user_api_acnrV1_GetAttrib(ctx, &cnrV1_attr);
1400 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1401 if (mode == OP_AUTO) {
1402 bayernrV2_attr.eMode = ABAYERNR_OP_MODE_AUTO;
1403 ynrV2_attr.eMode = AYNR_OP_MODE_AUTO;
1404 cnrV1_attr.eMode = ACNR_OP_MODE_AUTO;
1405 } else if (mode == OP_MANUAL) {
1406 bayernrV2_attr.eMode = ABAYERNR_OP_MODE_MANUAL;
1407 ynrV2_attr.eMode = AYNR_OP_MODE_MANUAL;
1408 cnrV1_attr.eMode = ACNR_OP_MODE_MANUAL;
1409 } else {
1410 ret = XCAM_RETURN_ERROR_PARAM;
1411 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
1412 }
1413 ret = rk_aiq_user_api_aynrV2_SetAttrib(ctx, &ynrV2_attr);
1414 ret = rk_aiq_user_api_abayernrV2_SetAttrib(ctx, &bayernrV2_attr);
1415 ret = rk_aiq_user_api_acnrV1_SetAttrib(ctx, &cnrV1_attr);
1416 }
1417
1418
1419 if (CHECK_ISP_HW_V30()) {
1420 rk_aiq_ynr_attrib_v3_t ynrV3_attr;
1421 ynrV3_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1422 rk_aiq_cnr_attrib_v2_t cnrV2_attr;
1423 cnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1424 rk_aiq_bayer2dnr_attrib_v2_t bayer2dnrV2_attr;
1425 bayer2dnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1426 rk_aiq_bayertnr_attrib_v2_t bayertnrV2_attr;
1427 bayertnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1428 ret = rk_aiq_user_api_aynrV3_GetAttrib(ctx, &ynrV3_attr);
1429 ret = rk_aiq_user_api_acnrV2_GetAttrib(ctx, &cnrV2_attr);
1430 ret = rk_aiq_user_api_abayer2dnrV2_SetAttrib(ctx, &bayer2dnrV2_attr);
1431 ret = rk_aiq_user_api_abayertnrV2_SetAttrib(ctx, &bayertnrV2_attr);
1432 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1433
1434 if (mode == OP_AUTO) {
1435 ynrV3_attr.eMode = AYNRV3_OP_MODE_AUTO;
1436 cnrV2_attr.eMode = ACNRV2_OP_MODE_AUTO;
1437 bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_AUTO;
1438 bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_AUTO;
1439 } else if (mode == OP_MANUAL) {
1440 ynrV3_attr.eMode = AYNRV3_OP_MODE_MANUAL;
1441 cnrV2_attr.eMode = ACNRV2_OP_MODE_MANUAL;
1442 bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_MANUAL;
1443 bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_MANUAL;
1444 } else if(mode == OP_REG_MANUAL) {
1445 ynrV3_attr.eMode = AYNRV3_OP_MODE_REG_MANUAL;
1446 cnrV2_attr.eMode = ACNRV2_OP_MODE_REG_MANUAL;
1447 bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_REG_MANUAL;
1448 bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_REG_MANUAL;
1449 } else {
1450 ret = XCAM_RETURN_ERROR_PARAM;
1451 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
1452 }
1453 ret = rk_aiq_user_api_aynrV3_SetAttrib(ctx, &ynrV3_attr);
1454 ret = rk_aiq_user_api_acnrV2_SetAttrib(ctx, &cnrV2_attr);
1455 ret = rk_aiq_user_api_abayer2dnrV2_SetAttrib(ctx, &bayer2dnrV2_attr);
1456 ret = rk_aiq_user_api_abayertnrV2_SetAttrib(ctx, &bayertnrV2_attr);
1457 }
1458
1459
1460 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1461 rk_aiq_ynr_attrib_v22_t ynrV22_attr;
1462 ynrV22_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1463 rk_aiq_cnr_attrib_v30_t cnrV30_attr;
1464 cnrV30_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1465 rk_aiq_bayer2dnr_attrib_v23_t bayer2dnrV23_attr;
1466 bayer2dnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1467 rk_aiq_bayertnr_attrib_v23_t bayertnrV23_attr;
1468 bayertnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1469 ret = rk_aiq_user_api_aynrV22_GetAttrib(ctx, &ynrV22_attr);
1470 ret = rk_aiq_user_api_acnrV30_GetAttrib(ctx, &cnrV30_attr);
1471 ret = rk_aiq_user_api_abayer2dnrV23_GetAttrib(ctx, &bayer2dnrV23_attr);
1472 ret = rk_aiq_user_api_abayertnrV23_GetAttrib(ctx, &bayertnrV23_attr);
1473 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1474
1475 if (mode == OP_AUTO) {
1476 ynrV22_attr.eMode = AYNRV22_OP_MODE_AUTO;
1477 cnrV30_attr.eMode = ACNRV30_OP_MODE_AUTO;
1478 bayer2dnrV23_attr.eMode = ABAYER2DNR_V23_OP_MODE_AUTO;
1479 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_AUTO;
1480 } else if (mode == OP_MANUAL) {
1481 ynrV22_attr.eMode = AYNRV22_OP_MODE_MANUAL;
1482 cnrV30_attr.eMode = ACNRV30_OP_MODE_MANUAL;
1483 bayer2dnrV23_attr.eMode = ABAYER2DNR_V23_OP_MODE_MANUAL;
1484 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_MANUAL;
1485 } else if(mode == OP_REG_MANUAL) {
1486 ynrV22_attr.eMode = AYNRV22_OP_MODE_REG_MANUAL;
1487 cnrV30_attr.eMode = ACNRV30_OP_MODE_REG_MANUAL;
1488 bayer2dnrV23_attr.eMode = ABAYER2DNR_V23_OP_MODE_REG_MANUAL;
1489 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_REG_MANUAL;
1490 } else {
1491 ret = XCAM_RETURN_ERROR_PARAM;
1492 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
1493 }
1494 ret = rk_aiq_user_api_aynrV22_SetAttrib(ctx, &ynrV22_attr);
1495 ret = rk_aiq_user_api_acnrV30_SetAttrib(ctx, &cnrV30_attr);
1496 ret = rk_aiq_user_api_abayer2dnrV23_SetAttrib(ctx, &bayer2dnrV23_attr);
1497 ret = rk_aiq_user_api_abayertnrV23_SetAttrib(ctx, &bayertnrV23_attr);
1498 }
1499 RKAIQ_IMGPROC_CHECK_RET(ret, "setNRMode failed!", ret);
1500 IMGPROC_FUNC_EXIT
1501
1502 return ret;
1503 }
1504
rk_aiq_uapi_getNRMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)1505 XCamReturn rk_aiq_uapi_getNRMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
1506 {
1507 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1508 IMGPROC_FUNC_ENTER
1509
1510 if (CHECK_ISP_HW_V20()) {
1511 rk_aiq_nr_attrib_t attr;
1512 ret = rk_aiq_user_api_anr_GetAttrib(ctx, &attr);
1513 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1514 if (attr.eMode == ANR_OP_MODE_AUTO) {
1515 *mode = OP_AUTO;
1516 } else if (attr.eMode == ANR_OP_MODE_MANUAL) {
1517 *mode = OP_MANUAL;
1518 } else if (attr.eMode == ANR_OP_MODE_INVALID) {
1519 *mode = OP_INVAL;
1520 }
1521 }
1522
1523 if (CHECK_ISP_HW_V21()) {
1524 rk_aiq_ynr_attrib_v2_t ynrV2_attr;
1525 rk_aiq_bayernr_attrib_v2_t bayernrV2_attr;
1526 rk_aiq_cnr_attrib_v1_t cnrV1_attr;
1527 ret = rk_aiq_user_api_aynrV2_GetAttrib(ctx, &ynrV2_attr);
1528 ret = rk_aiq_user_api_abayernrV2_GetAttrib(ctx, &bayernrV2_attr);
1529 ret = rk_aiq_user_api_acnrV1_GetAttrib(ctx, &cnrV1_attr);
1530 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1531
1532 if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_AUTO
1533 && ynrV2_attr.eMode == AYNR_OP_MODE_AUTO
1534 && cnrV1_attr.eMode == ACNR_OP_MODE_AUTO) {
1535 *mode = OP_AUTO;
1536 } else if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_MANUAL
1537 && ynrV2_attr.eMode == AYNR_OP_MODE_MANUAL
1538 && cnrV1_attr.eMode == ACNR_OP_MODE_MANUAL) {
1539 *mode = OP_MANUAL;
1540 } else if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_INVALID
1541 && ynrV2_attr.eMode == AYNR_OP_MODE_INVALID
1542 && cnrV1_attr.eMode == ACNR_OP_MODE_INVALID) {
1543 *mode = OP_INVAL;
1544 } else {
1545 LOGE_ANR("bayernr.mode:%d ynr.mode:%d cnr.mode:%d\n",
1546 bayernrV2_attr.eMode,
1547 ynrV2_attr.eMode,
1548 cnrV1_attr.eMode);
1549 }
1550
1551 }
1552
1553
1554 if (CHECK_ISP_HW_V30()) {
1555 rk_aiq_ynr_attrib_v3_t ynrV3_attr;
1556 ynrV3_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1557 rk_aiq_cnr_attrib_v2_t cnrV2_attr;
1558 cnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1559 rk_aiq_bayer2dnr_attrib_v2_t bayer2dnrV2_attr;
1560 bayer2dnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1561 rk_aiq_bayertnr_attrib_v2_t bayertnrV2_attr;
1562 bayertnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1563 ret = rk_aiq_user_api_aynrV3_GetAttrib(ctx, &ynrV3_attr);
1564 ret = rk_aiq_user_api_acnrV2_GetAttrib(ctx, &cnrV2_attr);
1565 ret = rk_aiq_user_api_abayer2dnrV2_GetAttrib(ctx, &bayer2dnrV2_attr);
1566 ret = rk_aiq_user_api_abayertnrV2_GetAttrib(ctx, &bayertnrV2_attr);
1567 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1568
1569 if(ynrV3_attr.eMode == AYNRV3_OP_MODE_AUTO
1570 && cnrV2_attr.eMode == ACNRV2_OP_MODE_AUTO
1571 && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_AUTO
1572 && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_AUTO) {
1573 *mode = OP_AUTO;
1574 } else if(ynrV3_attr.eMode == AYNRV3_OP_MODE_MANUAL
1575 && cnrV2_attr.eMode == ACNRV2_OP_MODE_MANUAL
1576 && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_MANUAL
1577 && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_MANUAL) {
1578 *mode = OP_MANUAL;
1579 } else if(ynrV3_attr.eMode == AYNRV3_OP_MODE_REG_MANUAL
1580 && cnrV2_attr.eMode == ACNRV2_OP_MODE_REG_MANUAL
1581 && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_REG_MANUAL
1582 && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_REG_MANUAL) {
1583 *mode = OP_REG_MANUAL;
1584 } else {
1585 LOGE_ANR("bayer2dnr.mode:%d bayertnr.mode:%d ynr.mode:%d cnr.mode:%d\n",
1586 bayer2dnrV2_attr.eMode,
1587 bayertnrV2_attr.eMode,
1588 ynrV3_attr.eMode,
1589 cnrV2_attr.eMode);
1590 }
1591 }
1592
1593 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1594 rk_aiq_ynr_attrib_v22_t ynrV22_attr;
1595 ynrV22_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1596 rk_aiq_cnr_attrib_v30_t cnrV30_attr;
1597 cnrV30_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1598 rk_aiq_bayer2dnr_attrib_v23_t bayer2dnrV23_attr;
1599 bayer2dnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1600 rk_aiq_bayertnr_attrib_v23_t bayertnrV23_attr;
1601 bayertnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1602 ret = rk_aiq_user_api_aynrV22_GetAttrib(ctx, &ynrV22_attr);
1603 ret = rk_aiq_user_api_acnrV30_GetAttrib(ctx, &cnrV30_attr);
1604 ret = rk_aiq_user_api_abayer2dnrV23_GetAttrib(ctx, &bayer2dnrV23_attr);
1605 ret = rk_aiq_user_api_abayertnrV23_GetAttrib(ctx, &bayertnrV23_attr);
1606 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
1607
1608 if(ynrV22_attr.eMode == AYNRV22_OP_MODE_AUTO
1609 && cnrV30_attr.eMode == ACNRV30_OP_MODE_AUTO
1610 && bayer2dnrV23_attr.eMode == ABAYER2DNR_V23_OP_MODE_AUTO
1611 && bayertnrV23_attr.eMode == ABAYERTNRV23_OP_MODE_AUTO) {
1612 *mode = OP_AUTO;
1613 } else if(ynrV22_attr.eMode == AYNRV22_OP_MODE_MANUAL
1614 && cnrV30_attr.eMode == ACNRV30_OP_MODE_MANUAL
1615 && bayer2dnrV23_attr.eMode == ABAYER2DNR_V23_OP_MODE_MANUAL
1616 && bayertnrV23_attr.eMode == ABAYERTNRV23_OP_MODE_MANUAL) {
1617 *mode = OP_MANUAL;
1618 } else if(ynrV22_attr.eMode == AYNRV22_OP_MODE_REG_MANUAL
1619 && cnrV30_attr.eMode == ACNRV30_OP_MODE_REG_MANUAL
1620 && bayer2dnrV23_attr.eMode == ABAYER2DNR_V23_OP_MODE_REG_MANUAL
1621 && bayertnrV23_attr.eMode == ABAYERTNRV23_OP_MODE_REG_MANUAL) {
1622 *mode = OP_REG_MANUAL;
1623 } else {
1624 LOGE_ANR("ynr.mode:%d cnr.mode:%d bayer2dnr.mode:%d bayertnr.mode:%d\n",
1625 ynrV22_attr.eMode,
1626 cnrV30_attr.eMode,
1627 bayer2dnrV23_attr.eMode,
1628 bayertnrV23_attr.eMode);
1629 }
1630 }
1631
1632 IMGPROC_FUNC_EXIT
1633 return ret;
1634 }
1635
1636 /*
1637 *****************************
1638 *
1639 * Desc: set normal noise reduction strength
1640 * Argument:
1641 * level: [0, 100]
1642 * Normal mode
1643 *****************************
1644 */
rk_aiq_uapi_setANRStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int level)1645 XCamReturn rk_aiq_uapi_setANRStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
1646 {
1647 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1648
1649 IMGPROC_FUNC_ENTER
1650
1651 if (ctx == NULL) {
1652 ret = XCAM_RETURN_ERROR_PARAM;
1653 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setANRStrth failed!");
1654 }
1655
1656 if (CHECK_ISP_HW_V20()) {
1657 ret = rk_aiq_user_api_anr_SetLumaSFStrength(ctx, level / 100.0);
1658 ret = rk_aiq_user_api_anr_SetLumaTFStrength(ctx, level / 100.0);
1659 RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret);
1660 }
1661
1662 if (CHECK_ISP_HW_V21()) {
1663 ret = rk_aiq_user_api_aynrV2_SetStrength(ctx, level / 100.0);
1664 ret = rk_aiq_user_api_abayernrV2_SetSFStrength(ctx, level / 100.0);
1665 ret = rk_aiq_user_api_abayernrV2_SetTFStrength(ctx, level / 100.0);
1666 RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret);
1667 }
1668
1669 if (CHECK_ISP_HW_V30()) {
1670 rk_aiq_uapi_sync_t sync;
1671 sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1672 rk_aiq_ynr_strength_v3_t ynrStrenght;
1673 ynrStrenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1674 ynrStrenght.strength_enable = true;
1675 ynrStrenght.percent = level / 100.0;
1676 ret = rk_aiq_user_api_aynrV3_SetStrength(ctx, &ynrStrenght);
1677 rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght;
1678 bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1679 bayer2dnrV2Strenght.strength_enable = true;
1680 bayer2dnrV2Strenght.percent = level / 100.0;
1681 ret = rk_aiq_user_api_abayer2dnrV2_SetStrength(ctx, &bayer2dnrV2Strenght);
1682 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
1683 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1684 bayertnrV2Strenght.strength_enable = true;
1685 bayertnrV2Strenght.percent = level / 100.0;
1686 ret = rk_aiq_user_api_abayertnrV2_SetStrength(ctx, &bayertnrV2Strenght);
1687 }
1688
1689 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1690 rk_aiq_ynr_strength_v22_t ynrV22Strength;
1691 ynrV22Strength.strength_enable = true;
1692 ynrV22Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1693 ynrV22Strength.percent = level / 100.0;
1694 ret = rk_aiq_user_api_aynrV22_SetStrength(ctx, &ynrV22Strength);
1695 rk_aiq_bayer2dnr_strength_v23_t bayer2dnrV23Strength;
1696 bayer2dnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1697 bayer2dnrV23Strength.strength_enable = true;
1698 bayer2dnrV23Strength.percent = level / 100.0;
1699 ret = rk_aiq_user_api_abayer2dnrV23_SetStrength(ctx, &bayer2dnrV23Strength);
1700 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
1701 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1702 bayertnrV23Strength.strength_enable = true;
1703 bayertnrV23Strength.percent = level / 100.0;
1704 ret = rk_aiq_user_api_abayertnrV23_SetStrength(ctx, &bayertnrV23Strength);
1705 RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret);
1706 }
1707 IMGPROC_FUNC_EXIT
1708 return ret;
1709 }
1710
rk_aiq_uapi_getANRStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)1711 XCamReturn rk_aiq_uapi_getANRStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
1712 {
1713 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1714 float percent = 0.0f;
1715
1716 IMGPROC_FUNC_ENTER
1717
1718 if (ctx == NULL) {
1719 ret = XCAM_RETURN_ERROR_PARAM;
1720 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getANRStrth failed!");
1721 }
1722
1723 if (CHECK_ISP_HW_V20()) {
1724 ret = rk_aiq_user_api_anr_GetLumaTFStrength(ctx, &percent);
1725 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
1726 *level = (unsigned int)(percent * 100);
1727 }
1728
1729 if (CHECK_ISP_HW_V21()) {
1730 ret = rk_aiq_user_api_abayernrV2_GetTFStrength(ctx, &percent);
1731 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
1732 *level = (unsigned int)(percent * 100);
1733 }
1734
1735 if (CHECK_ISP_HW_V30()) {
1736 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
1737 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1738 ret = rk_aiq_user_api_abayertnrV2_GetStrength(ctx, &bayertnrV2Strenght);
1739 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
1740 percent = bayertnrV2Strenght.percent;
1741 *level = (unsigned int)(percent * 100);
1742 }
1743
1744 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1745 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
1746 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1747 ret = rk_aiq_user_api_abayertnrV23_GetStrength(ctx, &bayertnrV23Strength);
1748 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
1749 *level = (unsigned int)(bayertnrV23Strength.percent * 100);
1750 }
1751
1752 IMGPROC_FUNC_EXIT
1753 return ret;
1754 }
1755
1756 /*
1757 *****************************
1758 *
1759 * Desc: set manual spatial noise reduction strength
1760 * this function is active for NR is manual mode
1761 * Argument:
1762 * level: [0, 100]
1763 *
1764 *****************************
1765 */
rk_aiq_uapi_setMSpaNRStrth(const rk_aiq_sys_ctx_t * ctx,bool on,unsigned int level)1766 XCamReturn rk_aiq_uapi_setMSpaNRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level)
1767 {
1768 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1769 IMGPROC_FUNC_ENTER
1770
1771 if (ctx == NULL) {
1772 ret = XCAM_RETURN_ERROR_PARAM;
1773 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMSpaNRStrth failed!");
1774 }
1775
1776 if (CHECK_ISP_HW_V20()) {
1777 ret = rk_aiq_user_api_anr_SetLumaSFStrength(ctx, level / 100.0);
1778 }
1779
1780 if (CHECK_ISP_HW_V21()) {
1781 ret = rk_aiq_user_api_abayernrV2_SetSFStrength(ctx, level / 100.0);
1782 ret = rk_aiq_user_api_aynrV2_SetStrength(ctx, level / 100.0);
1783 }
1784
1785 if (CHECK_ISP_HW_V30()) {
1786 rk_aiq_uapi_sync_t sync;
1787 sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1788 rk_aiq_ynr_strength_v3_t ynrStrenght;
1789 ynrStrenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1790 ynrStrenght.strength_enable = true;
1791 ynrStrenght.percent = level / 100.0;
1792 ret = rk_aiq_user_api_aynrV3_SetStrength(ctx, &ynrStrenght);
1793 rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght;
1794 bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1795 bayer2dnrV2Strenght.strength_enable = true;
1796 bayer2dnrV2Strenght.percent = level / 100.0;
1797 ret = rk_aiq_user_api_abayer2dnrV2_SetStrength(ctx, &bayer2dnrV2Strenght);
1798 }
1799
1800 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1801 rk_aiq_ynr_strength_v22_t ynrStrength;
1802 ynrStrength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1803 ynrStrength.strength_enable = true;
1804 ynrStrength.percent = level / 100.0;
1805 ret = rk_aiq_user_api_aynrV22_SetStrength(ctx, &ynrStrength);
1806 rk_aiq_bayer2dnr_strength_v23_t bayer2dnrV23Strength;
1807 bayer2dnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1808 bayer2dnrV23Strength.strength_enable = true;
1809 bayer2dnrV23Strength.percent = level / 100.0;
1810 ret = rk_aiq_user_api_abayer2dnrV23_SetStrength(ctx, &bayer2dnrV23Strength);
1811 }
1812
1813 RKAIQ_IMGPROC_CHECK_RET(ret, "setMSpaNRStrth failed!", ret);
1814 IMGPROC_FUNC_EXIT
1815 return ret;
1816 }
1817
1818 /*
1819 *****************************
1820 *
1821 * Desc: get manual spatial noise reduction strength
1822 * this function is active for NR is manual mode
1823 * Argument:
1824 * level: [0, 100]
1825 *
1826 *****************************
1827 */
rk_aiq_uapi_getMSpaNRStrth(const rk_aiq_sys_ctx_t * ctx,bool * on,unsigned int * level)1828 XCamReturn rk_aiq_uapi_getMSpaNRStrth(const rk_aiq_sys_ctx_t* ctx, bool *on, unsigned int *level)
1829 {
1830 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1831 float percent = 0.0f;
1832 IMGPROC_FUNC_ENTER
1833 if (ctx == NULL) {
1834 ret = XCAM_RETURN_ERROR_PARAM;
1835 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMSpaNRStrth failed!");
1836 }
1837
1838 if (CHECK_ISP_HW_V20()) {
1839 ret = rk_aiq_user_api_anr_GetLumaSFStrength(ctx, &percent);
1840 }
1841
1842 if (CHECK_ISP_HW_V21()) {
1843 ret = rk_aiq_user_api_abayernrV2_GetSFStrength(ctx, &percent);
1844 }
1845
1846 if (CHECK_ISP_HW_V30()) {
1847 rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght;
1848 bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1849 ret = rk_aiq_user_api_abayer2dnrV2_GetStrength(ctx, &bayer2dnrV2Strenght);
1850 percent = bayer2dnrV2Strenght.percent;
1851 }
1852
1853 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1854 rk_aiq_bayer2dnr_strength_v23_t bayer2dnrV23Strength;
1855 bayer2dnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1856 ret = rk_aiq_user_api_abayer2dnrV23_GetStrength(ctx, &bayer2dnrV23Strength);
1857 percent = bayer2dnrV23Strength.percent;
1858 }
1859
1860 RKAIQ_IMGPROC_CHECK_RET(ret, "getMSpaNRStrth failed!", ret);
1861 *level = (unsigned int)(percent * 100);
1862 IMGPROC_FUNC_EXIT
1863 return ret;
1864 }
1865
1866 /*
1867 *****************************
1868 *
1869 * Desc: set manual time noise reduction strength
1870 * this function is active for NR is manual mode
1871 * Argument:
1872 * level: [0, 100]
1873 *
1874 *****************************
1875 */
rk_aiq_uapi_setMTNRStrth(const rk_aiq_sys_ctx_t * ctx,bool on,unsigned int level)1876 XCamReturn rk_aiq_uapi_setMTNRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level)
1877 {
1878 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1879 IMGPROC_FUNC_ENTER
1880 LOGD("level=%d", level);
1881 if (ctx == NULL) {
1882 ret = XCAM_RETURN_ERROR_PARAM;
1883 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMTNRStrth failed!");
1884 }
1885
1886 if (CHECK_ISP_HW_V20()) {
1887 ret = rk_aiq_user_api_anr_SetLumaTFStrength(ctx, level / 100.0);
1888 }
1889
1890 if (CHECK_ISP_HW_V21()) {
1891 ret = rk_aiq_user_api_abayernrV2_SetTFStrength(ctx, level / 100.0);
1892 }
1893
1894 if (CHECK_ISP_HW_V30()) {
1895 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
1896 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1897 bayertnrV2Strenght.strength_enable = true;
1898 bayertnrV2Strenght.percent = level / 100.0;
1899 ret = rk_aiq_user_api_abayertnrV2_SetStrength(ctx, &bayertnrV2Strenght);
1900 }
1901
1902 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1903 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
1904 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1905 bayertnrV23Strength.strength_enable = true;
1906 bayertnrV23Strength.percent = level / 100.0;
1907 ret = rk_aiq_user_api_abayertnrV23_SetStrength(ctx, &bayertnrV23Strength);
1908 }
1909
1910 RKAIQ_IMGPROC_CHECK_RET(ret, "setMTNRStrth failed!", ret);
1911 IMGPROC_FUNC_EXIT
1912 return ret;
1913 }
1914
1915 /*
1916 *****************************
1917 *
1918 * Desc: get manual time noise reduction strength
1919 * this function is active for NR is manual mode
1920 * Argument:
1921 * level: [0, 100]
1922 *
1923 *****************************
1924 */
rk_aiq_uapi_getMTNRStrth(const rk_aiq_sys_ctx_t * ctx,bool * on,unsigned int * level)1925 XCamReturn rk_aiq_uapi_getMTNRStrth(const rk_aiq_sys_ctx_t* ctx, bool *on, unsigned int *level)
1926 {
1927 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1928 float percent = 0.0f;
1929 IMGPROC_FUNC_ENTER
1930 if (ctx == NULL) {
1931 ret = XCAM_RETURN_ERROR_PARAM;
1932 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMTNRStrth failed!");
1933 }
1934
1935 if (CHECK_ISP_HW_V20()) {
1936 ret = rk_aiq_user_api_anr_GetLumaTFStrength(ctx, &percent);
1937 }
1938
1939 if (CHECK_ISP_HW_V21()) {
1940 ret = rk_aiq_user_api_abayernrV2_GetTFStrength(ctx, &percent);
1941 }
1942
1943 if (CHECK_ISP_HW_V30()) {
1944 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
1945 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1946 ret = rk_aiq_user_api_abayertnrV2_GetStrength(ctx, &bayertnrV2Strenght);
1947 percent = bayertnrV2Strenght.percent;
1948 }
1949
1950 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
1951 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
1952 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
1953 ret = rk_aiq_user_api_abayertnrV23_GetStrength(ctx, &bayertnrV23Strength);
1954 percent = bayertnrV23Strength.percent;
1955 }
1956
1957 RKAIQ_IMGPROC_CHECK_RET(ret, "getMTNRStrth failed!", ret);
1958 *level = (unsigned int)(percent * 100);
1959 IMGPROC_FUNC_EXIT
1960 return ret;
1961 }
1962
1963 /*
1964 **********************************************************
1965 * Dehaze
1966 **********************************************************
1967 */
1968 /*
1969 *****************************
1970 *
1971 * Desc: set/get dehaze mode
1972 * Argument:
1973 * mode:
1974 * auto: auto dehaze, when use auto, equal use rk_aiq_uapi_enableDhz
1975 * manual: Manual dehaze, when needs to use manual, please use rk_aiq_uapi_setMDhzStrth
1976 *
1977 *****************************
1978 *//*
1979 XCamReturn rk_aiq_uapi_setDhzMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
1980 {
1981 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1982 adehaze_sw_t attr;
1983 memset(&attr, 0, sizeof(attr));
1984 IMGPROC_FUNC_ENTER
1985 if (ctx == NULL) {
1986 ret = XCAM_RETURN_ERROR_PARAM;
1987 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1988 }
1989 attr.byPass = false;
1990 if (mode == OP_AUTO) {
1991 attr.mode = RK_AIQ_DEHAZE_MODE_AUTO;
1992 ret = rk_aiq_user_api_adehaze_setSwAttrib(ctx, attr);
1993 RKAIQ_IMGPROC_CHECK_RET(ret, "setDhzMode auto failed!");
1994 } else if (mode == OP_MANUAL) {
1995 attr.mode = RK_AIQ_DEHAZE_MODE_MANUAL;
1996 RKAIQ_IMGPROC_CHECK_RET(ret, "setDhzMode manual failed!");
1997 } else {
1998 ret = XCAM_RETURN_ERROR_PARAM;
1999 LOGE("mode is invalid!");
2000 }
2001 IMGPROC_FUNC_EXIT
2002 return ret;
2003 }
2004
2005 //not implemet
2006 XCamReturn rk_aiq_uapi_getDhzMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
2007 {
2008 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2009 adehaze_sw_t attr;
2010 memset(&attr, 0, sizeof(attr));
2011 IMGPROC_FUNC_ENTER
2012 if (ctx == NULL) {
2013 ret = XCAM_RETURN_ERROR_PARAM;
2014 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getDhzMode failed!");
2015 }
2016 ret = rk_aiq_user_api_adehaze_getSwAttrib(ctx, &attr);
2017 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed in get attrib!");
2018 if (attr.mode == RK_AIQ_DEHAZE_MODE_AUTO) {
2019 *mode = OP_AUTO;
2020 } else if (attr.mode == RK_AIQ_DEHAZE_MODE_MANUAL) {
2021 *mode = OP_MANUAL;
2022 } else {
2023 *mode = OP_INVAL;
2024 }
2025
2026 IMGPROC_FUNC_EXIT
2027 return ret;
2028 }
2029 */
2030 /*
2031 *****************************
2032 *
2033 * Desc: set manual dehaze strength
2034 * this function is active for dehaze is manual mode
2035 * Argument:
2036 * level: [0, 10]
2037 * Do not need to use rk_aiq_uapi_enableDhz and rk_aiq_uapi_setDhzMode before use this
2038 *
2039 *****************************
2040 *//*
2041 XCamReturn rk_aiq_uapi_setMDhzStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level)
2042 {
2043 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2044 adehaze_sw_t attr;
2045 memset(&attr, 0, sizeof(attr));
2046 IMGPROC_FUNC_ENTER
2047
2048 if (ctx == NULL) {
2049 ret = XCAM_RETURN_ERROR_PARAM;
2050 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
2051 }
2052 if (!on) {
2053 ret = XCAM_RETURN_ERROR_PARAM;
2054 RKAIQ_IMGPROC_CHECK_RET(ret, "Error use, param 'on' should be 'true'!");
2055 }
2056 if (level < 1 || level > 10) {
2057 ret = XCAM_RETURN_ERROR_PARAM;
2058 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, strength range is [1,10]!");
2059 }
2060 attr.byPass = false;
2061 attr.mode = RK_AIQ_DEHAZE_MODE_MANUAL;
2062 attr.stManual.strength = level;
2063 ret = rk_aiq_user_api_adehaze_setSwAttrib(ctx, attr);
2064 RKAIQ_IMGPROC_CHECK_RET(ret, "setMDhzStrth failed!");
2065 IMGPROC_FUNC_EXIT
2066 return ret;
2067 }
2068
2069 XCamReturn rk_aiq_uapi_getMDhzStrth(const rk_aiq_sys_ctx_t* ctx, bool *on, unsigned int *level)
2070 {
2071 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2072 adehaze_sw_t attr;
2073 memset(&attr, 0, sizeof(attr));
2074 IMGPROC_FUNC_ENTER
2075 if (ctx == NULL) {
2076 ret = XCAM_RETURN_ERROR_PARAM;
2077 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
2078 }
2079 ret = rk_aiq_user_api_adehaze_getSwAttrib(ctx, &attr);
2080 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed in get attrib!");
2081
2082 if (attr.mode != RK_AIQ_DEHAZE_MODE_MANUAL) {
2083 LOGE("Not in manual mode!");
2084 *level = 0;
2085 *on = false;
2086 } else {
2087 *level = attr.stManual.strength;
2088 *on = true;
2089 }
2090
2091
2092 IMGPROC_FUNC_EXIT
2093 return ret;
2094 }*/
2095 /*
2096 *****************************
2097 *
2098 * Desc: enable dehaze
2099 * Argument:
2100 * When dehaze enable, dehaze on and para use use IQ xml
2101 * When dehaze disable, dehaze off and enhance para use use IQ xml
2102 *
2103 *****************************
2104 *//*
2105 XCamReturn rk_aiq_uapi_enableDhz(const rk_aiq_sys_ctx_t* ctx)
2106 {
2107 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2108 adehaze_sw_t attr;
2109 memset(&attr, 0, sizeof(attr));
2110 IMGPROC_FUNC_ENTER
2111 if (ctx == NULL) {
2112 ret = XCAM_RETURN_ERROR_PARAM;
2113 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
2114 }
2115 attr.byPass = false;
2116 attr.mode = RK_AIQ_DEHAZE_MODE_AUTO;
2117 ret = rk_aiq_user_api_adehaze_setSwAttrib(ctx, attr);
2118 RKAIQ_IMGPROC_CHECK_RET(ret, "enable dehaze failed!");
2119 IMGPROC_FUNC_EXIT
2120 return ret;
2121 }
2122
2123 XCamReturn rk_aiq_uapi_disableDhz(const rk_aiq_sys_ctx_t* ctx)
2124 {
2125 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2126 adehaze_sw_t attr;
2127 memset(&attr, 0, sizeof(attr));
2128 IMGPROC_FUNC_ENTER
2129 if (ctx == NULL) {
2130 ret = XCAM_RETURN_ERROR_PARAM;
2131 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
2132 }
2133 attr.byPass = false;
2134 attr.mode = RK_AIQ_DEHAZE_MODE_OFF;
2135 ret = rk_aiq_user_api_adehaze_setSwAttrib(ctx, attr);
2136 RKAIQ_IMGPROC_CHECK_RET(ret, "disable dehaze failed!");
2137 IMGPROC_FUNC_EXIT
2138 return ret;
2139 }
2140 */
2141 /*
2142 **********************************************************
2143 * Image adjust
2144 **********************************************************
2145 */
2146
2147 /*
2148 *****************************
2149 *
2150 * Desc: Adjust image contrast level
2151 * Argument:
2152 * level: contrast level, [0, 255]
2153 *****************************
2154 */
rk_aiq_uapi_setContrast(const rk_aiq_sys_ctx_t * ctx,unsigned int level)2155 XCamReturn rk_aiq_uapi_setContrast(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
2156 {
2157 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2158 IMGPROC_FUNC_ENTER
2159
2160 LOGD("setContrast enter, level=%d\n", level);
2161 acp_attrib_t attrib;
2162 if ((int)level < 0 || level > 255) {
2163 ret = XCAM_RETURN_ERROR_PARAM;
2164 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, setContrast failed!");
2165 }
2166
2167 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2168 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set contrast failed!");
2169 attrib.contrast = level;
2170 ret = rk_aiq_user_api_acp_SetAttrib(ctx, &attrib);
2171 RKAIQ_IMGPROC_CHECK_RET(ret, "set contrast failed!");
2172 IMGPROC_FUNC_EXIT
2173
2174 return ret;
2175 }
2176
rk_aiq_uapi_getContrast(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)2177 XCamReturn rk_aiq_uapi_getContrast(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
2178 {
2179 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2180 IMGPROC_FUNC_ENTER
2181 acp_attrib_t attrib;
2182 if (level == NULL || ctx == NULL) {
2183 ret = XCAM_RETURN_ERROR_PARAM;
2184 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getContrast failed!");
2185 }
2186 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2187 RKAIQ_IMGPROC_CHECK_RET(ret, "get contrast failed!");
2188 *level = attrib.contrast;
2189 IMGPROC_FUNC_EXIT
2190 return ret;
2191 }
2192
2193 /*
2194 *****************************
2195 *
2196 * Desc: Adjust image brightness level
2197 * Argument:
2198 * level: brightness level, [0, 255]
2199 *****************************
2200 */
rk_aiq_uapi_setBrightness(const rk_aiq_sys_ctx_t * ctx,unsigned int level)2201 XCamReturn rk_aiq_uapi_setBrightness(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
2202 {
2203 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2204 acp_attrib_t attrib;
2205
2206 IMGPROC_FUNC_ENTER
2207 if (ctx == NULL) {
2208 ret = XCAM_RETURN_ERROR_PARAM;
2209 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set brightness failed!");
2210 }
2211
2212 LOGD("setBrightness enter, level=%d\n", level);
2213 if ((int)level < 0 || level > 255) {
2214 ret = XCAM_RETURN_ERROR_PARAM;
2215 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set brightness failed!");
2216 }
2217 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2218 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set brightness failed!");
2219 attrib.brightness = level;
2220 ret = rk_aiq_user_api_acp_SetAttrib(ctx, &attrib);
2221 RKAIQ_IMGPROC_CHECK_RET(ret, "set brightness failed!");
2222 IMGPROC_FUNC_EXIT
2223 return ret;
2224 }
2225
rk_aiq_uapi_getBrightness(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)2226 XCamReturn rk_aiq_uapi_getBrightness(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
2227 {
2228 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2229 IMGPROC_FUNC_ENTER
2230 acp_attrib_t attrib;
2231 if (level == NULL || ctx == NULL) {
2232 ret = XCAM_RETURN_ERROR_PARAM;
2233 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get brightness failed!");
2234 }
2235 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2236 RKAIQ_IMGPROC_CHECK_RET(ret, "get brightness failed!");
2237 *level = attrib.brightness;
2238 IMGPROC_FUNC_EXIT
2239 return ret;
2240 }
2241
2242 /*
2243 *****************************
2244 *
2245 * Desc: Adjust image saturation level
2246 * Argument:
2247 * level: saturation level, [0, 255]
2248 *****************************
2249 */
rk_aiq_uapi_setSaturation(const rk_aiq_sys_ctx_t * ctx,unsigned int level)2250 XCamReturn rk_aiq_uapi_setSaturation(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
2251 {
2252 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2253 acp_attrib_t attrib;
2254
2255 IMGPROC_FUNC_ENTER
2256 if (ctx == NULL) {
2257 ret = XCAM_RETURN_ERROR_PARAM;
2258 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set saturation failed!");
2259 }
2260
2261 LOGD("setSaturation enter, level=%d\n", level);
2262 if ((int)level < 0 || level > 255) {
2263 ret = XCAM_RETURN_ERROR_PARAM;
2264 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set saturation failed!");
2265 }
2266 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2267 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set saturation failed!");
2268 attrib.saturation = level;
2269 ret = rk_aiq_user_api_acp_SetAttrib(ctx, &attrib);
2270 RKAIQ_IMGPROC_CHECK_RET(ret, "set saturation failed!");
2271 IMGPROC_FUNC_EXIT
2272 return ret;
2273 }
2274
rk_aiq_uapi_getSaturation(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)2275 XCamReturn rk_aiq_uapi_getSaturation(const rk_aiq_sys_ctx_t* ctx, unsigned int* level)
2276 {
2277 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2278 IMGPROC_FUNC_ENTER
2279 acp_attrib_t attrib;
2280 if (level == NULL || ctx == NULL) {
2281 ret = XCAM_RETURN_ERROR_PARAM;
2282 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get saturation failed!");
2283 }
2284 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2285 RKAIQ_IMGPROC_CHECK_RET(ret, "get saturation failed!");
2286 *level = attrib.saturation;
2287 IMGPROC_FUNC_EXIT
2288 return ret;
2289 }
2290
2291 /*
2292 *****************************
2293 *
2294 * Desc: Adjust image hue level
2295 * Argument:
2296 * level: hue level, [0, 255]
2297 *****************************
2298 */
rk_aiq_uapi_setHue(const rk_aiq_sys_ctx_t * ctx,unsigned int level)2299 XCamReturn rk_aiq_uapi_setHue(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
2300 {
2301 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2302 acp_attrib_t attrib;
2303
2304 IMGPROC_FUNC_ENTER
2305 if (ctx == NULL) {
2306 ret = XCAM_RETURN_ERROR_PARAM;
2307 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set hue failed!");
2308 }
2309
2310 LOGD("setHue enter, level=%d\n", level);
2311 if ((int)level < 0 || level > 255) {
2312 ret = XCAM_RETURN_ERROR_PARAM;
2313 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set hue failed!");
2314 }
2315 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2316 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set hue failed!");
2317 attrib.hue = level;
2318 ret = rk_aiq_user_api_acp_SetAttrib(ctx, &attrib);
2319 RKAIQ_IMGPROC_CHECK_RET(ret, "set hue failed!");
2320 IMGPROC_FUNC_EXIT
2321 return ret;
2322 }
2323
rk_aiq_uapi_getHue(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)2324 XCamReturn rk_aiq_uapi_getHue(const rk_aiq_sys_ctx_t* ctx, unsigned int* level)
2325 {
2326 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2327 IMGPROC_FUNC_ENTER
2328 acp_attrib_t attrib;
2329 if (level == NULL || ctx == NULL) {
2330 ret = XCAM_RETURN_ERROR_PARAM;
2331 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get hue failed!");
2332 }
2333 ret = rk_aiq_user_api_acp_GetAttrib(ctx, &attrib);
2334 RKAIQ_IMGPROC_CHECK_RET(ret, "get hue failed!");
2335 *level = attrib.hue;
2336 IMGPROC_FUNC_EXIT
2337 return ret;
2338 }
2339
2340 /*
2341 *****************************
2342 *
2343 * Desc: Adjust image sharpness level
2344 * Argument:
2345 * level: sharpness level, [0, 100]
2346 *****************************
2347 */
rk_aiq_uapi_setSharpness(const rk_aiq_sys_ctx_t * ctx,unsigned int level)2348 XCamReturn rk_aiq_uapi_setSharpness(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
2349 {
2350 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2351 float fPercent = 0.0f;
2352
2353 IMGPROC_FUNC_ENTER
2354 if (ctx == NULL) {
2355 ret = XCAM_RETURN_ERROR_PARAM;
2356 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set sharpeness failed!");
2357 }
2358
2359 LOGD("setSharpness enter, level=%d\n", level);
2360 if ((int)level < 0 || level > 100) {
2361 ret = XCAM_RETURN_ERROR_PARAM;
2362 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set sharpeness failed!");
2363 }
2364 fPercent = level / 100.0f;
2365 if (CHECK_ISP_HW_V20()) {
2366 ret = rk_aiq_user_api_asharp_SetStrength(ctx, fPercent);
2367 }
2368
2369 if (CHECK_ISP_HW_V21()) {
2370 ret = rk_aiq_user_api_asharpV3_SetStrength(ctx, fPercent);
2371 }
2372
2373 if (CHECK_ISP_HW_V30()) {
2374 rk_aiq_sharp_strength_v4_t sharpV4Strenght;
2375 sharpV4Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2376 sharpV4Strenght.strength_enable = true;
2377 sharpV4Strenght.percent = fPercent;
2378 ret = rk_aiq_user_api_asharpV4_SetStrength(ctx, &sharpV4Strenght);
2379 }
2380
2381 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2382 rk_aiq_sharp_strength_v33_t sharpV33Strength;
2383 sharpV33Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2384 sharpV33Strength.strength_enable = true;
2385 sharpV33Strength.percent = fPercent;
2386 ret = rk_aiq_user_api_asharpV33_SetStrength(ctx, &sharpV33Strength);
2387 }
2388 RKAIQ_IMGPROC_CHECK_RET(ret, "set sharpeness failed!");
2389 IMGPROC_FUNC_EXIT
2390
2391 return ret;
2392 }
2393
rk_aiq_uapi_getSharpness(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)2394 XCamReturn rk_aiq_uapi_getSharpness(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
2395 {
2396 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2397 float fPercent = 0.0f;
2398
2399 IMGPROC_FUNC_ENTER
2400 if (level == NULL || ctx == NULL) {
2401 ret = XCAM_RETURN_ERROR_PARAM;
2402 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get sharpeness failed!");
2403 }
2404
2405 if (CHECK_ISP_HW_V20()) {
2406 ret = rk_aiq_user_api_asharp_GetStrength(ctx, &fPercent);
2407 }
2408
2409 if (CHECK_ISP_HW_V21()) {
2410 ret = rk_aiq_user_api_asharpV3_GetStrength(ctx, &fPercent);
2411 }
2412
2413 if (CHECK_ISP_HW_V30()) {
2414 rk_aiq_sharp_strength_v4_t sharpV4Strenght;
2415 sharpV4Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2416 ret = rk_aiq_user_api_asharpV4_GetStrength(ctx, &sharpV4Strenght);
2417 fPercent = sharpV4Strenght.percent;
2418 }
2419
2420 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2421 rk_aiq_sharp_strength_v33_t sharpV33Strength;
2422 sharpV33Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2423 ret = rk_aiq_user_api_asharpV33_GetStrength(ctx, &sharpV33Strength);
2424 fPercent = sharpV33Strength.percent;
2425 }
2426 RKAIQ_IMGPROC_CHECK_RET(ret, "get sharpeness failed!");
2427
2428 *level = (unsigned int)(fPercent * 100);
2429 IMGPROC_FUNC_EXIT
2430 return ret;
2431 }
2432
2433 /*
2434 *****************************
2435 *
2436 * Desc: Adjust image gamma
2437 *
2438 *****************************
2439 */
rk_aiq_uapi_setGammaCoef(const rk_aiq_sys_ctx_t * ctx,rk_aiq_gamma_attrib_t gammaAttr)2440 XCamReturn rk_aiq_uapi_setGammaCoef(const rk_aiq_sys_ctx_t* ctx, rk_aiq_gamma_attrib_t gammaAttr)
2441 {
2442 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2443 IMGPROC_FUNC_ENTER
2444 if (ctx == NULL) {
2445 ret = XCAM_RETURN_ERROR_PARAM;
2446 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setGammaCoef failed!");
2447 }
2448 ret = rk_aiq_user_api_agamma_GetAttrib(ctx, &gammaAttr);
2449 RKAIQ_IMGPROC_CHECK_RET(ret, "get gamma attrib failed!");
2450 ret = rk_aiq_user_api_agamma_SetAttrib(ctx, gammaAttr);
2451 IMGPROC_FUNC_EXIT
2452 return ret;
2453 }
2454
rk_aiq_uapi_setGrayMode(const rk_aiq_sys_ctx_t * ctx,rk_aiq_gray_mode_t mode)2455 XCamReturn rk_aiq_uapi_setGrayMode(const rk_aiq_sys_ctx_t* ctx, rk_aiq_gray_mode_t mode)
2456 {
2457 return ctx->_analyzer->setGrayMode(mode);
2458 }
2459
rk_aiq_uapi_getGrayMode(const rk_aiq_sys_ctx_t * ctx)2460 rk_aiq_gray_mode_t rk_aiq_uapi_getGrayMode(const rk_aiq_sys_ctx_t* ctx)
2461 {
2462 return ctx->_analyzer->getGrayMode();
2463 }
2464
rk_aiq_uapi_setFrameRate(const rk_aiq_sys_ctx_t * ctx,frameRateInfo_t info)2465 XCamReturn rk_aiq_uapi_setFrameRate(const rk_aiq_sys_ctx_t* ctx, frameRateInfo_t info)
2466 {
2467 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2468 Uapi_ExpSwAttr_t expSwAttr;
2469 IMGPROC_FUNC_ENTER
2470 if ((ctx == NULL) || (info.mode < OP_AUTO || info.mode >= OP_INVAL)) {
2471 ret = XCAM_RETURN_ERROR_PARAM;
2472 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2473 }
2474 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
2475 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\n setFrameRate failed!");
2476 if(info.mode == OP_AUTO) {
2477 expSwAttr.stAuto.stFrmRate.isFpsFix = false;
2478 } else if (info.mode == OP_MANUAL) {
2479 expSwAttr.stAuto.stFrmRate.isFpsFix = true;
2480 expSwAttr.stAuto.stFrmRate.FpsValue = info.fps;
2481 }
2482 ret = rk_aiq_user_api_ae_setExpSwAttr(ctx, expSwAttr);
2483 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\n setFrameRate failed!");
2484 IMGPROC_FUNC_EXIT
2485 return ret;
2486 }
2487
rk_aiq_uapi_getFrameRate(const rk_aiq_sys_ctx_t * ctx,frameRateInfo_t * info)2488 XCamReturn rk_aiq_uapi_getFrameRate(const rk_aiq_sys_ctx_t* ctx, frameRateInfo_t *info)
2489 {
2490 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2491 Uapi_ExpSwAttr_t expSwAttr;
2492 IMGPROC_FUNC_ENTER
2493 if ((ctx == NULL) || (info == NULL)) {
2494 ret = XCAM_RETURN_ERROR_PARAM;
2495 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2496 }
2497 ret = rk_aiq_user_api_ae_getExpSwAttr(ctx, &expSwAttr);
2498 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\n getFrameRate failed!");
2499 if(expSwAttr.stAuto.stFrmRate.isFpsFix) {
2500 info->mode = OP_MANUAL;
2501 info->fps = expSwAttr.stAuto.stFrmRate.FpsValue;
2502 } else {
2503 info->mode = OP_AUTO;
2504 info->fps = expSwAttr.stAuto.stFrmRate.FpsValue;
2505 }
2506 IMGPROC_FUNC_EXIT
2507 return ret;
2508 }
2509
rk_aiq_uapi_setMirroFlip(const rk_aiq_sys_ctx_t * ctx,bool mirror,bool flip,int skip_frm_cnt)2510 XCamReturn rk_aiq_uapi_setMirroFlip(const rk_aiq_sys_ctx_t* ctx, bool mirror, bool flip, int skip_frm_cnt)
2511 {
2512 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2513 IMGPROC_FUNC_ENTER
2514 if (ctx == NULL) {
2515 ret = XCAM_RETURN_ERROR_PARAM;
2516 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2517 }
2518 return ctx->_rkAiqManager->setMirrorFlip(mirror, flip, skip_frm_cnt);
2519 }
2520
rk_aiq_uapi_getMirrorFlip(const rk_aiq_sys_ctx_t * ctx,bool * mirror,bool * flip)2521 XCamReturn rk_aiq_uapi_getMirrorFlip(const rk_aiq_sys_ctx_t* ctx, bool* mirror, bool* flip)
2522 {
2523 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2524 IMGPROC_FUNC_ENTER
2525 if (ctx == NULL || mirror == NULL || flip == NULL) {
2526 ret = XCAM_RETURN_ERROR_PARAM;
2527 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2528 }
2529 return ctx->_rkAiqManager->getMirrorFlip(*mirror, *flip);
2530 }
2531
rk_aiq_uapi_setFecEn(const rk_aiq_sys_ctx_t * ctx,bool en)2532 XCamReturn rk_aiq_uapi_setFecEn(const rk_aiq_sys_ctx_t* ctx, bool en)
2533 {
2534 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2535 IMGPROC_FUNC_ENTER
2536 if (ctx == NULL) {
2537 ret = XCAM_RETURN_ERROR_PARAM;
2538 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2539 }
2540 rk_aiq_fec_attrib_t fecAttr;
2541 ret = rk_aiq_user_api_afec_GetAttrib(ctx, &fecAttr);
2542 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
2543 fecAttr.en = en;
2544 ret = rk_aiq_user_api_afec_SetAttrib(ctx, fecAttr);
2545 IMGPROC_FUNC_EXIT
2546 return ret;
2547 }
2548
rk_aiq_uapi_setFecBypass(const rk_aiq_sys_ctx_t * ctx,bool bypass)2549 XCamReturn rk_aiq_uapi_setFecBypass(const rk_aiq_sys_ctx_t* ctx, bool bypass)
2550 {
2551 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2552 IMGPROC_FUNC_ENTER
2553 if (ctx == NULL) {
2554 ret = XCAM_RETURN_ERROR_PARAM;
2555 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2556 }
2557 rk_aiq_fec_attrib_t fecAttr;
2558 ret = rk_aiq_user_api_afec_GetAttrib(ctx, &fecAttr);
2559 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
2560 fecAttr.bypass = bypass;
2561 ret = rk_aiq_user_api_afec_SetAttrib(ctx, fecAttr);
2562 IMGPROC_FUNC_EXIT
2563 return ret;
2564 }
2565
rk_aiq_uapi_setFecCorrectLevel(const rk_aiq_sys_ctx_t * ctx,int correctLevel)2566 XCamReturn rk_aiq_uapi_setFecCorrectLevel(const rk_aiq_sys_ctx_t* ctx, int correctLevel)
2567 {
2568 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2569 IMGPROC_FUNC_ENTER
2570 if (ctx == NULL) {
2571 ret = XCAM_RETURN_ERROR_PARAM;
2572 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2573 }
2574 rk_aiq_fec_attrib_t fecAttr;
2575 ret = rk_aiq_user_api_afec_GetAttrib(ctx, &fecAttr);
2576 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
2577 fecAttr.correct_level = correctLevel;
2578 ret = rk_aiq_user_api_afec_SetAttrib(ctx, fecAttr);
2579 IMGPROC_FUNC_EXIT
2580 return ret;
2581 }
2582
rk_aiq_uapi_setFecCorrectDirection(const rk_aiq_sys_ctx_t * ctx,const fec_correct_direction_t direction)2583 XCamReturn rk_aiq_uapi_setFecCorrectDirection(const rk_aiq_sys_ctx_t* ctx,
2584 const fec_correct_direction_t direction)
2585 {
2586 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2587 IMGPROC_FUNC_ENTER
2588 if (ctx == NULL) {
2589 ret = XCAM_RETURN_ERROR_PARAM;
2590 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2591 }
2592 rk_aiq_fec_attrib_t fecAttr;
2593 ret = rk_aiq_user_api_afec_GetAttrib(ctx, &fecAttr);
2594 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
2595 fecAttr.direction = direction;
2596 ret = rk_aiq_user_api_afec_SetAttrib(ctx, fecAttr);
2597 IMGPROC_FUNC_EXIT
2598 return ret;
2599 }
2600
rk_aiq_uapi_setFecCorrectMode(const rk_aiq_sys_ctx_t * ctx,const fec_correct_mode_t mode)2601 XCamReturn rk_aiq_uapi_setFecCorrectMode(const rk_aiq_sys_ctx_t* ctx,
2602 const fec_correct_mode_t mode)
2603 {
2604 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2605 IMGPROC_FUNC_ENTER
2606 if (ctx == NULL) {
2607 ret = XCAM_RETURN_ERROR_PARAM;
2608 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2609 }
2610 rk_aiq_fec_attrib_t fecAttr;
2611 ret = rk_aiq_user_api_afec_GetAttrib(ctx, &fecAttr);
2612 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
2613 fecAttr.mode = mode;
2614 ret = rk_aiq_user_api_afec_SetAttrib(ctx, fecAttr);
2615 IMGPROC_FUNC_EXIT
2616 return ret;
2617 }
2618
rk_aiq_uapi_setLdchEn(const rk_aiq_sys_ctx_t * ctx,bool en)2619 XCamReturn rk_aiq_uapi_setLdchEn(const rk_aiq_sys_ctx_t* ctx, bool en)
2620 {
2621 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2622 IMGPROC_FUNC_ENTER
2623 if (ctx == NULL) {
2624 ret = XCAM_RETURN_ERROR_PARAM;
2625 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2626 }
2627 rk_aiq_ldch_attrib_t ldchAttr;
2628 ret = rk_aiq_user_api_aldch_GetAttrib(ctx, &ldchAttr);
2629 RKAIQ_IMGPROC_CHECK_RET(ret, "get ldch attrib failed!");
2630 ldchAttr.en = en;
2631 ret = rk_aiq_user_api_aldch_SetAttrib(ctx, &ldchAttr);
2632 IMGPROC_FUNC_EXIT
2633 return ret;
2634 }
2635
rk_aiq_uapi_setLdchCorrectLevel(const rk_aiq_sys_ctx_t * ctx,int correctLevel)2636 XCamReturn rk_aiq_uapi_setLdchCorrectLevel(const rk_aiq_sys_ctx_t* ctx, int correctLevel)
2637 {
2638 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2639 IMGPROC_FUNC_ENTER
2640 if (ctx == NULL) {
2641 ret = XCAM_RETURN_ERROR_PARAM;
2642 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
2643 }
2644 rk_aiq_ldch_attrib_t ldchAttr;
2645 ret = rk_aiq_user_api_aldch_GetAttrib(ctx, &ldchAttr);
2646 RKAIQ_IMGPROC_CHECK_RET(ret, "get ldch attrib failed!");
2647 ldchAttr.correct_level = correctLevel;
2648 ret = rk_aiq_user_api_aldch_SetAttrib(ctx, &ldchAttr);
2649 IMGPROC_FUNC_EXIT
2650 return ret;
2651 }
2652
2653 RKAIQ_END_DECLARE
2654