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 "include/uAPI2/rk_aiq_user_api2_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
35 /*
36 **********************************************************
37 * API of AEC module of V2
38 **********************************************************
39 */
40
41 /*
42 *****************************
43 * Desc: set ae mode
44 * Argument:
45 * mode contains: auto & manual
46 *
47 *****************************
48 */
rk_aiq_uapi2_setAeLock(const rk_aiq_sys_ctx_t * ctx,bool on)49 XCamReturn rk_aiq_uapi2_setAeLock
50 (
51 const rk_aiq_sys_ctx_t* ctx,
52 bool on
53 ) {
54
55 IMGPROC_FUNC_ENTER
56 XCamReturn ret = XCAM_RETURN_NO_ERROR;
57 Uapi_ExpSwAttrV2_t expSwAttr;
58 if (ctx == NULL) {
59 ret = XCAM_RETURN_ERROR_PARAM;
60 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
61 }
62
63 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
64 RKAIQ_IMGPROC_CHECK_RET(ret, "failed in getExpSwAttr!");
65 expSwAttr.Enable = (!on);
66 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
67 RKAIQ_IMGPROC_CHECK_RET(ret, "failed in setExpSwAttr!");
68 IMGPROC_FUNC_EXIT
69 return (ret);
70
71 }
rk_aiq_uapi2_setExpMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)72 XCamReturn rk_aiq_uapi2_setExpMode
73 (
74 const rk_aiq_sys_ctx_t* ctx,
75 opMode_t mode
76 ) {
77
78 IMGPROC_FUNC_ENTER
79 XCamReturn ret = XCAM_RETURN_NO_ERROR;
80 Uapi_ExpSwAttrV2_t expSwAttr;
81 if (ctx == NULL) {
82 ret = XCAM_RETURN_ERROR_PARAM;
83 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
84 }
85
86 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
87 RKAIQ_IMGPROC_CHECK_RET(ret, "setExpMode failed in getExpSwAttr!");
88 if (mode == OP_AUTO) {
89 expSwAttr.AecOpType = RK_AIQ_OP_MODE_AUTO;
90 } else if (mode == OP_MANUAL) {
91 if (isHDRmode(ctx)) {
92 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
93 expSwAttr.stManual.HdrAE.ManualGainEn = true;
94 expSwAttr.stManual.HdrAE.ManualTimeEn = true;
95 } else {
96 expSwAttr.AecOpType = RK_AIQ_OP_MODE_MANUAL;
97 expSwAttr.stManual.LinearAE.ManualGainEn = true;
98 expSwAttr.stManual.LinearAE.ManualTimeEn = true;
99 }
100 } else {
101 ret = XCAM_RETURN_ERROR_PARAM;
102 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is not supported!");
103 }
104 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
105 RKAIQ_IMGPROC_CHECK_RET(ret, "setExpMode failed in setExpSwAttr!");
106 IMGPROC_FUNC_EXIT
107 return (ret);
108
109 }
rk_aiq_uapi2_getExpMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)110 XCamReturn rk_aiq_uapi2_getExpMode
111 (
112 const rk_aiq_sys_ctx_t* ctx,
113 opMode_t *mode
114 ) {
115 XCamReturn ret = XCAM_RETURN_NO_ERROR;
116 Uapi_ExpSwAttrV2_t expSwAttr;
117 IMGPROC_FUNC_ENTER
118 if ((ctx == NULL) || (mode == NULL)) {
119 ret = XCAM_RETURN_ERROR_PARAM;
120 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
121 }
122 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
123 RKAIQ_IMGPROC_CHECK_RET(ret, "getExpMode failed in getExpSwAttr!");
124 if (expSwAttr.AecOpType == RK_AIQ_OP_MODE_AUTO) {
125 *mode = OP_AUTO;
126 } else if (expSwAttr.AecOpType == RK_AIQ_OP_MODE_MANUAL) {
127 *mode = OP_MANUAL;
128 }
129 IMGPROC_FUNC_EXIT
130 return (ret);
131 }
132
133 /*
134 *****************************
135 *
136 * Desc: set exposure parameter
137 * Argument:
138 * auto exposure mode:
139 * exposure gain will be adjust between [gain->min, gain->max]
140 * manual exposure mode:
141 * gain->min == gain->max
142 *
143 *****************************
144 */
rk_aiq_uapi2_setExpGainRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * gain)145 XCamReturn rk_aiq_uapi2_setExpGainRange
146 (
147 const rk_aiq_sys_ctx_t* ctx,
148 paRange_t *gain
149 ) {
150 XCamReturn ret = XCAM_RETURN_NO_ERROR;
151 Uapi_ExpSwAttrV2_t expSwAttr;
152 IMGPROC_FUNC_ENTER
153 if ((ctx == NULL) || (gain == NULL)) {
154 ret = XCAM_RETURN_ERROR_PARAM;
155 RKAIQ_IMGPROC_CHECK_RET(ret, "param invalid!");
156 }
157 LOGD("set range: [%f, %f]", gain->min, gain->max);
158
159 if (gain->min < 1.0f || gain->max < 1.0f || (gain->min > gain->max)) {
160 ret = XCAM_RETURN_ERROR_PARAM;
161 RKAIQ_IMGPROC_CHECK_RET(ret, "gain range is wrong!");
162 }
163 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
164 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpGainRange failed!");
165
166 expSwAttr.stAdvanced.SetAeRangeEn = true;
167 if (isHDRmode(ctx)) {
168 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Max = gain->max;
169 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[0].Min = gain->min;
170 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Max = gain->max;
171 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[1].Min = gain->min;
172 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Max = gain->max;
173 expSwAttr.stAdvanced.SetHdrAeRange.stGainRange[2].Min = gain->min;
174 } else {
175 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Max = gain->max;
176 expSwAttr.stAdvanced.SetLinAeRange.stGainRange.Min = gain->min;
177 }
178 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
179 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpGainRange failed!");
180 IMGPROC_FUNC_EXIT
181 return (ret);
182
183 }
rk_aiq_uapi2_getExpGainRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * gain)184 XCamReturn rk_aiq_uapi2_getExpGainRange
185 (
186 const rk_aiq_sys_ctx_t* ctx,
187 paRange_t *gain
188 ) {
189 XCamReturn ret = XCAM_RETURN_NO_ERROR;
190 Uapi_ExpSwAttrV2_t expSwAttr;
191 IMGPROC_FUNC_ENTER
192 if ((ctx == NULL) || (gain == NULL)) {
193 ret = XCAM_RETURN_ERROR_PARAM;
194 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
195 }
196
197 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
198 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetExpGainRange failed!");
199 if (isHDRmode(ctx)) {
200 int index = getHDRFrameNum(ctx);
201 gain->max = expSwAttr.stAuto.HdrAeRange.stGainRange[index - 1].Max;
202 gain->min = expSwAttr.stAuto.HdrAeRange.stGainRange[index - 1].Min;
203 } else {
204 gain->max = expSwAttr.stAuto.LinAeRange.stGainRange.Max;
205 gain->min = expSwAttr.stAuto.LinAeRange.stGainRange.Min;
206 }
207
208 IMGPROC_FUNC_EXIT
209 return (ret);
210
211 }
212 /*
213 *****************************
214 *
215 * Desc: set exposure parameter
216 * Argument:
217 * auto exposure mode:
218 * exposure time will be adjust between [time->min, time->max]
219 * manual exposure mode:
220 * exposure time will be set gain->min == gain->max;
221 *
222 *****************************
223 */
rk_aiq_uapi2_setExpTimeRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * time)224 XCamReturn rk_aiq_uapi2_setExpTimeRange
225 (
226 const rk_aiq_sys_ctx_t* ctx,
227 paRange_t *time
228 ) {
229 XCamReturn ret = XCAM_RETURN_NO_ERROR;
230 Uapi_ExpSwAttrV2_t expSwAttr;
231 IMGPROC_FUNC_ENTER
232 if ((ctx == NULL) || (time == NULL)) {
233 ret = XCAM_RETURN_ERROR_PARAM;
234 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
235 }
236 if ( time->min > time->max ) {
237 ret = XCAM_RETURN_ERROR_PARAM;
238 RKAIQ_IMGPROC_CHECK_RET(ret, "time range is wrong!");
239 }
240 LOGD("set range: [%f, %f]", time->min, time->max);
241 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
242 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpTimeRange failed!");
243
244 expSwAttr.stAdvanced.SetAeRangeEn = true;
245 if (isHDRmode(ctx)) {
246 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Max = time->max;
247 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[0].Min = time->min;
248 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Max = time->max;
249 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[1].Min = time->min;
250 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Max = time->max;
251 expSwAttr.stAdvanced.SetHdrAeRange.stExpTimeRange[2].Min = time->min;
252 } else {
253 expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Max = time->max;
254 expSwAttr.stAdvanced.SetLinAeRange.stExpTimeRange.Min = time->min;
255 }
256 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
257 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpTimeRange failed!");
258 IMGPROC_FUNC_EXIT
259 return (ret);
260
261 }
rk_aiq_uapi2_getExpTimeRange(const rk_aiq_sys_ctx_t * ctx,paRange_t * time)262 XCamReturn rk_aiq_uapi2_getExpTimeRange
263 (
264 const rk_aiq_sys_ctx_t* ctx,
265 paRange_t *time
266 ) {
267 XCamReturn ret = XCAM_RETURN_NO_ERROR;
268 Uapi_ExpSwAttrV2_t expSwAttr;
269 IMGPROC_FUNC_ENTER
270 if ((ctx == NULL) || (time == NULL)) {
271 ret = XCAM_RETURN_ERROR_PARAM;
272 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
273 }
274
275 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
276 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetExpTimeRange failed!");
277 if (isHDRmode(ctx)) {
278 int index = getHDRFrameNum(ctx);
279 time->max = expSwAttr.stAuto.HdrAeRange.stExpTimeRange[index - 1].Max;
280 time->min = expSwAttr.stAuto.HdrAeRange.stExpTimeRange[index - 1].Min;
281 } else {
282 time->max = expSwAttr.stAuto.LinAeRange.stExpTimeRange.Max;
283 time->min = expSwAttr.stAuto.LinAeRange.stExpTimeRange.Min;
284 }
285
286 IMGPROC_FUNC_EXIT
287 return (ret);
288
289 }
290
291 /*
292 *****************************
293 *
294 * Desc: backlight compensation
295 * Argument:
296 * on: 1 on
297 * 0 off
298 * areaType: backlight compensation area
299 *
300 *****************************
301 */
rk_aiq_uapi2_setBLCMode(const rk_aiq_sys_ctx_t * ctx,bool on,aeMeasAreaType_t areaType)302 XCamReturn rk_aiq_uapi2_setBLCMode(const rk_aiq_sys_ctx_t* ctx, bool on, aeMeasAreaType_t areaType)
303 {
304 XCamReturn ret = XCAM_RETURN_NO_ERROR;
305
306 Uapi_LinExpAttrV2_t LineExpAttr;
307 memset(&LineExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t));
308 IMGPROC_FUNC_ENTER
309 if (ctx == NULL) {
310 ret = XCAM_RETURN_ERROR_PARAM;
311 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
312 }
313 if (isHDRmode(ctx)) {
314 ret = XCAM_RETURN_ERROR_FAILED;
315 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
316 }
317
318 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LineExpAttr);
319 RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!");
320 LineExpAttr.Params.BackLightCtrl.Enable = on ? 1 : 0;
321 LineExpAttr.Params.BackLightCtrl.MeasArea = (CalibDb_AecMeasAreaModeV2_t)areaType;
322 LineExpAttr.Params.BackLightCtrl.StrBias = 0;
323 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LineExpAttr);
324 RKAIQ_IMGPROC_CHECK_RET(ret, "setBLCMode error!");
325 IMGPROC_FUNC_EXIT
326 return ret;
327 }
328
329 /*
330 *****************************
331 *
332 * Desc: backlight compensation strength,only available in normal mode
333 * Argument:
334 * strength: [1,100]
335 *****************************
336 */
rk_aiq_uapi2_setBLCStrength(const rk_aiq_sys_ctx_t * ctx,int strength)337 XCamReturn rk_aiq_uapi2_setBLCStrength(const rk_aiq_sys_ctx_t* ctx, int strength)
338 {
339 XCamReturn ret = XCAM_RETURN_NO_ERROR;
340 Uapi_LinExpAttrV2_t LineExpAttr;
341 memset(&LineExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t));
342
343 IMGPROC_FUNC_ENTER
344 if (ctx == NULL) {
345 ret = XCAM_RETURN_ERROR_PARAM;
346 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
347 }
348 if (isHDRmode(ctx)) {
349 ret = XCAM_RETURN_ERROR_FAILED;
350 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
351 } else {
352 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LineExpAttr);
353 RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!");
354 if(0 == LineExpAttr.Params.BackLightCtrl.Enable)
355 RKAIQ_IMGPROC_CHECK_RET(ret, "blc mode is not enabled!");
356 LineExpAttr.Params.BackLightCtrl.StrBias = strength;
357 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LineExpAttr);
358 RKAIQ_IMGPROC_CHECK_RET(ret, "setBLCStrength error!");
359 }
360
361 IMGPROC_FUNC_EXIT
362 return ret;
363 }
364
365 /*
366 *****************************
367 *
368 * Desc: highlight compensation
369 * Argument:
370 * on: 1 on
371 * 0 off
372 *****************************
373 */
rk_aiq_uapi2_setHLCMode(const rk_aiq_sys_ctx_t * ctx,bool on)374 XCamReturn rk_aiq_uapi2_setHLCMode(const rk_aiq_sys_ctx_t* ctx, bool on)
375 {
376 XCamReturn ret = XCAM_RETURN_NO_ERROR;
377 Uapi_LinExpAttrV2_t LinExpAttr;
378 memset(&LinExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t));
379 IMGPROC_FUNC_ENTER
380 if (ctx == NULL) {
381 ret = XCAM_RETURN_ERROR_PARAM;
382 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
383 }
384
385 if (isHDRmode(ctx)) {
386 ret = XCAM_RETURN_ERROR_FAILED;
387 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
388 } else {
389 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LinExpAttr);
390 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\n setHLCMode failed!");
391 LinExpAttr.Params.OverExpCtrl.Enable = on ? 1 : 0;
392 LinExpAttr.Params.OverExpCtrl.StrBias = 0;
393 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LinExpAttr);
394 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\n setHLCMode failed!");
395 }
396 IMGPROC_FUNC_EXIT
397 return ret;
398
399 }
400
401 /*
402 *****************************
403 *
404 * Desc: highlight compensation strength
405 * Argument:
406 * strength: [1,100]
407 *****************************
408 */
rk_aiq_uapi2_setHLCStrength(const rk_aiq_sys_ctx_t * ctx,int strength)409 XCamReturn rk_aiq_uapi2_setHLCStrength(const rk_aiq_sys_ctx_t* ctx, int strength)
410 {
411 XCamReturn ret = XCAM_RETURN_NO_ERROR;
412 Uapi_LinExpAttrV2_t LinExpAttr;
413 memset(&LinExpAttr, 0x00, sizeof(Uapi_LinExpAttrV2_t));
414 IMGPROC_FUNC_ENTER
415 if (ctx == NULL) {
416 ret = XCAM_RETURN_ERROR_PARAM;
417 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
418 }
419 if (isHDRmode(ctx)) {
420 ret = XCAM_RETURN_ERROR_FAILED;
421 RKAIQ_IMGPROC_CHECK_RET(ret, "Not support in HDR mode!");
422 } else {
423 ret = rk_aiq_user_api2_ae_getLinExpAttr(ctx, &LinExpAttr);
424 RKAIQ_IMGPROC_CHECK_RET(ret, "getLinExpAttr error!");
425 if(0 == LinExpAttr.Params.OverExpCtrl.Enable)
426 RKAIQ_IMGPROC_CHECK_RET(ret, "hlc mode is not enabled!");
427 LinExpAttr.Params.OverExpCtrl.StrBias = strength;
428 ret = rk_aiq_user_api2_ae_setLinExpAttr(ctx, LinExpAttr);
429 RKAIQ_IMGPROC_CHECK_RET(ret, "setHLCStrength error!");
430 }
431 IMGPROC_FUNC_EXIT
432 return ret;
433
434 }
435 /*
436 *****************************
437 *
438 * Desc: set anti-flicker mode
439 * Argument:
440 * mode
441 *
442 *****************************
443 */
rk_aiq_uapi2_setAntiFlickerEn(const rk_aiq_sys_ctx_t * ctx,bool on)444 XCamReturn rk_aiq_uapi2_setAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool on)
445 {
446 XCamReturn ret = XCAM_RETURN_NO_ERROR;
447 Uapi_ExpSwAttrV2_t expSwAttr;
448 IMGPROC_FUNC_ENTER
449 if (ctx == NULL) {
450 ret = XCAM_RETURN_ERROR_PARAM;
451 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
452 }
453
454 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
455 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetAntiFlickerEn failed!");
456 expSwAttr.stAuto.stAntiFlicker.enable = on;
457
458 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
459 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetAntiFlickerEn failed!");
460 IMGPROC_FUNC_EXIT
461 return ret;
462 }
463 /*
464 *****************************
465 *
466 * Desc: set anti-flicker mode
467 * Argument:
468 * mode
469 *
470 *****************************
471 */
rk_aiq_uapi2_getAntiFlickerEn(const rk_aiq_sys_ctx_t * ctx,bool * on)472 XCamReturn rk_aiq_uapi2_getAntiFlickerEn(const rk_aiq_sys_ctx_t* ctx, bool* on)
473 {
474
475 XCamReturn ret = XCAM_RETURN_NO_ERROR;
476 Uapi_ExpSwAttrV2_t expSwAttr;
477 IMGPROC_FUNC_ENTER
478 if (ctx == NULL) {
479 ret = XCAM_RETURN_ERROR_PARAM;
480 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
481 }
482
483 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
484 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetAntiFlickerEn!");
485 *on = expSwAttr.stAuto.stAntiFlicker.enable;
486 IMGPROC_FUNC_EXIT
487 return ret;
488 }
489
490 /*
491 *****************************
492 *
493 * Desc: set anti-flicker mode
494 * Argument:
495 * mode
496 *
497 *****************************
498 */
499
rk_aiq_uapi2_setAntiFlickerMode(const rk_aiq_sys_ctx_t * ctx,antiFlickerMode_t mode)500 XCamReturn rk_aiq_uapi2_setAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx, antiFlickerMode_t mode)
501 {
502 XCamReturn ret = XCAM_RETURN_NO_ERROR;
503 Uapi_ExpSwAttrV2_t expSwAttr;
504 IMGPROC_FUNC_ENTER
505 if (ctx == NULL) {
506 ret = XCAM_RETURN_ERROR_PARAM;
507 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
508 }
509
510 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
511 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetAntiFlickerMode failed!");
512 if (mode == ANTIFLICKER_AUTO_MODE) {
513 expSwAttr.stAuto.stAntiFlicker.enable = true;
514 expSwAttr.stAuto.stAntiFlicker.Mode = AECV2_ANTIFLICKER_AUTO_MODE;
515 } else if(mode == ANTIFLICKER_NORMAL_MODE) {
516 expSwAttr.stAuto.stAntiFlicker.enable = true;
517 expSwAttr.stAuto.stAntiFlicker.Mode = AECV2_ANTIFLICKER_NORMAL_MODE;
518 } else {
519 ret = XCAM_RETURN_ERROR_PARAM;
520 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!");
521 }
522 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
523 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetAntiFlickerMode failed!");
524 IMGPROC_FUNC_EXIT
525 return ret;
526 }
527
rk_aiq_uapi2_getAntiFlickerMode(const rk_aiq_sys_ctx_t * ctx,antiFlickerMode_t * mode)528 XCamReturn rk_aiq_uapi2_getAntiFlickerMode(const rk_aiq_sys_ctx_t* ctx, antiFlickerMode_t *mode)
529 {
530 XCamReturn ret = XCAM_RETURN_NO_ERROR;
531 Uapi_ExpSwAttrV2_t expSwAttr;
532 IMGPROC_FUNC_ENTER
533 if (ctx == NULL) {
534 ret = XCAM_RETURN_ERROR_PARAM;
535 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
536 }
537
538 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
539
540 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\ngetAntiFlickerMode!");
541 if (expSwAttr.stAuto.stAntiFlicker.Mode == AECV2_ANTIFLICKER_AUTO_MODE)
542 *mode = ANTIFLICKER_AUTO_MODE;
543 else if (expSwAttr.stAuto.stAntiFlicker.Mode == AECV2_ANTIFLICKER_NORMAL_MODE)
544 *mode = ANTIFLICKER_NORMAL_MODE;
545 IMGPROC_FUNC_EXIT
546 return ret;
547 }
548
549 /*
550 *****************************
551 *
552 * Desc: set power line frequence
553 * Argument:
554 * freq
555 *
556 *****************************
557 */
rk_aiq_uapi2_setExpPwrLineFreqMode(const rk_aiq_sys_ctx_t * ctx,expPwrLineFreq_t freq)558 XCamReturn rk_aiq_uapi2_setExpPwrLineFreqMode(const rk_aiq_sys_ctx_t* ctx, expPwrLineFreq_t freq)
559 {
560 XCamReturn ret = XCAM_RETURN_NO_ERROR;
561 Uapi_ExpSwAttrV2_t expSwAttr;
562 IMGPROC_FUNC_ENTER
563 if (ctx == NULL) {
564 ret = XCAM_RETURN_ERROR_PARAM;
565 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
566 }
567 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
568 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpPwrLineFreqMode failed!");
569 if (freq == EXP_PWR_LINE_FREQ_50HZ) {
570 expSwAttr.stAuto.stAntiFlicker.enable = true;
571 expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_50HZ;
572 } else if (freq == EXP_PWR_LINE_FREQ_60HZ) {
573 expSwAttr.stAuto.stAntiFlicker.enable = true;
574 expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_60HZ;
575 } else if (freq == EXP_PWR_LINE_FREQ_DIS) {
576 expSwAttr.stAuto.stAntiFlicker.enable = true;
577 expSwAttr.stAuto.stAntiFlicker.Frequency = AECV2_FLICKER_FREQUENCY_OFF;
578 } else {
579 ret = XCAM_RETURN_ERROR_PARAM;
580 RKAIQ_IMGPROC_CHECK_RET(ret, "freq is invalid!");
581 }
582 ret = rk_aiq_user_api2_ae_setExpSwAttr(ctx, expSwAttr);
583 RKAIQ_IMGPROC_CHECK_RET(ret, "set exp attr failed!\nsetExpPwrLineFreqMode failed!");
584 IMGPROC_FUNC_EXIT
585 return (ret);
586 }
rk_aiq_uapi2_getExpPwrLineFreqMode(const rk_aiq_sys_ctx_t * ctx,expPwrLineFreq_t * freq)587 XCamReturn rk_aiq_uapi2_getExpPwrLineFreqMode
588 (
589 const rk_aiq_sys_ctx_t* ctx,
590 expPwrLineFreq_t *freq
591 ) {
592 XCamReturn ret = XCAM_RETURN_NO_ERROR;
593 Uapi_ExpSwAttrV2_t expSwAttr;
594 IMGPROC_FUNC_ENTER
595 if (ctx == NULL) {
596 ret = XCAM_RETURN_ERROR_PARAM;
597 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
598 }
599
600 ret = rk_aiq_user_api2_ae_getExpSwAttr(ctx, &expSwAttr);
601 RKAIQ_IMGPROC_CHECK_RET(ret, "get exp attr failed!\nsetExpPwrLineFreqMode failed!");
602 if (expSwAttr.stAuto.stAntiFlicker.Frequency == AECV2_FLICKER_FREQUENCY_50HZ) {
603 *freq = EXP_PWR_LINE_FREQ_50HZ;
604 } else if (expSwAttr.stAuto.stAntiFlicker.Frequency == AECV2_FLICKER_FREQUENCY_60HZ) {
605 *freq = EXP_PWR_LINE_FREQ_60HZ;
606 } else if (expSwAttr.stAuto.stAntiFlicker.Frequency == AECV2_FLICKER_FREQUENCY_OFF) {
607 *freq = EXP_PWR_LINE_FREQ_DIS;
608 } else {
609 ret = XCAM_RETURN_ERROR_PARAM;
610 RKAIQ_IMGPROC_CHECK_RET(ret, "freq is invalid!");
611 }
612 IMGPROC_FUNC_EXIT
613 return (ret);
614
615 }
616
617 /*
618 *****************************
619 *
620 * Desc: Adjust image gamma
621 *
622 * Argument:
623 * GammaCoef: [0, 100]
624 * SlopeAtZero: [-0.05, 0.05]
625 *****************************
626 */
rk_aiq_uapi2_setGammaCoef(const rk_aiq_sys_ctx_t * ctx,float GammaCoef,float SlopeAtZero)627 XCamReturn rk_aiq_uapi2_setGammaCoef(const rk_aiq_sys_ctx_t* ctx, float GammaCoef, float SlopeAtZero)
628 {
629 XCamReturn ret = XCAM_RETURN_NO_ERROR;
630 IMGPROC_FUNC_ENTER
631 if (ctx == NULL) {
632 ret = XCAM_RETURN_ERROR_PARAM;
633 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setGammaCoef failed!");
634 }
635
636 if (GammaCoef < 0 || GammaCoef > 100) {
637 ret = XCAM_RETURN_ERROR_PARAM;
638 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, GammaCoef range is [0,100]!");
639 }
640 if (SlopeAtZero < -0.05 || SlopeAtZero > 0.05) {
641 ret = XCAM_RETURN_ERROR_PARAM;
642 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, SlopeAtZero range is [-0.05,0.05]!");
643 }
644
645 #if RKAIQ_HAVE_GAMMA_V10
646 rk_aiq_gamma_v10_attr_t gammaAttr;
647 memset(&gammaAttr, 0x0, sizeof(rk_aiq_gamma_v10_attr_t));
648 gammaAttr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
649 gammaAttr.sync.done = false;
650
651 gammaAttr.mode = RK_AIQ_GAMMA_MODE_AUTO;
652 gammaAttr.stAuto.GammaTuningPara.Gamma_en = true;
653 gammaAttr.stAuto.GammaTuningPara.Gamma_out_segnum = GAMMATYPE_LOG;
654 gammaAttr.stAuto.GammaTuningPara.Gamma_out_offset = 0;
655 float gamma_X_v10[CALIBDB_AGAMMA_KNOTS_NUM_V10] = {
656 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24,
657 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,
658 384, 448, 512, 640, 768, 896, 1024, 1280, 1536, 1792, 2048, 2560, 3072, 3584, 4095
659 };
660 float gamma_Y_v10[CALIBDB_AGAMMA_KNOTS_NUM_V10];
661 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V10; i++) {
662 gamma_Y_v10[i] = 4095 * pow(gamma_X_v10[i] / 4095, 1 / GammaCoef + SlopeAtZero);
663 gamma_Y_v10[i] = gamma_Y_v10[i] > 4095 ? 4095 : gamma_Y_v10[i] < 0 ? 0 : gamma_Y_v10[i];
664 gammaAttr.stAuto.GammaTuningPara.Gamma_curve[i] = (int)(gamma_Y_v10[i] + 0.5);
665 }
666 ret = rk_aiq_user_api2_agamma_v10_SetAttrib(ctx, &gammaAttr);
667 #endif
668 #if RKAIQ_HAVE_GAMMA_V11
669 rk_aiq_gamma_v11_attr_t gammaAttr;
670 memset(&gammaAttr, 0x0, sizeof(rk_aiq_gamma_v11_attr_t));
671 gammaAttr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
672 gammaAttr.sync.done = false;
673
674 gammaAttr.mode = RK_AIQ_GAMMA_MODE_AUTO;
675 gammaAttr.stAuto.GammaTuningPara.Gamma_en = true;
676 gammaAttr.stAuto.GammaTuningPara.Gamma_out_offset = 0;
677 float gamma_X_v11[CALIBDB_AGAMMA_KNOTS_NUM_V11] = {
678 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16,
679 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160,
680 192, 224, 256, 320, 384, 448, 512, 640, 768, 896, 1024, 1280, 1536,
681 1792, 2048, 2304, 2560, 2816, 3072, 3328, 3584, 3840, 4095
682 };
683 float gamma_Y_v11[CALIBDB_AGAMMA_KNOTS_NUM_V11];
684 for (int i = 0; i < CALIBDB_AGAMMA_KNOTS_NUM_V11; i++) {
685 gamma_Y_v11[i] = 4095 * pow(gamma_X_v11[i] / 4095, 1 / GammaCoef + SlopeAtZero);
686 gamma_Y_v11[i] = gamma_Y_v11[i] > 4095 ? 4095 : gamma_Y_v11[i] < 0 ? 0 : gamma_Y_v11[i];
687 gammaAttr.stAuto.GammaTuningPara.Gamma_curve[i] = (int)(gamma_Y_v11[i] + 0.5);
688 }
689 ret = rk_aiq_user_api2_agamma_v11_SetAttrib(ctx, &gammaAttr);
690 #endif
691
692 IMGPROC_FUNC_EXIT
693 return ret;
694 }
695 /*
696 *****************************
697 *
698 * Desc: set manual dehaze module enable
699 * enable/disable dehaze module function, including dehaze, enhance and hist
700 *
701 *****************************
702 */
rk_aiq_uapi2_setDehazeModuleEnable(const rk_aiq_sys_ctx_t * ctx,bool on)703 XCamReturn rk_aiq_uapi2_setDehazeModuleEnable(const rk_aiq_sys_ctx_t* ctx, bool on) {
704 XCamReturn ret = XCAM_RETURN_NO_ERROR;
705 IMGPROC_FUNC_ENTER
706
707 if (ctx == NULL) {
708 ret = XCAM_RETURN_ERROR_PARAM;
709 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
710 }
711 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
712 adehaze_sw_v11_t attr_v11;
713 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
714 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
715
716 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
717 attr_v11.sync.done = false;
718
719 if (attr_v11.mode == DEHAZE_API_AUTO) {
720 if (on)
721 attr_v11.stAuto.DehazeTuningPara.Enable = true;
722 else
723 attr_v11.stAuto.DehazeTuningPara.Enable = false;
724 } else if (attr_v11.mode == DEHAZE_API_MANUAL) {
725 if (on)
726 attr_v11.stManual.Enable = true;
727 else
728 attr_v11.stManual.Enable = false;
729 }
730 ret = rk_aiq_user_api2_adehaze_v11_setSwAttrib(ctx, &attr_v11);
731 RKAIQ_IMGPROC_CHECK_RET(ret, "setDehazeModuleEnable failed!");
732 #endif
733 #if RKAIQ_HAVE_DEHAZE_V12
734 adehaze_sw_v12_t attr_v12;
735 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
736 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
737
738 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
739 attr_v12.sync.done = false;
740
741 if (attr_v12.mode == DEHAZE_API_AUTO) {
742 if (on)
743 attr_v12.stAuto.DehazeTuningPara.Enable = true;
744 else
745 attr_v12.stAuto.DehazeTuningPara.Enable = false;
746 } else if (attr_v12.mode == DEHAZE_API_MANUAL) {
747 if (on)
748 attr_v12.stManual.Enable = true;
749 else
750 attr_v12.stManual.Enable = false;
751 }
752 ret = rk_aiq_user_api2_adehaze_v12_setSwAttrib(ctx, &attr_v12);
753 RKAIQ_IMGPROC_CHECK_RET(ret, "setDehazeModuleEnable failed!");
754 #endif
755 IMGPROC_FUNC_EXIT
756 return ret;
757 }
758
759 /*
760 *****************************
761 *
762 * Desc: set manual dehaze enable
763 * enable/disable dehaze function
764 *
765 *****************************
766 */
rk_aiq_uapi2_setDehazeEnable(const rk_aiq_sys_ctx_t * ctx,bool on)767 XCamReturn rk_aiq_uapi2_setDehazeEnable(const rk_aiq_sys_ctx_t* ctx, bool on) {
768 XCamReturn ret = XCAM_RETURN_NO_ERROR;
769 IMGPROC_FUNC_ENTER
770
771 if (ctx == NULL) {
772 ret = XCAM_RETURN_ERROR_PARAM;
773 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
774 }
775 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
776 adehaze_sw_v11_t attr_v11;
777 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
778 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
779
780 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
781 attr_v11.sync.done = false;
782
783 if (attr_v11.mode == DEHAZE_API_AUTO) {
784 if (on) {
785 attr_v11.stAuto.DehazeTuningPara.dehaze_setting.en = true;
786 attr_v11.stAuto.DehazeTuningPara.enhance_setting.en = false;
787 } else
788 attr_v11.stAuto.DehazeTuningPara.dehaze_setting.en = false;
789 } else if (attr_v11.mode == DEHAZE_API_MANUAL) {
790 if (on) {
791 attr_v11.stManual.dehaze_setting.en = true;
792 attr_v11.stManual.enhance_setting.en = false;
793 } else
794 attr_v11.stManual.dehaze_setting.en = false;
795 }
796 ret = rk_aiq_user_api2_adehaze_v11_setSwAttrib(ctx, &attr_v11);
797 RKAIQ_IMGPROC_CHECK_RET(ret, "setDehazeEnable failed!");
798 #endif
799 #if RKAIQ_HAVE_DEHAZE_V12
800 adehaze_sw_v12_t attr_v12;
801 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
802 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
803
804 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
805 attr_v12.sync.done = false;
806
807 if (attr_v12.mode == DEHAZE_API_AUTO) {
808 if (on) {
809 attr_v12.stAuto.DehazeTuningPara.dehaze_setting.en = true;
810 attr_v12.stAuto.DehazeTuningPara.enhance_setting.en = false;
811 } else
812 attr_v12.stAuto.DehazeTuningPara.dehaze_setting.en = false;
813 } else if (attr_v12.mode == DEHAZE_API_MANUAL) {
814 if (on) {
815 attr_v12.stManual.dehaze_setting.en = true;
816 attr_v12.stManual.enhance_setting.en = false;
817 } else
818 attr_v12.stManual.dehaze_setting.en = false;
819 }
820 ret = rk_aiq_user_api2_adehaze_v12_setSwAttrib(ctx, &attr_v12);
821 RKAIQ_IMGPROC_CHECK_RET(ret, "setDehazeEnable failed!");
822 #endif
823 IMGPROC_FUNC_EXIT
824 return ret;
825 }
826
827 /*
828 *****************************
829 *
830 * Desc: set/get manual dehaze strength
831 * this function is active for dehaze is manual mode
832 * Argument:
833 * level: [0, 100]
834 *
835 *****************************
836 */
rk_aiq_uapi2_setMDehazeStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int level)837 XCamReturn rk_aiq_uapi2_setMDehazeStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
838 {
839 XCamReturn ret = XCAM_RETURN_NO_ERROR;
840 IMGPROC_FUNC_ENTER
841 if (ctx == NULL) {
842 ret = XCAM_RETURN_ERROR_PARAM;
843 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
844 }
845 if (level > 100) {
846 ret = XCAM_RETURN_ERROR_PARAM;
847 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, strength range is [0,100]!");
848 }
849 #if RKAIQ_HAVE_DEHAZE_V10
850 #if 0
851 adehaze_sw_v10_t attr_v10;
852 memset(&attr_v10, 0, sizeof(adehaze_sw_v10_t));
853 ret = rk_aiq_user_api2_adehaze_v10_getSwAttrib(ctx, &attr_v10);
854 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
855
856 attr_v10.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
857 attr_v10.sync.done = false;
858 attr_v10.mode = DEHAZE_API_AUTO;
859 attr_v10.stAuto.DehazeTuningPara.Enable = true;
860 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.en = true;
861 attr_v10.stAuto.DehazeTuningPara.enhance_setting.en = false;
862 attr_v10.stAuto.DehazeTuningPara.cfg_alpha = NORMALIZE_MAX;
863 attr_v10.stAuto.DehazeTuningPara.ByPassThr = NORMALIZE_MIN;
864 // attr_v10.i.MDehazeStrth = level;
865 for (int i = 0; i < attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.CtrlData_len;
866 i++) {
867 float level_diff = (float)(level - DEHAZE_DEFAULT_LEVEL);
868 // sw_dhaz_cfg_wt
869 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_wt[i] +=
870 level_diff * DEHAZE_DEFAULT_CFG_WT_STEP;
871 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_wt[i] =
872 LIMIT_VALUE(attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_wt[i],
873 NORMALIZE_MAX, NORMALIZE_MIN);
874
875 // sw_dhaz_cfg_air
876 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_air[i] +=
877 level_diff * DEHAZE_DEFAULT_CFG_AIR_STEP;
878 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_air[i] = LIMIT_VALUE(
879 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_air[i], 255, 0);
880
881 // sw_dhaz_cfg_tmax
882 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_tmax[i] +=
883 level_diff * DEHAZE_DEFAULT_CFG_TMAX_STEP;
884 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_tmax[i] =
885 LIMIT_VALUE(attr_v10.stAuto.DehazeTuningPara.dehaze_setting.DehazeData.cfg_tmax[i],
886 NORMALIZE_MAX, NORMALIZE_MIN);
887 }
888
889 ret = rk_aiq_user_api2_adehaze_v10_setSwAttrib(ctx, &attr_v10);
890 RKAIQ_IMGPROC_CHECK_RET(ret, "setMDhzStrth failed!");
891 #endif
892 #endif
893 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
894 adehaze_sw_v11_t attr_v11;
895 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
896 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
897 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
898 if (attr_v11.mode == DEHAZE_API_AUTO) {
899 if (!attr_v11.stAuto.DehazeTuningPara.Enable ||
900 !attr_v11.stAuto.DehazeTuningPara.dehaze_setting.en ||
901 attr_v11.stAuto.DehazeTuningPara.enhance_setting.en) {
902 LOGW_ADEHAZE("%s: Dehaze is OFF! level is invalid\n", __FUNCTION__);
903 }
904 } else if (attr_v11.mode == DEHAZE_API_MANUAL) {
905 if (!attr_v11.stManual.Enable || !attr_v11.stManual.dehaze_setting.en ||
906 attr_v11.stManual.enhance_setting.en) {
907 LOGW_ADEHAZE("%s: Dehaze is OFF! level is invalid\n", __FUNCTION__);
908 }
909 }
910
911 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
912 attr_v11.sync.done = false;
913 attr_v11.Info.updateMDehazeStrth = true;
914 attr_v11.Info.MDehazeStrth = level;
915 ret = rk_aiq_user_api2_adehaze_v11_setSwAttrib(ctx, &attr_v11);
916 RKAIQ_IMGPROC_CHECK_RET(ret, "setMDhzStrth failed!");
917 #endif
918 #if RKAIQ_HAVE_DEHAZE_V12
919 adehaze_sw_v12_t attr_v12;
920 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
921 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
922 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
923 if (attr_v12.mode == DEHAZE_API_AUTO) {
924 if (!attr_v12.stAuto.DehazeTuningPara.Enable ||
925 !attr_v12.stAuto.DehazeTuningPara.dehaze_setting.en ||
926 attr_v12.stAuto.DehazeTuningPara.enhance_setting.en) {
927 LOGW_ADEHAZE("%s: Dehaze is OFF! level is invalid\n", __FUNCTION__);
928 }
929 } else if (attr_v12.mode == DEHAZE_API_MANUAL) {
930 if (!attr_v12.stManual.Enable || !attr_v12.stManual.dehaze_setting.en ||
931 attr_v12.stManual.enhance_setting.en) {
932 LOGW_ADEHAZE("%s: Dehaze is OFF! level is invalid\n", __FUNCTION__);
933 }
934 }
935
936 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
937 attr_v12.sync.done = false;
938 attr_v12.Info.updateMDehazeStrth = true;
939 attr_v12.Info.MDehazeStrth = level;
940 ret = rk_aiq_user_api2_adehaze_v12_setSwAttrib(ctx, &attr_v12);
941 RKAIQ_IMGPROC_CHECK_RET(ret, "setMDhzStrth failed!");
942 #endif
943
944 IMGPROC_FUNC_EXIT
945 return ret;
946 }
947
rk_aiq_uapi2_getMDehazeStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)948 XCamReturn rk_aiq_uapi2_getMDehazeStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
949 {
950 XCamReturn ret = XCAM_RETURN_NO_ERROR;
951 IMGPROC_FUNC_ENTER
952 if (ctx == NULL) {
953 ret = XCAM_RETURN_ERROR_PARAM;
954 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
955 }
956 #if RKAIQ_HAVE_DEHAZE_V10
957 adehaze_sw_v10_info_t attr_v10_info;
958 memset(&attr_v10_info, 0, sizeof(adehaze_sw_v10_info_t));
959 ret = rk_aiq_user_api2_adehaze_v10_getSwAttrib(ctx, &attr_v10_info);
960 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed in get attrib!");
961 *level = attr_v10_info.CtrlInfo.MDehazeStrth;
962 #endif
963 #if RKAIQ_HAVE_DEHAZE_V11
964 adehaze_sw_v11_t attr_v11;
965 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
966 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
967 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed in get attrib!");
968 *level = attr_v11.Info.MDehazeStrth;
969 #endif
970 #if RKAIQ_HAVE_DEHAZE_V12
971 adehaze_sw_v12_t attr_v12;
972 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
973 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
974 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed in get attrib!");
975 *level = attr_v12.Info.MDehazeStrth;
976 #endif
977
978 IMGPROC_FUNC_EXIT
979 return ret;
980 }
981
982 /*
983 *****************************
984 *
985 * Desc: set manual enhance enable
986 * enable/disable enhance function
987 *
988 *****************************
989 */
rk_aiq_uapi2_setEnhanceEnable(const rk_aiq_sys_ctx_t * ctx,bool on)990 XCamReturn rk_aiq_uapi2_setEnhanceEnable(const rk_aiq_sys_ctx_t* ctx, bool on) {
991 XCamReturn ret = XCAM_RETURN_NO_ERROR;
992 IMGPROC_FUNC_ENTER
993
994 if (ctx == NULL) {
995 ret = XCAM_RETURN_ERROR_PARAM;
996 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
997 }
998 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
999 adehaze_sw_v11_t attr_v11;
1000 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
1001 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
1002
1003 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1004 attr_v11.sync.done = false;
1005
1006 if (attr_v11.mode == DEHAZE_API_AUTO) {
1007 if (on)
1008 attr_v11.stAuto.DehazeTuningPara.enhance_setting.en = true;
1009 else
1010 attr_v11.stAuto.DehazeTuningPara.enhance_setting.en = false;
1011 } else if (attr_v11.mode == DEHAZE_API_MANUAL) {
1012 if (on)
1013 attr_v11.stManual.enhance_setting.en = true;
1014 else
1015 attr_v11.stManual.enhance_setting.en = false;
1016 }
1017 ret = rk_aiq_user_api2_adehaze_v11_setSwAttrib(ctx, &attr_v11);
1018 RKAIQ_IMGPROC_CHECK_RET(ret, "setEnhanceEnable failed!");
1019 #endif
1020 #if RKAIQ_HAVE_DEHAZE_V12
1021 adehaze_sw_v12_t attr_v12;
1022 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
1023 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
1024
1025 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1026 attr_v12.sync.done = false;
1027
1028 if (attr_v12.mode == DEHAZE_API_AUTO) {
1029 if (on)
1030 attr_v12.stAuto.DehazeTuningPara.enhance_setting.en = true;
1031 else
1032 attr_v12.stAuto.DehazeTuningPara.enhance_setting.en = false;
1033 } else if (attr_v12.mode == DEHAZE_API_MANUAL) {
1034 if (on)
1035 attr_v12.stManual.enhance_setting.en = true;
1036 else
1037 attr_v12.stManual.enhance_setting.en = false;
1038 }
1039 ret = rk_aiq_user_api2_adehaze_v12_setSwAttrib(ctx, &attr_v12);
1040 RKAIQ_IMGPROC_CHECK_RET(ret, "setEnhanceEnable failed!");
1041 #endif
1042 IMGPROC_FUNC_EXIT
1043 return ret;
1044 }
1045
1046 /*
1047 *****************************
1048 *
1049 * Desc: set/get manual enhance strength
1050 * this function is active for dehaze is manual mode
1051 * Argument:
1052 * level: [0, 100]
1053 *
1054 *****************************
1055 */
rk_aiq_uapi2_setMEnhanceStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int level)1056 XCamReturn rk_aiq_uapi2_setMEnhanceStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
1057 {
1058 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1059 IMGPROC_FUNC_ENTER
1060 if (ctx == NULL) {
1061 ret = XCAM_RETURN_ERROR_PARAM;
1062 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1063 }
1064 if (level > 100) {
1065 ret = XCAM_RETURN_ERROR_PARAM;
1066 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, level range is [0,100]!");
1067 }
1068 #if RKAIQ_HAVE_DEHAZE_V10
1069 #if 0
1070 adehaze_sw_v10_info_t attr_v10_info;
1071 memset(&attr_v10_info, 0, sizeof(adehaze_sw_v10_info_t));
1072 ret = rk_aiq_user_api2_adehaze_v10_getSwAttribInfo(ctx, &attr_v10_info);
1073 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzInfo failed!");
1074 attr_v10_info.CtrlInfo.MEnhanceStrth = level;
1075 ret = rk_aiq_user_api2_adehaze_v10_setSwAttribInfo(ctx, &attr_v10_info);
1076 RKAIQ_IMGPROC_CHECK_RET(ret, "setMDhzInfo failed!");
1077
1078 adehaze_sw_v10_t attr_v10;
1079 memset(&attr_v10, 0, sizeof(adehaze_sw_v10_t));
1080 ret = rk_aiq_user_api2_adehaze_v10_getSwAttrib(ctx, &attr_v10);
1081 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
1082 attr_v10.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1083 attr_v10.sync.done = false;
1084 attr_v10.mode = DEHAZE_API_AUTO;
1085 attr_v10.stAuto.DehazeTuningPara.Enable = true;
1086 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.en = false;
1087 attr_v10.stAuto.DehazeTuningPara.enhance_setting.en = true;
1088 attr_v10.stAuto.DehazeTuningPara.cfg_alpha = NORMALIZE_MAX;
1089 attr_v10.stAuto.DehazeTuningPara.ByPassThr = NORMALIZE_MIN;
1090 ret = rk_aiq_user_api2_adehaze_v10_setSwAttrib(ctx, &attr_v10);
1091 RKAIQ_IMGPROC_CHECK_RET(ret, "setMEnhanceStrth failed!");
1092 #endif
1093 #endif
1094 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
1095 adehaze_sw_v11_t attr_v11;
1096 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
1097 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
1098 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
1099 if (attr_v11.mode == DEHAZE_API_AUTO) {
1100 if (!attr_v11.stAuto.DehazeTuningPara.Enable ||
1101 !attr_v11.stAuto.DehazeTuningPara.enhance_setting.en) {
1102 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1103 }
1104 } else if (attr_v11.mode == DEHAZE_API_MANUAL) {
1105 if (!attr_v11.stManual.Enable || !attr_v11.stManual.enhance_setting.en) {
1106 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1107 }
1108 }
1109
1110 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1111 attr_v11.sync.done = false;
1112 attr_v11.Info.updateMEnhanceStrth = true;
1113 attr_v11.Info.MEnhanceStrth = level;
1114 ret = rk_aiq_user_api2_adehaze_v11_setSwAttrib(ctx, &attr_v11);
1115 RKAIQ_IMGPROC_CHECK_RET(ret, "setMEnhanceStrth failed!");
1116 #endif
1117 #if RKAIQ_HAVE_DEHAZE_V12
1118 adehaze_sw_v12_t attr_v12;
1119 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
1120 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
1121 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
1122 if (attr_v12.mode == DEHAZE_API_AUTO) {
1123 if (!attr_v12.stAuto.DehazeTuningPara.Enable ||
1124 !attr_v12.stAuto.DehazeTuningPara.enhance_setting.en) {
1125 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1126 }
1127 } else if (attr_v12.mode == DEHAZE_API_MANUAL) {
1128 if (!attr_v12.stManual.Enable || !attr_v12.stManual.enhance_setting.en) {
1129 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1130 }
1131 }
1132
1133 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1134 attr_v12.sync.done = false;
1135 attr_v12.Info.updateMEnhanceStrth = true;
1136 attr_v12.Info.MEnhanceStrth = level;
1137 ret = rk_aiq_user_api2_adehaze_v12_setSwAttrib(ctx, &attr_v12);
1138 RKAIQ_IMGPROC_CHECK_RET(ret, "setMEnhanceStrth failed!");
1139 #endif
1140
1141 IMGPROC_FUNC_EXIT
1142 return ret;
1143 }
1144
rk_aiq_uapi2_getMEnhanceStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)1145 XCamReturn rk_aiq_uapi2_getMEnhanceStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
1146 {
1147 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1148 IMGPROC_FUNC_ENTER
1149 if (ctx == NULL) {
1150 ret = XCAM_RETURN_ERROR_PARAM;
1151 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1152 }
1153 #if RKAIQ_HAVE_DEHAZE_V10
1154 adehaze_sw_v10_info_t attr_v10_info;
1155 memset(&attr_v10_info, 0, sizeof(adehaze_sw_v10_info_t));
1156 ret = rk_aiq_user_api2_adehaze_v10_getSwAttribInfo(ctx, &attr_v10_info);
1157 RKAIQ_IMGPROC_CHECK_RET(ret, "getMEnhanceStrth failed in get attrib!");
1158 *level = attr_v10_info.CtrlInfo.MEnhanceStrth;
1159 #endif
1160 #if RKAIQ_HAVE_DEHAZE_V11
1161 adehaze_sw_v11_t attr_v11;
1162 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
1163 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
1164 RKAIQ_IMGPROC_CHECK_RET(ret, "getMEnhanceStrth failed in get attrib!");
1165 *level = attr_v11.Info.MEnhanceStrth;
1166 #endif
1167 #if RKAIQ_HAVE_DEHAZE_V12
1168 adehaze_sw_v12_t attr_v12;
1169 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
1170 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
1171 RKAIQ_IMGPROC_CHECK_RET(ret, "getMEnhanceStrth failed in get attrib!");
1172 *level = attr_v12.Info.MEnhanceStrth;
1173 #endif
1174 IMGPROC_FUNC_EXIT
1175 return ret;
1176 }
1177 /*
1178 *****************************
1179 *
1180 * Desc: set/get manual enhance chrome strength
1181 * this function is active for dehaze is manual mode
1182 * Argument:
1183 * level: [0, 100]
1184 *
1185 *****************************
1186 */
rk_aiq_uapi2_setMEnhanceChromeStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int level)1187 XCamReturn rk_aiq_uapi2_setMEnhanceChromeStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level) {
1188 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1189 IMGPROC_FUNC_ENTER
1190 if (ctx == NULL) {
1191 ret = XCAM_RETURN_ERROR_PARAM;
1192 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1193 }
1194 if (level > 100) {
1195 ret = XCAM_RETURN_ERROR_PARAM;
1196 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, level range is [0,100]!");
1197 }
1198 #if RKAIQ_HAVE_DEHAZE_V10
1199 #if 0
1200 adehaze_sw_v10_info_t attr_v10_info;
1201 memset(&attr_v10_info, 0, sizeof(adehaze_sw_v10_info_t));
1202 ret = rk_aiq_user_api2_adehaze_v10_getSwAttribInfo(ctx, &attr_v10_info);
1203 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzInfo failed!");
1204 attr_v10_info.CtrlInfo.MEnhanceChromeStrth = level;
1205 ret = rk_aiq_user_api2_adehaze_v10_setSwAttribInfo(ctx, &attr_v10_info);
1206 RKAIQ_IMGPROC_CHECK_RET(ret, "setMDhzInfo failed!");
1207
1208 adehaze_sw_v10_t attr_v10;
1209 memset(&attr_v10, 0, sizeof(adehaze_sw_v10_t));
1210 ret = rk_aiq_user_api2_adehaze_v10_getSwAttrib(ctx, &attr_v10);
1211 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
1212
1213 attr_v10.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1214 attr_v10.sync.done = false;
1215 attr_v10.mode = DEHAZE_API_AUTO;
1216 attr_v10.stAuto.DehazeTuningPara.Enable = true;
1217 attr_v10.stAuto.DehazeTuningPara.dehaze_setting.en = false;
1218 attr_v10.stAuto.DehazeTuningPara.enhance_setting.en = true;
1219 attr_v10.stAuto.DehazeTuningPara.cfg_alpha = NORMALIZE_MAX;
1220 attr_v10.stAuto.DehazeTuningPara.ByPassThr = NORMALIZE_MIN;
1221 float level_diff = (float)(level - ENHANCE_DEFAULT_LEVEL);
1222 for (int i = 0; i < attr_v10.stAuto.DehazeTuningPara.enhance_setting.EnhanceData.CtrlData_len;
1223 i++) {
1224 // enhance_chroma
1225 attr_v10.stAuto.DehazeTuningPara.enhance_setting.EnhanceData[i].enhance_chroma +=
1226 level_diff * ENHANCE_VALUE_DEFAULT_STEP;
1227 attr_v10.stAuto.DehazeTuningPara.enhance_setting.EnhanceData[i].enhance_chroma =
1228 LIMIT_VALUE(
1229 attr_v10.stAuto.DehazeTuningPara.enhance_setting.EnhanceData[i].enhance_chroma,
1230 16.0, 1.0);
1231 }
1232 ret = rk_aiq_user_api2_adehaze_v10_setSwAttrib(ctx, &attr_v10);
1233 RKAIQ_IMGPROC_CHECK_RET(ret, "setMEnhanceStrth failed!");
1234 #endif
1235 #endif
1236 #if RKAIQ_HAVE_DEHAZE_V11 || RKAIQ_HAVE_DEHAZE_V11_DUO
1237 adehaze_sw_v11_t attr_v11;
1238 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
1239 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
1240 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
1241 if (attr_v11.mode == DEHAZE_API_AUTO) {
1242 if (!attr_v11.stAuto.DehazeTuningPara.Enable ||
1243 !attr_v11.stAuto.DehazeTuningPara.enhance_setting.en) {
1244 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1245 }
1246 } else if (attr_v11.mode == DEHAZE_API_MANUAL) {
1247 if (!attr_v11.stManual.Enable || !attr_v11.stManual.enhance_setting.en) {
1248 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1249 }
1250 }
1251
1252 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1253 attr_v11.sync.done = false;
1254 attr_v11.Info.updateMEnhanceChromeStrth = true;
1255 attr_v11.Info.MEnhanceChromeStrth = level;
1256 ret = rk_aiq_user_api2_adehaze_v11_setSwAttrib(ctx, &attr_v11);
1257 RKAIQ_IMGPROC_CHECK_RET(ret, "setMEnhanceStrth failed!");
1258 #endif
1259 #if RKAIQ_HAVE_DEHAZE_V12
1260 adehaze_sw_v12_t attr_v12;
1261 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
1262 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
1263 RKAIQ_IMGPROC_CHECK_RET(ret, "getMDhzStrth failed!");
1264 if (attr_v12.mode == DEHAZE_API_AUTO) {
1265 if (!attr_v12.stAuto.DehazeTuningPara.Enable ||
1266 !attr_v12.stAuto.DehazeTuningPara.enhance_setting.en) {
1267 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1268 }
1269 } else if (attr_v12.mode == DEHAZE_API_MANUAL) {
1270 if (!attr_v12.stManual.Enable || !attr_v12.stManual.enhance_setting.en) {
1271 LOGW_ADEHAZE("%s: Enhance is OFF! level is invalid\n", __FUNCTION__);
1272 }
1273 }
1274
1275 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1276 attr_v12.sync.done = false;
1277 attr_v12.Info.updateMEnhanceChromeStrth = true;
1278 attr_v12.Info.MEnhanceChromeStrth = level;
1279 ret = rk_aiq_user_api2_adehaze_v12_setSwAttrib(ctx, &attr_v12);
1280 RKAIQ_IMGPROC_CHECK_RET(ret, "setMEnhanceStrth failed!");
1281 #endif
1282
1283 IMGPROC_FUNC_EXIT
1284
1285 return ret;
1286 }
1287
rk_aiq_uapi2_getMEnhanceChromeStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)1288 XCamReturn rk_aiq_uapi2_getMEnhanceChromeStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int* level) {
1289 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1290 IMGPROC_FUNC_ENTER
1291 if (ctx == NULL) {
1292 ret = XCAM_RETURN_ERROR_PARAM;
1293 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1294 }
1295 #if RKAIQ_HAVE_DEHAZE_V10
1296 adehaze_sw_v10_info_t attr_v10_info;
1297 memset(&attr_v10_info, 0, sizeof(adehaze_sw_v10_info_t));
1298 ret = rk_aiq_user_api2_adehaze_v10_getSwAttribInfo(ctx, &attr_v10_info);
1299 RKAIQ_IMGPROC_CHECK_RET(ret, "getMEnhanceChromeStrth failed in get attrib!");
1300 *level = attr_v10_info.CtrlInfo.MEnhanceChromeStrth;
1301 #endif
1302 #if RKAIQ_HAVE_DEHAZE_V11
1303 adehaze_sw_v11_t attr_v11;
1304 memset(&attr_v11, 0, sizeof(adehaze_sw_v11_t));
1305 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(ctx, &attr_v11);
1306 RKAIQ_IMGPROC_CHECK_RET(ret, "getMEnhanceChromeStrth failed in get attrib!");
1307 *level = attr_v11.Info.MEnhanceChromeStrth;
1308 #endif
1309 #if RKAIQ_HAVE_DEHAZE_V12
1310 adehaze_sw_v12_t attr_v12;
1311 memset(&attr_v12, 0, sizeof(adehaze_sw_v12_t));
1312 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(ctx, &attr_v12);
1313 RKAIQ_IMGPROC_CHECK_RET(ret, "getMEnhanceChromeStrth failed in get attrib!");
1314 *level = attr_v12.Info.MEnhanceChromeStrth;
1315 #endif
1316 IMGPROC_FUNC_EXIT
1317 return ret;
1318 }
1319
1320 /*
1321 *****************************
1322 *
1323 * Desc: set/get manual drc Local TMO
1324 * this function is active for DRC is Auto mode
1325 * use in RK356x, RV1106
1326 * Argument:
1327 * LocalWeit: [0, 1]
1328 * GlobalContrast: [0, 1]
1329 * LoLitContrast: [0, 1]
1330 * only valid in RK356x
1331 *****************************
1332 */
rk_aiq_uapi2_setDrcLocalTMO(const rk_aiq_sys_ctx_t * ctx,float LocalWeit,float GlobalContrast,float LoLitContrast)1333 XCamReturn rk_aiq_uapi2_setDrcLocalTMO(const rk_aiq_sys_ctx_t* ctx, float LocalWeit, float GlobalContrast, float LoLitContrast)
1334 {
1335 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1336 IMGPROC_FUNC_ENTER
1337
1338 if (ctx == NULL) {
1339 ret = XCAM_RETURN_ERROR_PARAM;
1340 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1341 }
1342 if (LocalWeit < 0 || LocalWeit > 1) {
1343 ret = XCAM_RETURN_ERROR_PARAM;
1344 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalWeit range is [0,1]!");
1345 }
1346 if (GlobalContrast < 0 || GlobalContrast > 1) {
1347 ret = XCAM_RETURN_ERROR_PARAM;
1348 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, GlobalContrast range is [0,1]!");
1349 }
1350 if (LoLitContrast < 0 || LoLitContrast > 1) {
1351 ret = XCAM_RETURN_ERROR_PARAM;
1352 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LoLitContrast range is [0,1]!");
1353 }
1354
1355 #if RKAIQ_HAVE_DRC_V10
1356 drcAttrV10_t attr_v10;
1357 memset(&attr_v10, 0, sizeof(drcAttrV10_t));
1358 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(ctx, &attr_v10);
1359 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalTMO failed in get attrib!");
1360 attr_v10.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1361 attr_v10.sync.done = false;
1362
1363 if (attr_v10.opMode == DRC_OPMODE_AUTO) {
1364 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1365 attr_v10.stAuto.DrcTuningPara.LocalTMOSetting.LocalTMOData.LocalWeit[i] = LocalWeit;
1366 attr_v10.stAuto.DrcTuningPara.LocalTMOSetting.LocalTMOData.GlobalContrast[i] =
1367 GlobalContrast;
1368 attr_v10.stAuto.DrcTuningPara.LocalTMOSetting.LocalTMOData.LoLitContrast[i] =
1369 LoLitContrast;
1370 }
1371 } else if (attr_v10.opMode == DRC_OPMODE_MANUAL) {
1372 attr_v10.stManual.LocalTMOSetting.LocalTMOData.LocalWeit = LocalWeit;
1373 attr_v10.stManual.LocalTMOSetting.LocalTMOData.GlobalContrast = GlobalContrast;
1374 attr_v10.stManual.LocalTMOSetting.LocalTMOData.LoLitContrast = LoLitContrast;
1375 }
1376 ret = rk_aiq_user_api2_adrc_v10_SetAttrib(ctx, &attr_v10);
1377 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcLocalTMO failed!");
1378 #endif
1379 #if RKAIQ_HAVE_DRC_V11
1380 ret = XCAM_RETURN_ERROR_PARAM;
1381 RKAIQ_IMGPROC_CHECK_RET(ret,
1382 "RK3588 do not support rk_aiq_uapi2_setDrcLocalTMO! Please use "
1383 "rk_aiq_uapi2_setDrcLocalData");
1384 #endif
1385 #if RKAIQ_HAVE_DRC_V12
1386 ret = XCAM_RETURN_ERROR_PARAM;
1387 RKAIQ_IMGPROC_CHECK_RET(ret,
1388 "RV1106 do not support rk_aiq_uapi2_setDrcLocalTMO! Please use "
1389 "rk_aiq_uapi2_setDrcLocalData");
1390 #endif
1391 #if RKAIQ_HAVE_DRC_V12_LITE
1392 ret = XCAM_RETURN_ERROR_PARAM;
1393 RKAIQ_IMGPROC_CHECK_RET(ret,
1394 "RK3562 do not support rk_aiq_uapi2_setDrcLocalTMO! Please use "
1395 "rk_aiq_uapi2_setDrcLocalData");
1396 #endif
1397
1398 IMGPROC_FUNC_EXIT
1399 return ret;
1400 }
1401
rk_aiq_uapi2_getDrcLocalTMO(const rk_aiq_sys_ctx_t * ctx,float * LocalWeit,float * GlobalContrast,float * LoLitContrast)1402 XCamReturn rk_aiq_uapi2_getDrcLocalTMO(const rk_aiq_sys_ctx_t* ctx, float * LocalWeit, float * GlobalContrast, float * LoLitContrast)
1403 {
1404 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1405
1406 IMGPROC_FUNC_ENTER
1407 if (ctx == NULL) {
1408 ret = XCAM_RETURN_ERROR_PARAM;
1409 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1410 }
1411
1412 #if RKAIQ_HAVE_DRC_V10
1413 drcAttrV10_t attr_v10;
1414 memset(&attr_v10, 0, sizeof(drcAttrV10_t));
1415 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(ctx, &attr_v10);
1416 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalTMO failed in get attrib!");
1417 *LocalWeit = attr_v10.Info.ValidParams.LocalTMOSetting.LocalTMOData.LocalWeit;
1418 *GlobalContrast = attr_v10.Info.ValidParams.LocalTMOSetting.LocalTMOData.GlobalContrast;
1419 *LoLitContrast = attr_v10.Info.ValidParams.LocalTMOSetting.LocalTMOData.LoLitContrast;
1420 #endif
1421 #if RKAIQ_HAVE_DRC_V11
1422 ret = XCAM_RETURN_ERROR_PARAM;
1423 RKAIQ_IMGPROC_CHECK_RET(ret,
1424 "RK3588 do not support rk_aiq_uapi2_getDrcLocalTMO! Please use "
1425 "rk_aiq_uapi2_getDrcLocalData");
1426 #endif
1427 #if RKAIQ_HAVE_DRC_V12
1428 ret = XCAM_RETURN_ERROR_PARAM;
1429 RKAIQ_IMGPROC_CHECK_RET(ret,
1430 "RV1106 do not support rk_aiq_uapi2_getDrcLocalTMO! Please use "
1431 "rk_aiq_uapi2_getDrcLocalData");
1432 #endif
1433 #if RKAIQ_HAVE_DRC_V12_LITE
1434 ret = XCAM_RETURN_ERROR_PARAM;
1435 RKAIQ_IMGPROC_CHECK_RET(ret,
1436 "RK3562 do not support rk_aiq_uapi2_getDrcLocalTMO! Please use "
1437 "rk_aiq_uapi2_getDrcLocalData");
1438 #endif
1439
1440 IMGPROC_FUNC_EXIT
1441 return ret;
1442 }
1443 /*
1444 *****************************
1445 *
1446 * Desc: set/get manual drc Local Data
1447 * this function is active for DRC is Auto mode
1448 * use in RK356x, RV1106
1449 * Argument:
1450 * LocalWeit: [0, 1]
1451 * GlobalContrast: [0, 1]
1452 * LoLitContrast: [0, 1]
1453 * LocalAutoEnable: [0, 1]
1454 * LocalAutoWeit: [0, 1]
1455 *
1456 *****************************
1457 */
rk_aiq_uapi2_setDrcLocalData(const rk_aiq_sys_ctx_t * ctx,float LocalWeit,float GlobalContrast,float LoLitContrast,int LocalAutoEnable,float LocalAutoWeit)1458 XCamReturn rk_aiq_uapi2_setDrcLocalData(const rk_aiq_sys_ctx_t* ctx, float LocalWeit, float GlobalContrast,
1459 float LoLitContrast, int LocalAutoEnable, float LocalAutoWeit)
1460 {
1461 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1462 IMGPROC_FUNC_ENTER
1463
1464 if (ctx == NULL) {
1465 ret = XCAM_RETURN_ERROR_PARAM;
1466 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1467 }
1468 if (LocalWeit < 0 || LocalWeit > 1) {
1469 ret = XCAM_RETURN_ERROR_PARAM;
1470 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalWeit range is [0,1]!");
1471 }
1472 if (GlobalContrast < 0 || GlobalContrast > 1) {
1473 ret = XCAM_RETURN_ERROR_PARAM;
1474 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, GlobalContrast range is [0,1]!");
1475 }
1476 if (LoLitContrast < 0 || LoLitContrast > 1) {
1477 ret = XCAM_RETURN_ERROR_PARAM;
1478 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LoLitContrast range is [0,1]!");
1479 }
1480 if (LocalAutoEnable < 0 || LocalAutoEnable > 1) {
1481 ret = XCAM_RETURN_ERROR_PARAM;
1482 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalAutoEnable range is [0,1]!");
1483 }
1484 if (LocalAutoWeit < 0 || LocalAutoWeit > 1) {
1485 ret = XCAM_RETURN_ERROR_PARAM;
1486 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, LocalAutoWeit range is [0,1]!");
1487 }
1488 #if RKAIQ_HAVE_DRC_V10
1489 ret = XCAM_RETURN_ERROR_PARAM;
1490 RKAIQ_IMGPROC_CHECK_RET(ret,
1491 "RK356x do not support rk_aiq_uapi2_setDrcLocalData! Please use "
1492 "rk_aiq_uapi2_setDrcLocalTMO");
1493 #endif
1494 #if RKAIQ_HAVE_DRC_V11
1495 drcAttrV11_t attr_v11;
1496 memset(&attr_v11, 0, sizeof(drcAttrV11_t));
1497 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(ctx, &attr_v11);
1498 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalData failed!");
1499 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1500 attr_v11.sync.done = false;
1501
1502 if (attr_v11.opMode == DRC_OPMODE_AUTO) {
1503 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1504 attr_v11.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalWeit[i] = LocalWeit;
1505 attr_v11.stAuto.DrcTuningPara.LocalSetting.LocalData.GlobalContrast[i] = GlobalContrast;
1506 attr_v11.stAuto.DrcTuningPara.LocalSetting.LocalData.LoLitContrast[i] = LoLitContrast;
1507 attr_v11.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalAutoEnable[i] =
1508 LocalAutoEnable;
1509 attr_v11.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalAutoWeit[i] = LocalAutoWeit;
1510 }
1511 } else if (attr_v11.opMode == DRC_OPMODE_MANUAL) {
1512 attr_v11.stManual.LocalSetting.LocalData.LocalWeit = LocalWeit;
1513 attr_v11.stManual.LocalSetting.LocalData.GlobalContrast = GlobalContrast;
1514 attr_v11.stManual.LocalSetting.LocalData.LoLitContrast = LoLitContrast;
1515 attr_v11.stManual.LocalSetting.LocalData.LocalAutoEnable = LocalAutoEnable;
1516 attr_v11.stManual.LocalSetting.LocalData.LocalAutoWeit = LocalAutoWeit;
1517 }
1518 ret = rk_aiq_user_api2_adrc_v11_SetAttrib(ctx, &attr_v11);
1519 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!");
1520 #endif
1521 #if RKAIQ_HAVE_DRC_V12
1522 drcAttrV12_t attr_v12;
1523 memset(&attr_v12, 0, sizeof(drcAttrV12_t));
1524 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(ctx, &attr_v12);
1525 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalData failed!");
1526 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1527 attr_v12.sync.done = false;
1528 if (attr_v12.opMode == DRC_OPMODE_AUTO) {
1529 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1530 attr_v12.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalWeit[i] = LocalWeit;
1531 attr_v12.stAuto.DrcTuningPara.LocalSetting.LocalData.GlobalContrast[i] = GlobalContrast;
1532 attr_v12.stAuto.DrcTuningPara.LocalSetting.LocalData.LoLitContrast[i] = LoLitContrast;
1533 attr_v12.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalAutoEnable[i] =
1534 LocalAutoEnable;
1535 attr_v12.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalAutoWeit[i] = LocalAutoWeit;
1536 }
1537 } else if (attr_v12.opMode == DRC_OPMODE_MANUAL) {
1538 attr_v12.stManual.LocalSetting.LocalData.LocalWeit = LocalWeit;
1539 attr_v12.stManual.LocalSetting.LocalData.GlobalContrast = GlobalContrast;
1540 attr_v12.stManual.LocalSetting.LocalData.LoLitContrast = LoLitContrast;
1541 attr_v12.stManual.LocalSetting.LocalData.LocalAutoEnable = LocalAutoEnable;
1542 attr_v12.stManual.LocalSetting.LocalData.LocalAutoWeit = LocalAutoWeit;
1543 }
1544 ret = rk_aiq_user_api2_adrc_v12_SetAttrib(ctx, &attr_v12);
1545 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!");
1546 #endif
1547 #if RKAIQ_HAVE_DRC_V12_LITE
1548 drcAttrV12Lite_t attr_v12_lite;
1549 memset(&attr_v12_lite, 0, sizeof(drcAttrV12Lite_t));
1550 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(ctx, &attr_v12_lite);
1551 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalData failed!");
1552 attr_v12_lite.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1553 attr_v12_lite.sync.done = false;
1554 if (attr_v12_lite.opMode == DRC_OPMODE_AUTO) {
1555 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1556 attr_v12_lite.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalWeit[i] = LocalWeit;
1557 attr_v12_lite.stAuto.DrcTuningPara.LocalSetting.LocalData.GlobalContrast[i] =
1558 GlobalContrast;
1559 attr_v12_lite.stAuto.DrcTuningPara.LocalSetting.LocalData.LoLitContrast[i] =
1560 LoLitContrast;
1561 attr_v12_lite.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalAutoEnable[i] =
1562 LocalAutoEnable;
1563 attr_v12_lite.stAuto.DrcTuningPara.LocalSetting.LocalData.LocalAutoWeit[i] =
1564 LocalAutoWeit;
1565 }
1566 } else if (attr_v12_lite.opMode == DRC_OPMODE_MANUAL) {
1567 attr_v12_lite.stManual.LocalSetting.LocalData.LocalWeit = LocalWeit;
1568 attr_v12_lite.stManual.LocalSetting.LocalData.GlobalContrast = GlobalContrast;
1569 attr_v12_lite.stManual.LocalSetting.LocalData.LoLitContrast = LoLitContrast;
1570 attr_v12_lite.stManual.LocalSetting.LocalData.LocalAutoEnable = LocalAutoEnable;
1571 attr_v12_lite.stManual.LocalSetting.LocalData.LocalAutoWeit = LocalAutoWeit;
1572 }
1573 ret = rk_aiq_user_api2_adrc_v12_lite_SetAttrib(ctx, &attr_v12_lite);
1574 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!");
1575 #endif
1576
1577 IMGPROC_FUNC_EXIT
1578 return ret;
1579 }
1580
rk_aiq_uapi2_getDrcLocalData(const rk_aiq_sys_ctx_t * ctx,float * LocalWeit,float * GlobalContrast,float * LoLitContrast,int * LocalAutoEnable,float * LocalAutoWeit)1581 XCamReturn rk_aiq_uapi2_getDrcLocalData(const rk_aiq_sys_ctx_t* ctx, float * LocalWeit, float * GlobalContrast,
1582 float * LoLitContrast, int* LocalAutoEnable, float* LocalAutoWeit)
1583 {
1584 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1585 IMGPROC_FUNC_ENTER
1586 if (ctx == NULL) {
1587 ret = XCAM_RETURN_ERROR_PARAM;
1588 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1589 }
1590
1591 #if RKAIQ_HAVE_DRC_V10
1592 ret = XCAM_RETURN_ERROR_PARAM;
1593 RKAIQ_IMGPROC_CHECK_RET(ret,
1594 "RK356x do not support rk_aiq_uapi2_getDrcLocalData! Please use "
1595 "rk_aiq_uapi2_getDrcLocalTMO");
1596 #endif
1597 #if RKAIQ_HAVE_DRC_V11
1598 drcAttrV11_t attr_v11;
1599 memset(&attr_v11, 0, sizeof(drcAttrV11_t));
1600 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(ctx, &attr_v11);
1601 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalData failed in get attrib!");
1602 *LocalWeit = attr_v11.Info.ValidParams.LocalSetting.LocalData.LocalWeit;
1603 *GlobalContrast = attr_v11.Info.ValidParams.LocalSetting.LocalData.GlobalContrast;
1604 *LoLitContrast = attr_v11.Info.ValidParams.LocalSetting.LocalData.LoLitContrast;
1605 *LocalAutoEnable = attr_v11.Info.ValidParams.LocalSetting.LocalData.LocalAutoEnable;
1606 *LocalAutoWeit = attr_v11.Info.ValidParams.LocalSetting.LocalData.LocalAutoWeit;
1607 #endif
1608 #if RKAIQ_HAVE_DRC_V12
1609 drcAttrV12_t attr_v12;
1610 memset(&attr_v12, 0, sizeof(drcAttrV12_t));
1611 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(ctx, &attr_v12);
1612 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalData failed in get attrib!");
1613 *LocalWeit = attr_v12.Info.ValidParams.LocalSetting.LocalData.LocalWeit;
1614 *GlobalContrast = attr_v12.Info.ValidParams.LocalSetting.LocalData.GlobalContrast;
1615 *LoLitContrast = attr_v12.Info.ValidParams.LocalSetting.LocalData.LoLitContrast;
1616 *LocalAutoEnable = attr_v12.Info.ValidParams.LocalSetting.LocalData.LocalAutoEnable;
1617 *LocalAutoWeit = attr_v12.Info.ValidParams.LocalSetting.LocalData.LocalAutoWeit;
1618 #endif
1619 #if RKAIQ_HAVE_DRC_V12_LITE
1620 drcAttrV12Lite_t attr_v12_lite;
1621 memset(&attr_v12_lite, 0, sizeof(drcAttrV12Lite_t));
1622 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(ctx, &attr_v12_lite);
1623 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcLocalData failed in get attrib!");
1624 *LocalWeit = attr_v12_lite.Info.ValidParams.LocalSetting.LocalData.LocalWeit;
1625 *GlobalContrast = attr_v12_lite.Info.ValidParams.LocalSetting.LocalData.GlobalContrast;
1626 *LoLitContrast = attr_v12_lite.Info.ValidParams.LocalSetting.LocalData.LoLitContrast;
1627 *LocalAutoEnable = attr_v12_lite.Info.ValidParams.LocalSetting.LocalData.LocalAutoEnable;
1628 *LocalAutoWeit = attr_v12_lite.Info.ValidParams.LocalSetting.LocalData.LocalAutoWeit;
1629 #endif
1630
1631 IMGPROC_FUNC_EXIT
1632 return ret;
1633 }
1634
1635 /*
1636 *****************************
1637 *
1638 * Desc: set/get manual drc HiLit
1639 * this function is active for DRC is Auto mode
1640 * use in RK356x, RV1106
1641 * Argument:
1642 * Strength: [0, 1]
1643 *
1644 *****************************
1645 */
rk_aiq_uapi2_setDrcHiLit(const rk_aiq_sys_ctx_t * ctx,float Strength)1646 XCamReturn rk_aiq_uapi2_setDrcHiLit(const rk_aiq_sys_ctx_t* ctx, float Strength)
1647 {
1648 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1649 IMGPROC_FUNC_ENTER
1650 if (ctx == NULL) {
1651 ret = XCAM_RETURN_ERROR_PARAM;
1652 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1653 }
1654 if (Strength < 0 || Strength > 1) {
1655 ret = XCAM_RETURN_ERROR_PARAM;
1656 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Strength range is [0,1]!");
1657 }
1658 #if RKAIQ_HAVE_DRC_V10
1659 drcAttrV10_t attr_v10;
1660 memset(&attr_v10, 0, sizeof(drcAttrV10_t));
1661 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(ctx, &attr_v10);
1662 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed!");
1663 attr_v10.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1664 attr_v10.sync.done = false;
1665
1666 if (attr_v10.opMode == DRC_OPMODE_AUTO) {
1667 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++)
1668 attr_v10.stAuto.DrcTuningPara.HiLight.Strength[i] = Strength;
1669 } else if (attr_v10.opMode == DRC_OPMODE_MANUAL) {
1670 attr_v10.stManual.HiLight.Strength = Strength;
1671 }
1672 ret = rk_aiq_user_api2_adrc_v10_SetAttrib(ctx, &attr_v10);
1673 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcHiLit failed!");
1674 #endif
1675 #if RKAIQ_HAVE_DRC_V11
1676 drcAttrV11_t attr_v11;
1677 memset(&attr_v11, 0, sizeof(drcAttrV11_t));
1678 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(ctx, &attr_v11);
1679 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed!");
1680 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1681 attr_v11.sync.done = false;
1682
1683 if (attr_v11.opMode == DRC_OPMODE_AUTO) {
1684 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++)
1685 attr_v11.stAuto.DrcTuningPara.HiLight.Strength[i] = Strength;
1686 } else if (attr_v11.opMode == DRC_OPMODE_MANUAL) {
1687 attr_v11.stManual.HiLight.Strength = Strength;
1688 }
1689 ret = rk_aiq_user_api2_adrc_v11_SetAttrib(ctx, &attr_v11);
1690 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcHiLit failed!");
1691 #endif
1692 #if RKAIQ_HAVE_DRC_V12
1693 drcAttrV12_t attr_v12;
1694 memset(&attr_v12, 0, sizeof(drcAttrV12_t));
1695 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(ctx, &attr_v12);
1696 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed!");
1697 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1698 attr_v12.sync.done = false;
1699
1700 if (attr_v12.opMode == DRC_OPMODE_AUTO) {
1701 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++)
1702 attr_v12.stAuto.DrcTuningPara.HiLight.HiLightData.Strength[i] = Strength;
1703 } else if (attr_v12.opMode == DRC_OPMODE_MANUAL) {
1704 attr_v12.stManual.HiLight.HiLightData.Strength = Strength;
1705 }
1706 ret = rk_aiq_user_api2_adrc_v12_SetAttrib(ctx, &attr_v12);
1707 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcHiLit failed!");
1708 #endif
1709 #if RKAIQ_HAVE_DRC_V12_LITE
1710 drcAttrV12Lite_t attr_v12_lite;
1711 memset(&attr_v12_lite, 0, sizeof(drcAttrV12Lite_t));
1712 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(ctx, &attr_v12_lite);
1713 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed!");
1714 attr_v12_lite.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1715 attr_v12_lite.sync.done = false;
1716
1717 if (attr_v12_lite.opMode == DRC_OPMODE_AUTO) {
1718 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++)
1719 attr_v12_lite.stAuto.DrcTuningPara.HiLight.HiLightData.Strength[i] = Strength;
1720 } else if (attr_v12_lite.opMode == DRC_OPMODE_MANUAL) {
1721 attr_v12_lite.stManual.HiLight.HiLightData.Strength = Strength;
1722 }
1723 ret = rk_aiq_user_api2_adrc_v12_lite_SetAttrib(ctx, &attr_v12_lite);
1724 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcHiLit failed!");
1725 #endif
1726
1727 IMGPROC_FUNC_EXIT
1728 return ret;
1729 }
1730
rk_aiq_uapi2_getDrcHiLit(const rk_aiq_sys_ctx_t * ctx,float * Strength)1731 XCamReturn rk_aiq_uapi2_getDrcHiLit(const rk_aiq_sys_ctx_t* ctx, float * Strength)
1732 {
1733 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1734 IMGPROC_FUNC_ENTER
1735 if (ctx == NULL) {
1736 ret = XCAM_RETURN_ERROR_PARAM;
1737 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1738 }
1739 #if RKAIQ_HAVE_DRC_V10
1740 drcAttrV10_t attr_v10;
1741 memset(&attr_v10, 0, sizeof(drcAttrV10_t));
1742 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(ctx, &attr_v10);
1743 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed in get attrib!");
1744 *Strength = attr_v10.Info.ValidParams.HiLight.Strength;
1745 #endif
1746 #if RKAIQ_HAVE_DRC_V11
1747 drcAttrV11_t attr_v11;
1748 memset(&attr_v11, 0, sizeof(drcAttrV11_t));
1749 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(ctx, &attr_v11);
1750 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed in get attrib!");
1751 *Strength = attr_v11.Info.ValidParams.HiLight.Strength;
1752 #endif
1753 #if RKAIQ_HAVE_DRC_V12
1754 drcAttrV12_t attr_v12;
1755 memset(&attr_v12, 0, sizeof(drcAttrV12_t));
1756 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(ctx, &attr_v12);
1757 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed in get attrib!");
1758 *Strength = attr_v12.Info.ValidParams.HiLight.HiLightData.Strength;
1759 #endif
1760 #if RKAIQ_HAVE_DRC_V12_LITE
1761 drcAttrV12Lite_t attr_v12_lite;
1762 memset(&attr_v12_lite, 0, sizeof(drcAttrV12Lite_t));
1763 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(ctx, &attr_v12_lite);
1764 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcHiLit failed in get attrib!");
1765 *Strength = attr_v12_lite.Info.ValidParams.HiLight.HiLightData.Strength;
1766 #endif
1767
1768 IMGPROC_FUNC_EXIT
1769 return ret;
1770 }
1771
1772 /*
1773 *****************************
1774 *
1775 * Desc: set/get manual drc Gain
1776 * this function is active for DRC is Auto mode
1777 * use in RK356x, RV1106
1778 * Argument:
1779 * Gain: [1, 8]
1780 * Alpha: [0, 1]
1781 * Clip: [0, 64]
1782 *
1783 *****************************
1784 */
rk_aiq_uapi2_setDrcGain(const rk_aiq_sys_ctx_t * ctx,float Gain,float Alpha,float Clip)1785 XCamReturn rk_aiq_uapi2_setDrcGain(const rk_aiq_sys_ctx_t* ctx, float Gain, float Alpha, float Clip)
1786 {
1787 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1788
1789 IMGPROC_FUNC_ENTER
1790
1791 if (ctx == NULL) {
1792 ret = XCAM_RETURN_ERROR_PARAM;
1793 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1794 }
1795 if (Gain < 1 || Gain > 8) {
1796 ret = XCAM_RETURN_ERROR_PARAM;
1797 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Gain range is [1,8]!");
1798 }
1799 if (Alpha < 0 || Alpha > 1) {
1800 ret = XCAM_RETURN_ERROR_PARAM;
1801 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Alpha range is [0,1]!");
1802 }
1803 if (Clip < 0 || Clip > 64) {
1804 ret = XCAM_RETURN_ERROR_PARAM;
1805 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, Clip range is [0,64]!");
1806 }
1807 #if RKAIQ_HAVE_DRC_V10
1808 drcAttrV10_t attr_v10;
1809 memset(&attr_v10, 0, sizeof(drcAttrV10_t));
1810 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(ctx, &attr_v10);
1811 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcGain failed!");
1812 attr_v10.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1813 attr_v10.sync.done = false;
1814
1815 if (attr_v10.opMode == DRC_OPMODE_AUTO) {
1816 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1817 attr_v10.stAuto.DrcTuningPara.DrcGain.DrcGain[i] = Gain;
1818 attr_v10.stAuto.DrcTuningPara.DrcGain.Alpha[i] = Alpha;
1819 attr_v10.stAuto.DrcTuningPara.DrcGain.Clip[i] = Clip;
1820 }
1821 } else if (attr_v10.opMode == DRC_OPMODE_MANUAL) {
1822 attr_v10.stManual.DrcGain.DrcGain = Gain;
1823 attr_v10.stManual.DrcGain.Alpha = Alpha;
1824 attr_v10.stManual.DrcGain.Clip = Clip;
1825 }
1826 ret = rk_aiq_user_api2_adrc_v10_SetAttrib(ctx, &attr_v10);
1827 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!");
1828 #endif
1829 #if RKAIQ_HAVE_DRC_V11
1830 drcAttrV11_t attr_v11;
1831 memset(&attr_v11, 0, sizeof(drcAttrV11_t));
1832 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(ctx, &attr_v11);
1833 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcGain failed!");
1834 attr_v11.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1835 attr_v11.sync.done = false;
1836
1837 if (attr_v11.opMode == DRC_OPMODE_AUTO) {
1838 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1839 attr_v11.stAuto.DrcTuningPara.DrcGain.DrcGain[i] = Gain;
1840 attr_v11.stAuto.DrcTuningPara.DrcGain.Alpha[i] = Alpha;
1841 attr_v11.stAuto.DrcTuningPara.DrcGain.Clip[i] = Clip;
1842 }
1843 } else if (attr_v11.opMode == DRC_OPMODE_MANUAL) {
1844 attr_v11.stManual.DrcGain.DrcGain = Gain;
1845 attr_v11.stManual.DrcGain.Alpha = Alpha;
1846 attr_v11.stManual.DrcGain.Clip = Clip;
1847 }
1848 ret = rk_aiq_user_api2_adrc_v11_SetAttrib(ctx, &attr_v11);
1849 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!");
1850 #endif
1851 #if RKAIQ_HAVE_DRC_V12
1852 drcAttrV12_t attr_v12;
1853 memset(&attr_v12, 0, sizeof(drcAttrV12_t));
1854 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(ctx, &attr_v12);
1855 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcGain failed!");
1856 attr_v12.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1857 attr_v12.sync.done = false;
1858
1859 if (attr_v12.opMode == DRC_OPMODE_AUTO) {
1860 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1861 attr_v12.stAuto.DrcTuningPara.DrcGain.DrcGain[i] = Gain;
1862 attr_v12.stAuto.DrcTuningPara.DrcGain.Alpha[i] = Alpha;
1863 attr_v12.stAuto.DrcTuningPara.DrcGain.Clip[i] = Clip;
1864 }
1865 } else if (attr_v12.opMode == DRC_OPMODE_MANUAL) {
1866 attr_v12.stManual.DrcGain.DrcGain = Gain;
1867 attr_v12.stManual.DrcGain.Alpha = Alpha;
1868 attr_v12.stManual.DrcGain.Clip = Clip;
1869 }
1870 ret = rk_aiq_user_api2_adrc_v12_SetAttrib(ctx, &attr_v12);
1871 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!");
1872 #endif
1873 #if RKAIQ_HAVE_DRC_V12_LITE
1874 drcAttrV12Lite_t attr_v12_lite;
1875 memset(&attr_v12_lite, 0, sizeof(drcAttrV12Lite_t));
1876 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(ctx, &attr_v12_lite);
1877 RKAIQ_IMGPROC_CHECK_RET(ret, "getDrcGain failed!");
1878 attr_v12_lite.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
1879 attr_v12_lite.sync.done = false;
1880
1881 if (attr_v12_lite.opMode == DRC_OPMODE_AUTO) {
1882 for (int i = 0; i < ADRC_ENVLV_STEP_MAX; i++) {
1883 attr_v12_lite.stAuto.DrcTuningPara.DrcGain.DrcGain[i] = Gain;
1884 attr_v12_lite.stAuto.DrcTuningPara.DrcGain.Alpha[i] = Alpha;
1885 attr_v12_lite.stAuto.DrcTuningPara.DrcGain.Clip[i] = Clip;
1886 }
1887 } else if (attr_v12_lite.opMode == DRC_OPMODE_MANUAL) {
1888 attr_v12_lite.stManual.DrcGain.DrcGain = Gain;
1889 attr_v12_lite.stManual.DrcGain.Alpha = Alpha;
1890 attr_v12_lite.stManual.DrcGain.Clip = Clip;
1891 }
1892 ret = rk_aiq_user_api2_adrc_v12_lite_SetAttrib(ctx, &attr_v12_lite);
1893 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed!");
1894 #endif
1895
1896 IMGPROC_FUNC_EXIT
1897 return ret;
1898 }
1899
rk_aiq_uapi2_getDrcGain(const rk_aiq_sys_ctx_t * ctx,float * Gain,float * Alpha,float * Clip)1900 XCamReturn rk_aiq_uapi2_getDrcGain(const rk_aiq_sys_ctx_t* ctx, float * Gain, float * Alpha, float * Clip)
1901 {
1902 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1903 IMGPROC_FUNC_ENTER
1904 if (ctx == NULL) {
1905 ret = XCAM_RETURN_ERROR_PARAM;
1906 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, ctx is NULL!");
1907 }
1908 #if RKAIQ_HAVE_DRC_V10
1909 drcAttrV10_t attr_v10;
1910 memset(&attr_v10, 0, sizeof(drcAttrV10_t));
1911 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(ctx, &attr_v10);
1912 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!");
1913 *Gain = attr_v10.Info.ValidParams.DrcGain.DrcGain;
1914 *Alpha = attr_v10.Info.ValidParams.DrcGain.Alpha;
1915 *Clip = attr_v10.Info.ValidParams.DrcGain.Clip;
1916 #endif
1917 #if RKAIQ_HAVE_DRC_V11
1918 drcAttrV11_t attr_v11;
1919 memset(&attr_v11, 0, sizeof(drcAttrV11_t));
1920 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(ctx, &attr_v11);
1921 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!");
1922 *Gain = attr_v11.Info.ValidParams.DrcGain.DrcGain;
1923 *Alpha = attr_v11.Info.ValidParams.DrcGain.Alpha;
1924 *Clip = attr_v11.Info.ValidParams.DrcGain.Clip;
1925 #endif
1926 #if RKAIQ_HAVE_DRC_V12
1927 drcAttrV12_t attr_v12;
1928 memset(&attr_v12, 0, sizeof(drcAttrV12_t));
1929 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(ctx, &attr_v12);
1930 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!");
1931 *Gain = attr_v12.Info.ValidParams.DrcGain.DrcGain;
1932 *Alpha = attr_v12.Info.ValidParams.DrcGain.Alpha;
1933 *Clip = attr_v12.Info.ValidParams.DrcGain.Clip;
1934 #endif
1935 #if RKAIQ_HAVE_DRC_V12_LITE
1936 drcAttrV12Lite_t attr_v12_lite;
1937 memset(&attr_v12_lite, 0, sizeof(drcAttrV12Lite_t));
1938 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(ctx, &attr_v12_lite);
1939 RKAIQ_IMGPROC_CHECK_RET(ret, "setDrcGain failed in get attrib!");
1940 *Gain = attr_v12_lite.Info.ValidParams.DrcGain.DrcGain;
1941 *Alpha = attr_v12_lite.Info.ValidParams.DrcGain.Alpha;
1942 *Clip = attr_v12_lite.Info.ValidParams.DrcGain.Clip;
1943 #endif
1944
1945 IMGPROC_FUNC_EXIT
1946 return ret;
1947 }
1948
1949 /*
1950 *****************************
1951 *
1952 * Desc: set/get dark area boost strength
1953 * this function is active for normal mode
1954 * Argument:
1955 * level: [1, 10]
1956 * only valid in RV1109/RV1126
1957 *****************************
1958 */
rk_aiq_uapi2_getDarkAreaBoostStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)1959 XCamReturn rk_aiq_uapi2_getDarkAreaBoostStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
1960 {
1961 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1962
1963 #if RKAIQ_HAVE_DRC_V10
1964 ret = XCAM_RETURN_ERROR_PARAM;
1965 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api!");
1966 #endif
1967 #if RKAIQ_HAVE_DRC_V11
1968 ret = XCAM_RETURN_ERROR_PARAM;
1969 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!");
1970 #endif
1971 #if RKAIQ_HAVE_DRC_V12
1972 ret = XCAM_RETURN_ERROR_PARAM;
1973 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.2 do not support tmo api!");
1974 #endif
1975 #if RKAIQ_HAVE_DRC_V12_LITE
1976 ret = XCAM_RETURN_ERROR_PARAM;
1977 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.2 lite do not support tmo api!");
1978 #endif
1979
1980 return ret;
1981 }
1982
rk_aiq_uapi2_setDarkAreaBoostStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int level)1983 XCamReturn rk_aiq_uapi2_setDarkAreaBoostStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
1984 {
1985 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1986
1987 #if RKAIQ_HAVE_DRC_V10
1988 ret = XCAM_RETURN_ERROR_PARAM;
1989 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api!");
1990 #endif
1991 #if RKAIQ_HAVE_DRC_V11
1992 ret = XCAM_RETURN_ERROR_PARAM;
1993 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!");
1994 #endif
1995 #if RKAIQ_HAVE_DRC_V12
1996 ret = XCAM_RETURN_ERROR_PARAM;
1997 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.2 do not support tmo api!");
1998 #endif
1999 #if RKAIQ_HAVE_DRC_V12_LITE
2000 ret = XCAM_RETURN_ERROR_PARAM;
2001 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.2 lite do not support tmo api!");
2002 #endif
2003
2004 return ret;
2005 }
2006
2007 /*
2008 *****************************
2009 *
2010 * Desc: set/get manual hdr strength
2011 * this function is active for HDR is manual mode
2012 * Argument:
2013 * level: [1, 100]
2014 *
2015 *****************************
2016 */
rk_aiq_uapi2_setMHDRStrth(const rk_aiq_sys_ctx_t * ctx,bool on,unsigned int level)2017 XCamReturn rk_aiq_uapi2_setMHDRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level)
2018 {
2019 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2020 /*
2021 if(CHECK_ISP_HW_V20()) {
2022 atmo_attrib_t attr;
2023 memset(&attr, 0, sizeof(attr));
2024 IMGPROC_FUNC_ENTER
2025 if (ctx == NULL) {
2026 ret = XCAM_RETURN_ERROR_PARAM;
2027 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMHDRStrth failed!");
2028 }
2029
2030 if (!isHDRmode(ctx)) {
2031 ret = XCAM_RETURN_ERROR_FAILED;
2032 RKAIQ_IMGPROC_CHECK_RET(ret, "not in HDR mode!");
2033 }
2034 if (level < 1 || level > 100) {
2035 ret = XCAM_RETURN_ERROR_OUTOFRANGE;
2036 RKAIQ_IMGPROC_CHECK_RET(ret, "level(%d) is out of range, setMHDRStrth failed!");
2037 }
2038
2039 attr.stSetLevel.level = level;
2040 attr.opMode = TMO_OPMODE_SET_LEVEL;
2041 ret = rk_aiq_user_api2_atmo_SetAttrib(ctx, attr);
2042 RKAIQ_IMGPROC_CHECK_RET(ret, "setMHDRStrth failed!");
2043 IMGPROC_FUNC_EXIT
2044 }
2045 else if(CHECK_ISP_HW_V21()) {
2046 ret = XCAM_RETURN_ERROR_PARAM;
2047 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api, ctx is NULL!");
2048 }
2049 else if(CHECK_ISP_HW_V30()) {
2050 ret = XCAM_RETURN_ERROR_PARAM;
2051 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!");
2052 }
2053 */
2054 return ret;
2055 }
rk_aiq_uapi2_getMHDRStrth(const rk_aiq_sys_ctx_t * ctx,bool * on,unsigned int * level)2056 XCamReturn rk_aiq_uapi2_getMHDRStrth(const rk_aiq_sys_ctx_t* ctx, bool * on, unsigned int *level)
2057 {
2058 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2059 /*
2060 if(CHECK_ISP_HW_V20()) {
2061 atmo_attrib_t attr;
2062 memset(&attr, 0, sizeof(attr));
2063 IMGPROC_FUNC_ENTER
2064 if (ctx == NULL) {
2065 ret = XCAM_RETURN_ERROR_PARAM;
2066 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMHDRStrth failed!");
2067 }
2068 if (!isHDRmode(ctx)) {
2069 ret = XCAM_RETURN_ERROR_FAILED;
2070 RKAIQ_IMGPROC_CHECK_RET(ret, "not in HDR mode!");
2071 }
2072 ret = rk_aiq_user_api2_atmo_GetAttrib(ctx, &attr);
2073 RKAIQ_IMGPROC_CHECK_RET(ret, "getMHDRStrth failed in get attrib!");
2074
2075 *level = attr.stSetLevel.level;
2076 IMGPROC_FUNC_EXIT
2077
2078 }
2079 else if(CHECK_ISP_HW_V21()) {
2080 ret = XCAM_RETURN_ERROR_PARAM;
2081 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP2.1 do not support tmo api, ctx is NULL!");
2082 }
2083 else if(CHECK_ISP_HW_V30()) {
2084 ret = XCAM_RETURN_ERROR_PARAM;
2085 RKAIQ_IMGPROC_CHECK_RET(ret, "ISP3.0 do not support tmo api!");
2086 }
2087 */
2088 return ret;
2089 }
2090
2091
2092 /*
2093 **********************************************************
2094 * Noise reduction
2095 **********************************************************
2096 */
2097 /*
2098 *****************************
2099 *
2100 * Desc: set noise reduction mode
2101 * Argument:
2102 * mode:
2103 * auto: auto noise reduction
2104 * manual：manual noise reduction
2105 *
2106 *****************************
2107 */
rk_aiq_uapi2_setNRMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)2108 XCamReturn rk_aiq_uapi2_setNRMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
2109 {
2110 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2111
2112 IMGPROC_FUNC_ENTER
2113
2114 if (CHECK_ISP_HW_V20()) {
2115 rk_aiq_nr_attrib_t attr;
2116 ret = rk_aiq_user_api2_anr_GetAttrib(ctx, &attr);
2117 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2118 if (mode == OP_AUTO) {
2119 attr.eMode = ANR_OP_MODE_AUTO;
2120 } else if (mode == OP_MANUAL) {
2121 attr.eMode = ANR_OP_MODE_MANUAL;
2122 } else {
2123 ret = XCAM_RETURN_ERROR_PARAM;
2124 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
2125 }
2126 ret = rk_aiq_user_api2_anr_SetAttrib(ctx, &attr);
2127 }
2128
2129 if (CHECK_ISP_HW_V21()) {
2130 rk_aiq_ynr_attrib_v2_t ynrV2_attr;
2131 rk_aiq_bayernr_attrib_v2_t bayernrV2_attr;
2132 rk_aiq_cnr_attrib_v1_t cnrV1_attr;
2133 ret = rk_aiq_user_api2_aynrV2_GetAttrib(ctx, &ynrV2_attr);
2134 ret = rk_aiq_user_api2_abayernrV2_GetAttrib(ctx, &bayernrV2_attr);
2135 ret = rk_aiq_user_api2_acnrV1_GetAttrib(ctx, &cnrV1_attr);
2136 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2137 if (mode == OP_AUTO) {
2138 bayernrV2_attr.eMode = ABAYERNR_OP_MODE_AUTO;
2139 ynrV2_attr.eMode = AYNR_OP_MODE_AUTO;
2140 cnrV1_attr.eMode = ACNR_OP_MODE_AUTO;
2141 } else if (mode == OP_MANUAL) {
2142 bayernrV2_attr.eMode = ABAYERNR_OP_MODE_MANUAL;
2143 ynrV2_attr.eMode = AYNR_OP_MODE_MANUAL;
2144 cnrV1_attr.eMode = ACNR_OP_MODE_MANUAL;
2145 } else {
2146 ret = XCAM_RETURN_ERROR_PARAM;
2147 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
2148 }
2149 ret = rk_aiq_user_api2_aynrV2_SetAttrib(ctx, &ynrV2_attr);
2150 ret = rk_aiq_user_api2_abayernrV2_SetAttrib(ctx, &bayernrV2_attr);
2151 ret = rk_aiq_user_api2_acnrV1_SetAttrib(ctx, &cnrV1_attr);
2152 }
2153
2154 if (CHECK_ISP_HW_V30()) {
2155 rk_aiq_ynr_attrib_v3_t ynrV3_attr;
2156 ynrV3_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2157 rk_aiq_cnr_attrib_v2_t cnrV2_attr;
2158 cnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2159 rk_aiq_bayer2dnr_attrib_v2_t bayer2dnrV2_attr;
2160 bayer2dnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2161 rk_aiq_bayertnr_attrib_v2_t bayertnrV2_attr;
2162 bayertnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2163 ret = rk_aiq_user_api2_aynrV3_GetAttrib(ctx, &ynrV3_attr);
2164 ret = rk_aiq_user_api2_acnrV2_GetAttrib(ctx, &cnrV2_attr);
2165 ret = rk_aiq_user_api2_abayer2dnrV2_GetAttrib(ctx, &bayer2dnrV2_attr);
2166 ret = rk_aiq_user_api2_abayertnrV2_GetAttrib(ctx, &bayertnrV2_attr);
2167 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2168
2169 if (mode == OP_AUTO) {
2170 ynrV3_attr.eMode = AYNRV3_OP_MODE_AUTO;
2171 cnrV2_attr.eMode = ACNRV2_OP_MODE_AUTO;
2172 bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_AUTO;
2173 bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_AUTO;
2174 } else if (mode == OP_MANUAL) {
2175 ynrV3_attr.eMode = AYNRV3_OP_MODE_MANUAL;
2176 cnrV2_attr.eMode = ACNRV2_OP_MODE_MANUAL;
2177 bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_MANUAL;
2178 bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_MANUAL;
2179 } else if(mode == OP_REG_MANUAL) {
2180 ynrV3_attr.eMode = AYNRV3_OP_MODE_REG_MANUAL;
2181 cnrV2_attr.eMode = ACNRV2_OP_MODE_REG_MANUAL;
2182 bayer2dnrV2_attr.eMode = ABAYER2DNR_OP_MODE_REG_MANUAL;
2183 bayertnrV2_attr.eMode = ABAYERTNRV2_OP_MODE_REG_MANUAL;
2184 } else {
2185 ret = XCAM_RETURN_ERROR_PARAM;
2186 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
2187 }
2188 ret = rk_aiq_user_api2_aynrV3_SetAttrib(ctx, &ynrV3_attr);
2189 ret = rk_aiq_user_api2_acnrV2_SetAttrib(ctx, &cnrV2_attr);
2190 ret = rk_aiq_user_api2_abayer2dnrV2_SetAttrib(ctx, &bayer2dnrV2_attr);
2191 ret = rk_aiq_user_api2_abayertnrV2_SetAttrib(ctx, &bayertnrV2_attr);
2192 }
2193
2194 if (CHECK_ISP_HW_V32()) {
2195 rk_aiq_ynr_attrib_v22_t ynrV22_attr;
2196 ynrV22_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2197 rk_aiq_cnr_attrib_v30_t cnrV30_attr;
2198 cnrV30_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2199 rk_aiq_bayer2dnr_attrib_v23_t bayer2dnrV23_attr;
2200 bayer2dnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2201 rk_aiq_bayertnr_attrib_v23_t bayertnrV23_attr;
2202 bayertnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2203 ret = rk_aiq_user_api2_aynrV22_GetAttrib(ctx, &ynrV22_attr);
2204 ret = rk_aiq_user_api2_acnrV30_GetAttrib(ctx, &cnrV30_attr);
2205 ret = rk_aiq_user_api2_abayer2dnrV23_GetAttrib(ctx, &bayer2dnrV23_attr);
2206 ret = rk_aiq_user_api2_abayertnrV23_GetAttrib(ctx, &bayertnrV23_attr);
2207 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2208
2209 if (mode == OP_AUTO) {
2210 ynrV22_attr.eMode = AYNRV22_OP_MODE_AUTO;
2211 cnrV30_attr.eMode = ACNRV30_OP_MODE_AUTO;
2212 bayer2dnrV23_attr.eMode = ABAYER2DNR_V23_OP_MODE_AUTO;
2213 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_AUTO;
2214 } else if (mode == OP_MANUAL) {
2215 ynrV22_attr.eMode = AYNRV22_OP_MODE_MANUAL;
2216 cnrV30_attr.eMode = ACNRV30_OP_MODE_MANUAL;
2217 bayer2dnrV23_attr.eMode = ABAYER2DNR_V23_OP_MODE_MANUAL;
2218 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_MANUAL;
2219 } else if(mode == OP_REG_MANUAL) {
2220 ynrV22_attr.eMode = AYNRV22_OP_MODE_REG_MANUAL;
2221 cnrV30_attr.eMode = ACNRV30_OP_MODE_REG_MANUAL;
2222 bayer2dnrV23_attr.eMode = ABAYER2DNR_V23_OP_MODE_REG_MANUAL;
2223 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_REG_MANUAL;
2224 } else {
2225 ret = XCAM_RETURN_ERROR_PARAM;
2226 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
2227 }
2228 ret = rk_aiq_user_api2_aynrV22_SetAttrib(ctx, &ynrV22_attr);
2229 ret = rk_aiq_user_api2_acnrV30_SetAttrib(ctx, &cnrV30_attr);
2230 ret = rk_aiq_user_api2_abayer2dnrV23_SetAttrib(ctx, &bayer2dnrV23_attr);
2231 ret = rk_aiq_user_api2_abayertnrV23_SetAttrib(ctx, &bayertnrV23_attr);
2232 }
2233
2234 if (CHECK_ISP_HW_V32_LITE()) {
2235 rk_aiq_ynr_attrib_v22_t ynrV22_attr;
2236 ynrV22_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2237 rk_aiq_cnr_attrib_v30_t cnrV30_attr;
2238 cnrV30_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2239 rk_aiq_bayertnr_attrib_v23L_t bayertnrV23_attr;
2240 bayertnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2241 ret = rk_aiq_user_api2_aynrV22_GetAttrib(ctx, &ynrV22_attr);
2242 ret = rk_aiq_user_api2_acnrV30_GetAttrib(ctx, &cnrV30_attr);
2243 ret = rk_aiq_user_api2_abayertnrV23Lite_GetAttrib(ctx, &bayertnrV23_attr);
2244 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2245
2246 if (mode == OP_AUTO) {
2247 ynrV22_attr.eMode = AYNRV22_OP_MODE_AUTO;
2248 cnrV30_attr.eMode = ACNRV30_OP_MODE_AUTO;
2249 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_AUTO;
2250 } else if (mode == OP_MANUAL) {
2251 ynrV22_attr.eMode = AYNRV22_OP_MODE_MANUAL;
2252 cnrV30_attr.eMode = ACNRV30_OP_MODE_MANUAL;
2253 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_MANUAL;
2254 } else if (mode == OP_REG_MANUAL) {
2255 ynrV22_attr.eMode = AYNRV22_OP_MODE_REG_MANUAL;
2256 cnrV30_attr.eMode = ACNRV30_OP_MODE_REG_MANUAL;
2257 bayertnrV23_attr.eMode = ABAYERTNRV23_OP_MODE_REG_MANUAL;
2258 } else {
2259 ret = XCAM_RETURN_ERROR_PARAM;
2260 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
2261 }
2262 ret = rk_aiq_user_api2_aynrV22_SetAttrib(ctx, &ynrV22_attr);
2263 ret = rk_aiq_user_api2_acnrV30_SetAttrib(ctx, &cnrV30_attr);
2264 ret = rk_aiq_user_api2_abayertnrV23Lite_SetAttrib(ctx, &bayertnrV23_attr);
2265 }
2266
2267 RKAIQ_IMGPROC_CHECK_RET(ret, "setNRMode failed!", ret);
2268 IMGPROC_FUNC_EXIT
2269
2270 return ret;
2271 }
2272
2273
rk_aiq_uapi2_getNRMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)2274 XCamReturn rk_aiq_uapi2_getNRMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
2275 {
2276 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2277 IMGPROC_FUNC_ENTER
2278
2279 if (CHECK_ISP_HW_V20()) {
2280 rk_aiq_nr_attrib_t attr;
2281 ret = rk_aiq_user_api2_anr_GetAttrib(ctx, &attr);
2282 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2283 if (attr.eMode == ANR_OP_MODE_AUTO) {
2284 *mode = OP_AUTO;
2285 } else if (attr.eMode == ANR_OP_MODE_MANUAL) {
2286 *mode = OP_MANUAL;
2287 } else if (attr.eMode == ANR_OP_MODE_INVALID) {
2288 *mode = OP_INVAL;
2289 }
2290 }
2291
2292 if (CHECK_ISP_HW_V21()) {
2293 rk_aiq_ynr_attrib_v2_t ynrV2_attr;
2294 rk_aiq_bayernr_attrib_v2_t bayernrV2_attr;
2295 rk_aiq_cnr_attrib_v1_t cnrV1_attr;
2296 ret = rk_aiq_user_api2_aynrV2_GetAttrib(ctx, &ynrV2_attr);
2297 ret = rk_aiq_user_api2_abayernrV2_GetAttrib(ctx, &bayernrV2_attr);
2298 ret = rk_aiq_user_api2_acnrV1_GetAttrib(ctx, &cnrV1_attr);
2299 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2300
2301 if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_AUTO
2302 && ynrV2_attr.eMode == AYNR_OP_MODE_AUTO
2303 && cnrV1_attr.eMode == ACNR_OP_MODE_AUTO) {
2304 *mode = OP_AUTO;
2305 } else if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_MANUAL
2306 && ynrV2_attr.eMode == AYNR_OP_MODE_MANUAL
2307 && cnrV1_attr.eMode == ACNR_OP_MODE_MANUAL) {
2308 *mode = OP_MANUAL;
2309 } else if (bayernrV2_attr.eMode == ABAYERNR_OP_MODE_INVALID
2310 && ynrV2_attr.eMode == AYNR_OP_MODE_INVALID
2311 && cnrV1_attr.eMode == ACNR_OP_MODE_INVALID) {
2312 *mode = OP_INVAL;
2313 } else {
2314 LOGE_ANR("bayernr.mode:%d ynr.mode:%d cnr.mode:%d\n",
2315 bayernrV2_attr.eMode,
2316 ynrV2_attr.eMode,
2317 cnrV1_attr.eMode);
2318 }
2319
2320 }
2321
2322 if (CHECK_ISP_HW_V30()) {
2323 rk_aiq_ynr_attrib_v3_t ynrV3_attr;
2324 ynrV3_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2325 rk_aiq_cnr_attrib_v2_t cnrV2_attr;
2326 cnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2327 rk_aiq_bayer2dnr_attrib_v2_t bayer2dnrV2_attr;
2328 bayer2dnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2329 rk_aiq_bayertnr_attrib_v2_t bayertnrV2_attr;
2330 bayertnrV2_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2331 ret = rk_aiq_user_api2_aynrV3_GetAttrib(ctx, &ynrV3_attr);
2332 ret = rk_aiq_user_api2_acnrV2_GetAttrib(ctx, &cnrV2_attr);
2333 ret = rk_aiq_user_api2_abayer2dnrV2_GetAttrib(ctx, &bayer2dnrV2_attr);
2334 ret = rk_aiq_user_api2_abayertnrV2_GetAttrib(ctx, &bayertnrV2_attr);
2335 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2336
2337 if(ynrV3_attr.eMode == AYNRV3_OP_MODE_AUTO
2338 && cnrV2_attr.eMode == ACNRV2_OP_MODE_AUTO
2339 && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_AUTO
2340 && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_AUTO) {
2341 *mode = OP_AUTO;
2342 } else if(ynrV3_attr.eMode == AYNRV3_OP_MODE_MANUAL
2343 && cnrV2_attr.eMode == ACNRV2_OP_MODE_MANUAL
2344 && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_MANUAL
2345 && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_MANUAL) {
2346 *mode = OP_MANUAL;
2347 } else if(ynrV3_attr.eMode == AYNRV3_OP_MODE_REG_MANUAL
2348 && cnrV2_attr.eMode == ACNRV2_OP_MODE_REG_MANUAL
2349 && bayer2dnrV2_attr.eMode == ABAYER2DNR_OP_MODE_REG_MANUAL
2350 && bayertnrV2_attr.eMode == ABAYERTNRV2_OP_MODE_REG_MANUAL) {
2351 *mode = OP_REG_MANUAL;
2352 } else {
2353 LOGE_ANR("ynr.mode:%d cnr.mode:%d bayer2dnr.mode:%d bayertnr.mode:%d\n",
2354 ynrV3_attr.eMode,
2355 cnrV2_attr.eMode,
2356 bayer2dnrV2_attr.eMode,
2357 bayertnrV2_attr.eMode);
2358 }
2359 }
2360
2361 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2362 rk_aiq_ynr_attrib_v22_t ynrV22_attr;
2363 ynrV22_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2364 rk_aiq_cnr_attrib_v30_t cnrV30_attr;
2365 cnrV30_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2366 rk_aiq_bayer2dnr_attrib_v23_t bayer2dnrV23_attr;
2367 bayer2dnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2368 rk_aiq_bayertnr_attrib_v23_t bayertnrV23_attr;
2369 bayertnrV23_attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2370 ret = rk_aiq_user_api2_aynrV22_GetAttrib(ctx, &ynrV22_attr);
2371 ret = rk_aiq_user_api2_acnrV30_GetAttrib(ctx, &cnrV30_attr);
2372 ret = rk_aiq_user_api2_abayer2dnrV23_GetAttrib(ctx, &bayer2dnrV23_attr);
2373 ret = rk_aiq_user_api2_abayertnrV23_GetAttrib(ctx, &bayertnrV23_attr);
2374 RKAIQ_IMGPROC_CHECK_RET(ret, "get anr attrib failed!,ret=%d", ret);
2375
2376 if(ynrV22_attr.eMode == AYNRV22_OP_MODE_AUTO
2377 && cnrV30_attr.eMode == ACNRV30_OP_MODE_AUTO
2378 && bayer2dnrV23_attr.eMode == ABAYER2DNR_V23_OP_MODE_AUTO
2379 && bayertnrV23_attr.eMode == ABAYERTNRV23_OP_MODE_AUTO) {
2380 *mode = OP_AUTO;
2381 } else if(ynrV22_attr.eMode == AYNRV22_OP_MODE_MANUAL
2382 && cnrV30_attr.eMode == ACNRV30_OP_MODE_MANUAL
2383 && bayer2dnrV23_attr.eMode == ABAYER2DNR_V23_OP_MODE_MANUAL
2384 && bayertnrV23_attr.eMode == ABAYERTNRV23_OP_MODE_MANUAL) {
2385 *mode = OP_MANUAL;
2386 } else if(ynrV22_attr.eMode == AYNRV22_OP_MODE_REG_MANUAL
2387 && cnrV30_attr.eMode == ACNRV30_OP_MODE_REG_MANUAL
2388 && bayer2dnrV23_attr.eMode == ABAYER2DNR_V23_OP_MODE_REG_MANUAL
2389 && bayertnrV23_attr.eMode == ABAYERTNRV23_OP_MODE_REG_MANUAL) {
2390 *mode = OP_REG_MANUAL;
2391 } else {
2392 LOGE_ANR("ynr.mode:%d cnr.mode:%d bayer2dnr.mode:%d bayertnr.mode:%d\n",
2393 ynrV22_attr.eMode,
2394 cnrV30_attr.eMode,
2395 bayer2dnrV23_attr.eMode,
2396 bayertnrV23_attr.eMode);
2397 }
2398 }
2399
2400 IMGPROC_FUNC_EXIT
2401 return ret;
2402 }
2403
2404
2405
2406 /*
2407 *****************************
2408 *
2409 * Desc: set normal noise reduction strength
2410 * Argument:
2411 * level: [0, 100]
2412 * Normal mode
2413 *****************************
2414 */
rk_aiq_uapi2_setANRStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int level)2415 XCamReturn rk_aiq_uapi2_setANRStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
2416 {
2417 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2418
2419 IMGPROC_FUNC_ENTER
2420
2421 if (ctx == NULL) {
2422 ret = XCAM_RETURN_ERROR_PARAM;
2423 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setANRStrth failed!");
2424 }
2425
2426 if (CHECK_ISP_HW_V20()) {
2427 ret = rk_aiq_user_api2_anr_SetLumaSFStrength(ctx, level / 100.0);
2428 ret = rk_aiq_user_api2_anr_SetLumaTFStrength(ctx, level / 100.0);
2429 RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret);
2430 }
2431
2432 if (CHECK_ISP_HW_V21()) {
2433 ret = rk_aiq_user_api2_aynrV2_SetStrength(ctx, level / 100.0);
2434 ret = rk_aiq_user_api2_abayernrV2_SetSFStrength(ctx, level / 100.0);
2435 ret = rk_aiq_user_api2_abayernrV2_SetTFStrength(ctx, level / 100.0);
2436 RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret);
2437 }
2438
2439 if (CHECK_ISP_HW_V30()) {
2440 rk_aiq_ynr_strength_v3_t ynrStrenght;
2441 ynrStrenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2442 ynrStrenght.percent = level / 100.0;
2443 ret = rk_aiq_user_api2_aynrV3_SetStrength(ctx, &ynrStrenght);
2444 rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght;
2445 bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2446 bayer2dnrV2Strenght.percent = level / 100.0;
2447 ret = rk_aiq_user_api2_abayer2dnrV2_SetStrength(ctx, &bayer2dnrV2Strenght);
2448 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
2449 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2450 bayertnrV2Strenght.percent = level / 100.0;
2451 ret = rk_aiq_user_api2_abayertnrV2_SetStrength(ctx, &bayertnrV2Strenght);
2452 RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret);
2453 }
2454
2455 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2456 rk_aiq_ynr_strength_v22_t ynrV22Strength;
2457 ynrV22Strength.strength_enable = true;
2458 ynrV22Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2459 ynrV22Strength.percent = level / 100.0;
2460 ret = rk_aiq_user_api2_aynrV22_SetStrength(ctx, &ynrV22Strength);
2461 rk_aiq_bayer2dnr_strength_v23_t bayer2dnrV23Strength;
2462 bayer2dnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2463 bayer2dnrV23Strength.strength_enable = true;
2464 bayer2dnrV23Strength.percent = level / 100.0;
2465 ret = rk_aiq_user_api2_abayer2dnrV23_SetStrength(ctx, &bayer2dnrV23Strength);
2466 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
2467 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2468 bayertnrV23Strength.strength_enable = true;
2469 bayertnrV23Strength.percent = level / 100.0;
2470 ret = rk_aiq_user_api2_abayertnrV23_SetStrength(ctx, &bayertnrV23Strength);
2471 RKAIQ_IMGPROC_CHECK_RET(ret, "setANRStrth failed!", ret);
2472 }
2473
2474 IMGPROC_FUNC_EXIT
2475 return ret;
2476 }
2477
2478
rk_aiq_uapi2_getANRStrth(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)2479 XCamReturn rk_aiq_uapi2_getANRStrth(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
2480 {
2481 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2482 float percent = 0.0f;
2483
2484 IMGPROC_FUNC_ENTER
2485
2486 if (ctx == NULL) {
2487 ret = XCAM_RETURN_ERROR_PARAM;
2488 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getANRStrth failed!");
2489 }
2490
2491 if (CHECK_ISP_HW_V20()) {
2492 ret = rk_aiq_user_api2_anr_GetLumaTFStrength(ctx, &percent);
2493 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
2494 *level = (unsigned int)(percent * 100);
2495 }
2496
2497 if (CHECK_ISP_HW_V21()) {
2498 ret = rk_aiq_user_api2_abayernrV2_GetTFStrength(ctx, &percent);
2499 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
2500 *level = (unsigned int)(percent * 100);
2501 }
2502
2503 if (CHECK_ISP_HW_V30()) {
2504 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
2505 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2506 ret = rk_aiq_user_api2_abayertnrV2_GetStrength(ctx, &bayertnrV2Strenght);
2507 percent = bayertnrV2Strenght.percent;
2508 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
2509 *level = (unsigned int)(percent * 100);
2510 }
2511
2512 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2513 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
2514 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2515 ret = rk_aiq_user_api2_abayertnrV23_GetStrength(ctx, &bayertnrV23Strength);
2516 RKAIQ_IMGPROC_CHECK_RET(ret, "getANRStrth failed!", ret);
2517 *level = (unsigned int)(bayertnrV23Strength.percent * 100);
2518 }
2519
2520
2521
2522 IMGPROC_FUNC_EXIT
2523 return ret;
2524 }
2525
2526
2527 /*
2528 *****************************
2529 *
2530 * Desc: set manual spatial noise reduction strength
2531 * this function is active for NR is manual mode
2532 * Argument:
2533 * level: [0, 100]
2534 *
2535 *****************************
2536 */
rk_aiq_uapi2_setMSpaNRStrth(const rk_aiq_sys_ctx_t * ctx,bool on,unsigned int level)2537 XCamReturn rk_aiq_uapi2_setMSpaNRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level)
2538 {
2539 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2540 IMGPROC_FUNC_ENTER
2541
2542 if (ctx == NULL) {
2543 ret = XCAM_RETURN_ERROR_PARAM;
2544 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMSpaNRStrth failed!");
2545 }
2546
2547 if (CHECK_ISP_HW_V20()) {
2548 ret = rk_aiq_user_api2_anr_SetLumaSFStrength(ctx, level / 100.0);
2549 }
2550
2551 if (CHECK_ISP_HW_V21()) {
2552 ret = rk_aiq_user_api2_abayernrV2_SetSFStrength(ctx, level / 100.0);
2553 ret = rk_aiq_user_api2_aynrV2_SetStrength(ctx, level / 100.0);
2554 }
2555
2556 if (CHECK_ISP_HW_V30()) {
2557 rk_aiq_ynr_strength_v3_t ynrStrenght;
2558 ynrStrenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2559 ynrStrenght.strength_enable = true;
2560 ynrStrenght.percent = level / 100.0;
2561 ret = rk_aiq_user_api2_aynrV3_SetStrength(ctx, &ynrStrenght);
2562 rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght;
2563 bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2564 bayer2dnrV2Strenght.strength_enable = true;
2565 bayer2dnrV2Strenght.percent = level / 100.0;
2566 ret = rk_aiq_user_api2_abayer2dnrV2_SetStrength(ctx, &bayer2dnrV2Strenght);
2567 }
2568
2569 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2570 rk_aiq_ynr_strength_v22_t ynrStrength;
2571 ynrStrength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2572 ynrStrength.strength_enable = true;
2573 ynrStrength.percent = level / 100.0;
2574 ret = rk_aiq_user_api2_aynrV22_SetStrength(ctx, &ynrStrength);
2575 rk_aiq_bayer2dnr_strength_v23_t bayer2dnrV23Strength;
2576 bayer2dnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2577 bayer2dnrV23Strength.strength_enable = true;
2578 bayer2dnrV23Strength.percent = level / 100.0;
2579 ret = rk_aiq_user_api2_abayer2dnrV23_SetStrength(ctx, &bayer2dnrV23Strength);
2580 }
2581
2582 RKAIQ_IMGPROC_CHECK_RET(ret, "setMSpaNRStrth failed!", ret);
2583 IMGPROC_FUNC_EXIT
2584 return ret;
2585 }
2586
2587
2588
2589 /*
2590 *****************************
2591 *
2592 * Desc: get manual spatial noise reduction strength
2593 * this function is active for NR is manual mode
2594 * Argument:
2595 * level: [0, 100]
2596 *
2597 *****************************
2598 */
rk_aiq_uapi2_getMSpaNRStrth(const rk_aiq_sys_ctx_t * ctx,bool * on,unsigned int * level)2599 XCamReturn rk_aiq_uapi2_getMSpaNRStrth(const rk_aiq_sys_ctx_t* ctx, bool * on, unsigned int *level)
2600 {
2601 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2602 float percent = 0.0f;
2603 IMGPROC_FUNC_ENTER
2604 if (ctx == NULL) {
2605 ret = XCAM_RETURN_ERROR_PARAM;
2606 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMSpaNRStrth failed!");
2607 }
2608
2609 if (CHECK_ISP_HW_V20()) {
2610 ret = rk_aiq_user_api2_anr_GetLumaSFStrength(ctx, &percent);
2611 }
2612
2613 if (CHECK_ISP_HW_V21()) {
2614 ret = rk_aiq_user_api2_abayernrV2_GetSFStrength(ctx, &percent);
2615 }
2616
2617 if (CHECK_ISP_HW_V30()) {
2618 rk_aiq_bayer2dnr_strength_v2_t bayer2dnrV2Strenght;
2619 bayer2dnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2620 ret = rk_aiq_user_api2_abayer2dnrV2_GetStrength(ctx, &bayer2dnrV2Strenght);
2621 percent = bayer2dnrV2Strenght.percent;
2622 }
2623
2624 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2625 rk_aiq_bayer2dnr_strength_v23_t bayer2dnrV23Strength;
2626 bayer2dnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2627 ret = rk_aiq_user_api2_abayer2dnrV23_GetStrength(ctx, &bayer2dnrV23Strength);
2628 percent = bayer2dnrV23Strength.percent;
2629 }
2630
2631
2632 RKAIQ_IMGPROC_CHECK_RET(ret, "getMSpaNRStrth failed!", ret);
2633 *level = (unsigned int)(percent * 100);
2634 IMGPROC_FUNC_EXIT
2635 return ret;
2636 }
2637
2638
2639
2640 /*
2641 *****************************
2642 *
2643 * Desc: set manual time noise reduction strength
2644 * this function is active for NR is manual mode
2645 * Argument:
2646 * level: [0, 100]
2647 *
2648 *****************************
2649 */
rk_aiq_uapi2_setMTNRStrth(const rk_aiq_sys_ctx_t * ctx,bool on,unsigned int level)2650 XCamReturn rk_aiq_uapi2_setMTNRStrth(const rk_aiq_sys_ctx_t* ctx, bool on, unsigned int level)
2651 {
2652 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2653 IMGPROC_FUNC_ENTER
2654 LOGD("level=%d", level);
2655 if (ctx == NULL) {
2656 ret = XCAM_RETURN_ERROR_PARAM;
2657 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, setMTNRStrth failed!");
2658 }
2659
2660 if (CHECK_ISP_HW_V20()) {
2661 ret = rk_aiq_user_api2_anr_SetLumaTFStrength(ctx, level / 100.0);
2662 }
2663
2664 if (CHECK_ISP_HW_V21()) {
2665 ret = rk_aiq_user_api2_abayernrV2_SetTFStrength(ctx, level / 100.0);
2666 }
2667
2668 if (CHECK_ISP_HW_V30()) {
2669 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
2670 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2671 bayertnrV2Strenght.strength_enable = true;
2672 bayertnrV2Strenght.percent = level / 100.0;
2673 ret = rk_aiq_user_api2_abayertnrV2_SetStrength(ctx, &bayertnrV2Strenght);
2674 }
2675
2676 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2677 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
2678 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2679 bayertnrV23Strength.strength_enable = true;
2680 bayertnrV23Strength.percent = level / 100.0;
2681 ret = rk_aiq_user_api2_abayertnrV23_SetStrength(ctx, &bayertnrV23Strength);
2682 }
2683 RKAIQ_IMGPROC_CHECK_RET(ret, "setMTNRStrth failed!", ret);
2684 IMGPROC_FUNC_EXIT
2685 return ret;
2686 }
2687
2688
2689
2690 /*
2691 *****************************
2692 *
2693 * Desc: get manual time noise reduction strength
2694 * this function is active for NR is manual mode
2695 * Argument:
2696 * level: [0, 100]
2697 *
2698 *****************************
2699 */
rk_aiq_uapi2_getMTNRStrth(const rk_aiq_sys_ctx_t * ctx,bool * on,unsigned int * level)2700 XCamReturn rk_aiq_uapi2_getMTNRStrth(const rk_aiq_sys_ctx_t* ctx, bool * on, unsigned int *level)
2701 {
2702 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2703 float percent = 0.0f;
2704 IMGPROC_FUNC_ENTER
2705 if (ctx == NULL) {
2706 ret = XCAM_RETURN_ERROR_PARAM;
2707 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, getMTNRStrth failed!");
2708 }
2709
2710 if (CHECK_ISP_HW_V20()) {
2711 ret = rk_aiq_user_api2_anr_GetLumaTFStrength(ctx, &percent);
2712 }
2713
2714 if (CHECK_ISP_HW_V21()) {
2715 ret = rk_aiq_user_api2_abayernrV2_GetTFStrength(ctx, &percent);
2716 }
2717
2718 if (CHECK_ISP_HW_V30()) {
2719 rk_aiq_bayertnr_strength_v2_t bayertnrV2Strenght;
2720 bayertnrV2Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2721 ret = rk_aiq_user_api2_abayertnrV2_GetStrength(ctx, &bayertnrV2Strenght);
2722 percent = bayertnrV2Strenght.percent;
2723 }
2724
2725 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2726 rk_aiq_bayertnr_strength_v23_t bayertnrV23Strength;
2727 bayertnrV23Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2728 ret = rk_aiq_user_api2_abayertnrV23_GetStrength(ctx, &bayertnrV23Strength);
2729 percent = bayertnrV23Strength.percent;
2730 }
2731 RKAIQ_IMGPROC_CHECK_RET(ret, "getMTNRStrth failed!", ret);
2732 *level = (unsigned int)(percent * 100);
2733 IMGPROC_FUNC_EXIT
2734 return ret;
2735 }
2736
2737
2738 /*
2739 *****************************
2740 *
2741 * Desc: Adjust image sharpness level
2742 * Argument:
2743 * level: sharpness level, [0, 100]
2744 *****************************
2745 */
rk_aiq_uapi2_setSharpness(const rk_aiq_sys_ctx_t * ctx,unsigned int level)2746 XCamReturn rk_aiq_uapi2_setSharpness(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
2747 {
2748 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2749 float fPercent = 0.0f;
2750
2751 IMGPROC_FUNC_ENTER
2752 if (ctx == NULL) {
2753 ret = XCAM_RETURN_ERROR_PARAM;
2754 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set sharpeness failed!");
2755 }
2756
2757 LOGD("setSharpness enter, level=%d\n", level);
2758 if ((int)level < 0 || level > 100) {
2759 ret = XCAM_RETURN_ERROR_PARAM;
2760 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set sharpeness failed!");
2761 }
2762 fPercent = level / 100.0f;
2763
2764
2765 if (CHECK_ISP_HW_V21()) {
2766 ret = rk_aiq_user_api2_asharpV3_SetStrength(ctx, fPercent);
2767 }
2768
2769 if (CHECK_ISP_HW_V30()) {
2770 rk_aiq_sharp_strength_v4_t sharpV4Strenght;
2771 sharpV4Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2772 sharpV4Strenght.strength_enable = true;
2773 sharpV4Strenght.percent = fPercent;
2774 ret = rk_aiq_user_api2_asharpV4_SetStrength(ctx, &sharpV4Strenght);
2775 }
2776
2777 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2778 rk_aiq_sharp_strength_v33_t sharpV33Strength;
2779 sharpV33Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2780 sharpV33Strength.strength_enable = true;
2781 sharpV33Strength.percent = fPercent;
2782 ret = rk_aiq_user_api2_asharpV33_SetStrength(ctx, &sharpV33Strength);
2783 }
2784 RKAIQ_IMGPROC_CHECK_RET(ret, "set sharpeness failed!");
2785 IMGPROC_FUNC_EXIT
2786
2787 return ret;
2788 }
2789
rk_aiq_uapi2_getSharpness(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)2790 XCamReturn rk_aiq_uapi2_getSharpness(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
2791 {
2792 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2793 float fPercent = 0.0f;
2794
2795 IMGPROC_FUNC_ENTER
2796 if (level == NULL || ctx == NULL) {
2797 ret = XCAM_RETURN_ERROR_PARAM;
2798 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get sharpeness failed!");
2799 }
2800
2801 if (CHECK_ISP_HW_V21()) {
2802 ret = rk_aiq_user_api2_asharpV3_GetStrength(ctx, &fPercent);
2803 }
2804
2805 if (CHECK_ISP_HW_V30()) {
2806 rk_aiq_sharp_strength_v4_t sharpV4Strenght;
2807 sharpV4Strenght.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2808 ret = rk_aiq_user_api2_asharpV4_GetStrength(ctx, &sharpV4Strenght);
2809 fPercent = sharpV4Strenght.percent;
2810 }
2811
2812 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
2813 rk_aiq_sharp_strength_v33_t sharpV33Strength;
2814 sharpV33Strength.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
2815 ret = rk_aiq_user_api2_asharpV33_GetStrength(ctx, &sharpV33Strength);
2816 fPercent = sharpV33Strength.percent;
2817 }
2818 RKAIQ_IMGPROC_CHECK_RET(ret, "get sharpeness failed!");
2819
2820 *level = (unsigned int)(fPercent * 100);
2821 IMGPROC_FUNC_EXIT
2822 return ret;
2823 }
2824
2825
2826 /*
2827 **********************************************************
2828 * White balance & Color
2829 **********************************************************
2830 */
2831
2832 /*
2833 *****************************
2834 *
2835 * Desc: set white balance mode
2836 * Argument:
2837 * mode: auto: auto white balance
2838 * manual: manual white balance
2839 *****************************
2840 */
rk_aiq_uapi2_setWBMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)2841 XCamReturn rk_aiq_uapi2_setWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
2842 {
2843 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2844 rk_aiq_uapiV2_wb_opMode_t attr;
2845 memset(&attr, 0, sizeof(attr));
2846 IMGPROC_FUNC_ENTER
2847 if (mode >= OP_INVAL || mode < OP_AUTO) {
2848 ret = XCAM_RETURN_ERROR_PARAM;
2849 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!");
2850 }
2851 if (mode == OP_AUTO) {
2852 attr.mode = RK_AIQ_WB_MODE_AUTO;
2853 } else if (mode == OP_MANUAL) {
2854 attr.mode = RK_AIQ_WB_MODE_MANUAL;
2855 } else {
2856 ret = XCAM_RETURN_ERROR_PARAM;
2857 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
2858 }
2859 ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, attr);
2860 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
2861 IMGPROC_FUNC_EXIT
2862 return ret;
2863 }
2864
rk_aiq_uapi2_getWBMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)2865 XCamReturn rk_aiq_uapi2_getWBMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
2866 {
2867 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2868 rk_aiq_uapiV2_wb_opMode_t attr;
2869 IMGPROC_FUNC_ENTER
2870 ret = rk_aiq_user_api2_awb_GetWpModeAttrib(ctx, &attr);
2871 RKAIQ_IMGPROC_CHECK_RET(ret, "getWBMode failed!");
2872 if (attr.mode == RK_AIQ_WB_MODE_AUTO) {
2873 *mode = OP_AUTO;
2874 } else if (attr.mode == RK_AIQ_WB_MODE_MANUAL) {
2875 *mode = OP_MANUAL;
2876 } else {
2877 *mode = OP_INVAL;
2878 }
2879 IMGPROC_FUNC_EXIT
2880 return ret;
2881 }
2882
2883
2884
2885 /*
2886 *****************************
2887 *
2888 * Desc: lock/unlock auto white balance
2889 * Argument:
2890 *
2891 *
2892 *****************************
2893 */
rk_aiq_uapi2_lockAWB(const rk_aiq_sys_ctx_t * ctx)2894 XCamReturn rk_aiq_uapi2_lockAWB(const rk_aiq_sys_ctx_t* ctx)
2895 {
2896 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2897 IMGPROC_FUNC_ENTER
2898 ret = rk_aiq_user_api2_awb_Lock(ctx);
2899 IMGPROC_FUNC_EXIT
2900 return ret;
2901 }
2902
rk_aiq_uapi2_unlockAWB(const rk_aiq_sys_ctx_t * ctx)2903 XCamReturn rk_aiq_uapi2_unlockAWB(const rk_aiq_sys_ctx_t* ctx)
2904 {
2905 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2906 IMGPROC_FUNC_ENTER
2907 ret = rk_aiq_user_api2_awb_Unlock(ctx);
2908 IMGPROC_FUNC_EXIT
2909 return ret;
2910 }
2911
2912 /*
2913 *****************************
2914 *
2915 * Desc: set manual white balance scene mode
2916 * Argument:
2917 * ct_scene:
2918 *
2919 *****************************
2920 */
rk_aiq_uapi2_setMWBScene(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_scene_t scene)2921 XCamReturn rk_aiq_uapi2_setMWBScene(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_scene_t scene)
2922 {
2923 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2924 rk_aiq_wb_mwb_attrib_t attr;
2925 memset(&attr, 0, sizeof(attr));
2926 IMGPROC_FUNC_ENTER
2927 if (ctx == NULL) {
2928 ret = XCAM_RETURN_ERROR_PARAM;
2929 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBScene failed!");
2930 }
2931
2932 if (scene < RK_AIQ_WBCT_INCANDESCENT || scene > RK_AIQ_WBCT_SHADE) {
2933 ret = XCAM_RETURN_ERROR_PARAM;
2934 RKAIQ_IMGPROC_CHECK_RET(ret, "invalid scene mode, setMWBScene failed!");
2935 }
2936 rk_aiq_uapiV2_wb_opMode_t opMode;
2937 memset(&opMode, 0, sizeof(opMode));
2938 opMode.mode = RK_AIQ_WB_MODE_MANUAL;
2939 ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode);
2940 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
2941 attr.mode = RK_AIQ_MWB_MODE_SCENE;
2942 attr.para.scene = scene;
2943 ret = rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr);
2944 RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBScene failed!");
2945 IMGPROC_FUNC_EXIT
2946 return ret;
2947 }
2948
rk_aiq_uapi2_getMWBScene(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_scene_t * scene)2949 XCamReturn rk_aiq_uapi2_getMWBScene(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_scene_t *scene)
2950 {
2951 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2952 rk_aiq_wb_mwb_attrib_t attr;
2953 memset(&attr, 0, sizeof(attr));
2954 IMGPROC_FUNC_ENTER
2955 if ((ctx == NULL) || (scene == NULL)) {
2956 ret = XCAM_RETURN_ERROR_PARAM;
2957 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBScene failed!");
2958 }
2959 //attr.mode = RK_AIQ_WB_MODE_MANUAL;
2960 ret = rk_aiq_user_api2_awb_GetMwbAttrib(ctx, &attr);
2961 RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBScene failed!");
2962 if(attr.mode == RK_AIQ_MWB_MODE_SCENE) {
2963 *scene = attr.para.scene;
2964 } else {
2965 LOGE("get manual wb scene failed, since current manual mode is not RK_AIQ_MWB_MODE_SCENE ");
2966 }
2967 IMGPROC_FUNC_EXIT
2968 return ret;
2969 }
2970
2971
2972 /*
2973 *****************************
2974 *
2975 * Desc: set manual white balance r/b gain
2976 * Argument:
2977 * ct_scene:
2978 *
2979 *****************************
2980 */
rk_aiq_uapi2_setMWBGain(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_gain_t * gain)2981 XCamReturn rk_aiq_uapi2_setMWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t *gain)
2982 {
2983 XCamReturn ret = XCAM_RETURN_NO_ERROR;
2984 rk_aiq_wb_mwb_attrib_t attr;
2985 memset(&attr, 0, sizeof(attr));
2986 IMGPROC_FUNC_ENTER
2987 if ((ctx == NULL) || (gain == NULL)) {
2988 ret = XCAM_RETURN_ERROR_PARAM;
2989 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBGain failed!");
2990 }
2991 rk_aiq_uapiV2_wb_opMode_t opMode;
2992 memset(&opMode, 0, sizeof(opMode));
2993 opMode.mode = RK_AIQ_WB_MODE_MANUAL;
2994 ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode);
2995 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
2996 attr.mode = RK_AIQ_MWB_MODE_WBGAIN;
2997 attr.para.gain = *gain;
2998 ret = rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr);
2999 RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBGain failed!");
3000 IMGPROC_FUNC_EXIT
3001 return ret;
3002 }
3003
rk_aiq_uapi2_getWBGain(const rk_aiq_sys_ctx_t * ctx,rk_aiq_wb_gain_t * gain)3004 XCamReturn rk_aiq_uapi2_getWBGain(const rk_aiq_sys_ctx_t* ctx, rk_aiq_wb_gain_t *gain)
3005 {
3006 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3007
3008 rk_aiq_wb_querry_info_t query_info;
3009 IMGPROC_FUNC_ENTER
3010 if ((ctx == NULL) || (gain == NULL)) {
3011 ret = XCAM_RETURN_ERROR_PARAM;
3012 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBGain failed!");
3013 }
3014 ret = rk_aiq_user_api2_awb_QueryWBInfo(ctx, &query_info);
3015 RKAIQ_IMGPROC_CHECK_RET(ret, "getMWBGain failed!");
3016 *gain = query_info.gain;
3017 IMGPROC_FUNC_EXIT
3018
3019 return ret;
3020 }
3021
3022 /*
3023 *****************************
3024 *
3025 * Desc: set manual white balance color temperature
3026 * Argument:
3027 * ct: color temperature value [2800, 7500]K
3028 *
3029 *****************************
3030 */
rk_aiq_uapi2_setMWBCT(const rk_aiq_sys_ctx_t * ctx,unsigned int ct)3031 XCamReturn rk_aiq_uapi2_setMWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int ct)
3032 {
3033 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3034 rk_aiq_wb_mwb_attrib_t attr;
3035 memset(&attr, 0, sizeof(attr));
3036 IMGPROC_FUNC_ENTER
3037 if (ctx == NULL) {
3038 ret = XCAM_RETURN_ERROR_PARAM;
3039 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setMWBCT failed!");
3040 }
3041 rk_aiq_uapiV2_wb_opMode_t opMode;
3042 memset(&opMode, 0, sizeof(opMode));
3043 opMode.mode = RK_AIQ_WB_MODE_MANUAL;
3044 ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode);
3045 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
3046 attr.mode = RK_AIQ_MWB_MODE_CCT;
3047 attr.para.cct.CCT = (float)ct;
3048 attr.para.cct.CCRI = 0.0f;
3049 ret = rk_aiq_user_api2_awb_SetMwbAttrib(ctx, attr);
3050 RKAIQ_IMGPROC_CHECK_RET(ret, "setMWBCT failed!");
3051 IMGPROC_FUNC_EXIT
3052 return ret;
3053
3054 }
3055
rk_aiq_uapi2_getWBCT(const rk_aiq_sys_ctx_t * ctx,unsigned int * ct)3056 XCamReturn rk_aiq_uapi2_getWBCT(const rk_aiq_sys_ctx_t* ctx, unsigned int *ct)
3057 {
3058 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3059 rk_aiq_wb_cct_t cct;
3060 IMGPROC_FUNC_ENTER
3061 if ((ctx == NULL) || (ct == NULL)) {
3062 ret = XCAM_RETURN_ERROR_PARAM;
3063 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getMWBCT failed!");
3064 }
3065 ret = rk_aiq_user_api2_awb_GetCCT(ctx, &cct);
3066 *ct = (unsigned int)cct.CCT;
3067
3068 IMGPROC_FUNC_EXIT
3069 return ret;
3070 }
3071
3072
rk_aiq_uapi2_setAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wb_awb_wbGainOffset_t offset)3073 XCamReturn rk_aiq_uapi2_setAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainOffset_t offset)
3074 {
3075 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3076 IMGPROC_FUNC_ENTER
3077 if (ctx == NULL) {
3078 ret = XCAM_RETURN_ERROR_PARAM;
3079 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setWbGainOffsetAttrib failed!");
3080 }
3081 rk_aiq_uapiV2_wb_opMode_t opMode;
3082 memset(&opMode, 0, sizeof(opMode));
3083 opMode.mode = RK_AIQ_WB_MODE_AUTO;
3084 opMode.sync.sync_mode = offset.sync.sync_mode;
3085 ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode);
3086 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
3087 ret = rk_aiq_user_api2_awb_SetWbGainOffsetAttrib(ctx, offset);
3088 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbGainOffsetAttrib failed!");
3089 IMGPROC_FUNC_EXIT
3090 return ret;
3091
3092 }
3093
rk_aiq_uapi2_getAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wb_awb_wbGainOffset_t * offset)3094 XCamReturn rk_aiq_uapi2_getAwbGainOffsetAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainOffset_t *offset)
3095 {
3096 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3097 IMGPROC_FUNC_ENTER
3098 if ((ctx == NULL) || (offset == NULL)) {
3099 ret = XCAM_RETURN_ERROR_PARAM;
3100 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getWbGainOffsetAttrib( failed!");
3101 }
3102 ret = rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(ctx, offset);
3103 RKAIQ_IMGPROC_CHECK_RET(ret, "getWbGainOffsetAttrib failed!");
3104
3105 IMGPROC_FUNC_EXIT
3106 return ret;
3107 }
3108
rk_aiq_uapi2_setAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wb_awb_wbGainAdjust_t adjust)3109 XCamReturn rk_aiq_uapi2_setAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainAdjust_t adjust)
3110 {
3111 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3112 IMGPROC_FUNC_ENTER
3113 if (ctx == NULL) {
3114 ret = XCAM_RETURN_ERROR_PARAM;
3115 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setWbGainAdjustAttrib failed!");
3116 }
3117 rk_aiq_uapiV2_wb_opMode_t opMode;
3118
3119 memset(&opMode, 0, sizeof(opMode));
3120 opMode.sync.sync_mode = adjust.sync.sync_mode;
3121 opMode.mode = RK_AIQ_WB_MODE_AUTO;
3122 ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode);
3123 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
3124 ret = rk_aiq_user_api2_awb_SetWbGainAdjustAttrib(ctx, adjust);
3125 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbGainAdjustAttrib failed!");
3126 IMGPROC_FUNC_EXIT
3127 return ret;
3128
3129 }
3130
rk_aiq_uapi2_getAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wb_awb_wbGainAdjust_t * adjust)3131 XCamReturn rk_aiq_uapi2_getAwbGainAdjustAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *adjust)
3132 {
3133 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3134 IMGPROC_FUNC_ENTER
3135 if ((ctx == NULL) || (adjust == NULL)) {
3136 ret = XCAM_RETURN_ERROR_PARAM;
3137 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getWbGainAdjustAttrib failed!");
3138 }
3139 ret = rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(ctx, adjust);
3140 RKAIQ_IMGPROC_CHECK_RET(ret, "getWbGainAdjustAttrib failed!");
3141
3142 IMGPROC_FUNC_EXIT
3143 return ret;
3144 }
3145
3146
rk_aiq_uapi2_setAwbMultiWindowAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wb_awb_mulWindow_t multiwindow)3147 XCamReturn rk_aiq_uapi2_setAwbMultiWindowAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_mulWindow_t multiwindow)
3148 {
3149 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3150 IMGPROC_FUNC_ENTER
3151 if (ctx == NULL) {
3152 ret = XCAM_RETURN_ERROR_PARAM;
3153 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setAwbMultiWindowAttrib failed!");
3154 }
3155 rk_aiq_uapiV2_wb_opMode_t opMode;
3156 memset(&opMode, 0, sizeof(opMode));
3157 opMode.mode = RK_AIQ_WB_MODE_AUTO;
3158 opMode.sync.sync_mode = multiwindow.sync.sync_mode;
3159 ret = rk_aiq_user_api2_awb_SetWpModeAttrib(ctx, opMode);
3160 RKAIQ_IMGPROC_CHECK_RET(ret, "setWbMode failed!");
3161 ret = rk_aiq_user_api2_awb_SetMultiWindowAttrib(ctx, multiwindow);
3162 RKAIQ_IMGPROC_CHECK_RET(ret, "setAwbMultiWindowAttrib failed!");
3163 IMGPROC_FUNC_EXIT
3164 return ret;
3165
3166 }
3167
rk_aiq_uapi2_getAwbMultiWindowAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wb_awb_mulWindow_t * multiwindow)3168 XCamReturn rk_aiq_uapi2_getAwbMultiWindowAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wb_awb_mulWindow_t *multiwindow)
3169 {
3170 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3171 IMGPROC_FUNC_ENTER
3172 if ((ctx == NULL) || (multiwindow == NULL)) {
3173 ret = XCAM_RETURN_ERROR_PARAM;
3174 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAwbMultiWindowAttrib failed!");
3175 }
3176 ret = rk_aiq_user_api2_awb_GetMultiWindowAttrib(ctx, multiwindow);
3177 RKAIQ_IMGPROC_CHECK_RET(ret, "getAwbMultiWindowAttrib failed!");
3178
3179 IMGPROC_FUNC_EXIT
3180 return ret;
3181 }
3182
rk_aiq_uapi2_setAwbV30AllAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wbV30_attrib_t attr)3183 XCamReturn rk_aiq_uapi2_setAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV30_attrib_t attr)
3184 {
3185 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3186 IMGPROC_FUNC_ENTER
3187 if (ctx == NULL) {
3188 ret = XCAM_RETURN_ERROR_PARAM;
3189 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setAwbV30AllAttrib failed!");
3190 }
3191 ret = rk_aiq_user_api2_awbV30_SetAllAttrib(ctx, attr);
3192 RKAIQ_IMGPROC_CHECK_RET(ret, "setAwbV30AllAttrib failed!");
3193 IMGPROC_FUNC_EXIT
3194 return ret;
3195
3196 }
3197
rk_aiq_uapi2_getAwbV30AllAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wbV30_attrib_t * attr)3198 XCamReturn rk_aiq_uapi2_getAwbV30AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV30_attrib_t *attr)
3199 {
3200 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3201 IMGPROC_FUNC_ENTER
3202 if ((ctx == NULL) || (attr == NULL)) {
3203 ret = XCAM_RETURN_ERROR_PARAM;
3204 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAwbV30AllAttrib failed!");
3205 }
3206 ret = rk_aiq_user_api2_awbV30_GetAllAttrib(ctx, attr);
3207 RKAIQ_IMGPROC_CHECK_RET(ret, "getAwbV30AllAttrib failed!");
3208
3209 IMGPROC_FUNC_EXIT
3210 return ret;
3211 }
3212
rk_aiq_uapi2_setAwbV21AllAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wbV21_attrib_t attr)3213 XCamReturn rk_aiq_uapi2_setAwbV21AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV21_attrib_t attr)
3214 {
3215 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3216 IMGPROC_FUNC_ENTER
3217 if (ctx == NULL) {
3218 ret = XCAM_RETURN_ERROR_PARAM;
3219 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, setAwbV21AllAttrib failed!");
3220 }
3221 ret = rk_aiq_user_api2_awbV21_SetAllAttrib(ctx, attr);
3222 RKAIQ_IMGPROC_CHECK_RET(ret, "setAwbV21AllAttrib failed!");
3223 IMGPROC_FUNC_EXIT
3224 return ret;
3225
3226 }
3227
rk_aiq_uapi2_getAwbV21AllAttrib(const rk_aiq_sys_ctx_t * ctx,rk_aiq_uapiV2_wbV21_attrib_t * attr)3228 XCamReturn rk_aiq_uapi2_getAwbV21AllAttrib(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapiV2_wbV21_attrib_t *attr)
3229 {
3230 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3231 IMGPROC_FUNC_ENTER
3232 if ((ctx == NULL) || (attr == NULL)) {
3233 ret = XCAM_RETURN_ERROR_PARAM;
3234 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAwbV21AllAttrib failed!");
3235 }
3236 ret = rk_aiq_user_api2_awbV21_GetAllAttrib(ctx, attr);
3237 RKAIQ_IMGPROC_CHECK_RET(ret, "getAwbV21AllAttrib failed!");
3238
3239 IMGPROC_FUNC_EXIT
3240 return ret;
3241 }
3242
3243
3244 /*
3245 **********************************************************
3246 * Focus & Zoom
3247 **********************************************************
3248 */
rk_aiq_uapi2_setFocusMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)3249 XCamReturn rk_aiq_uapi2_setFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
3250 {
3251 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3252
3253 rk_aiq_af_attrib_t attr;
3254 ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr);
3255 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMode failed!");
3256 if (mode == OP_AUTO) {
3257 attr.AfMode = RKAIQ_AF_MODE_CONTINUOUS_PICTURE;
3258 } else if (mode == OP_MANUAL) {
3259 attr.AfMode = RKAIQ_AF_MODE_FIXED;
3260 } else if (mode == OP_SEMI_AUTO) {
3261 attr.AfMode = RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM;
3262 } else {
3263 ret = XCAM_RETURN_ERROR_PARAM;
3264 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
3265 }
3266
3267 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
3268 ret = rk_aiq_user_api2_af_SetAttrib(ctx, &attr);
3269 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusMode failed!");
3270 return ret;
3271 }
3272
rk_aiq_uapi2_getFocusMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)3273 XCamReturn rk_aiq_uapi2_getFocusMode(const rk_aiq_sys_ctx_t* ctx, opMode_t *mode)
3274 {
3275 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3276
3277 rk_aiq_af_attrib_t attr;
3278 ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr);
3279 RKAIQ_IMGPROC_CHECK_RET(ret, "getFocusMode failed!");
3280 if (attr.AfMode == RKAIQ_AF_MODE_FIXED) {
3281 *mode = OP_MANUAL;
3282 } else if (attr.AfMode == RKAIQ_AF_MODE_NOT_SET) {
3283 *mode = OP_INVAL;
3284 } else if (attr.AfMode == RKAIQ_AF_MODE_ONESHOT_AFTER_ZOOM) {
3285 *mode = OP_SEMI_AUTO;
3286 } else {
3287 *mode = OP_AUTO;
3288 }
3289
3290 return ret;
3291 }
3292
rk_aiq_uapi2_setFocusPosition(const rk_aiq_sys_ctx_t * ctx,short code)3293 XCamReturn rk_aiq_uapi2_setFocusPosition(const rk_aiq_sys_ctx_t* ctx, short code)
3294 {
3295 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3296 rk_aiq_af_attrib_t attr;
3297
3298 IMGPROC_FUNC_ENTER
3299 ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr);
3300 RKAIQ_IMGPROC_CHECK_RET(ret, "setFixedModeCode failed!");
3301 attr.fixedModeDefCode = code;
3302 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
3303 ret = rk_aiq_user_api2_af_SetAttrib(ctx, &attr);
3304 RKAIQ_IMGPROC_CHECK_RET(ret, "setFixedModeCode failed!");
3305 IMGPROC_FUNC_EXIT
3306 return ret;
3307 }
3308
rk_aiq_uapi2_getFocusPosition(const rk_aiq_sys_ctx_t * ctx,short * code)3309 XCamReturn rk_aiq_uapi2_getFocusPosition(const rk_aiq_sys_ctx_t* ctx, short * code)
3310 {
3311 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3312 rk_aiq_af_attrib_t attr;
3313 IMGPROC_FUNC_ENTER
3314 ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr);
3315 RKAIQ_IMGPROC_CHECK_RET(ret, "getFixedModeCode failed!");
3316 *code = attr.fixedModeDefCode;
3317 IMGPROC_FUNC_EXIT
3318 return ret;
3319 }
3320
rk_aiq_uapi2_setFocusWin(const rk_aiq_sys_ctx_t * ctx,paRect_t * rect)3321 XCamReturn rk_aiq_uapi2_setFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect)
3322 {
3323 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3324 rk_aiq_af_attrib_t attr;
3325 IMGPROC_FUNC_ENTER
3326 ret = rk_aiq_user_api_af_GetAttrib(ctx, &attr);
3327 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusWin failed!");
3328
3329 attr.h_offs = rect->x;
3330 attr.v_offs = rect->y;
3331 attr.h_size = rect->w;
3332 attr.v_size = rect->h;
3333 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_SYNC;
3334 ret = rk_aiq_user_api2_af_SetAttrib(ctx, &attr);
3335 RKAIQ_IMGPROC_CHECK_RET(ret, "setFocusWin failed!");
3336 IMGPROC_FUNC_EXIT
3337 return ret;
3338 }
3339
rk_aiq_uapi2_getFocusWin(const rk_aiq_sys_ctx_t * ctx,paRect_t * rect)3340 XCamReturn rk_aiq_uapi2_getFocusWin(const rk_aiq_sys_ctx_t* ctx, paRect_t *rect)
3341 {
3342 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3343 rk_aiq_af_attrib_t attr;
3344 IMGPROC_FUNC_ENTER
3345 ret = rk_aiq_user_api2_af_GetAttrib(ctx, &attr);
3346 RKAIQ_IMGPROC_CHECK_RET(ret, "getFocusWin failed!");
3347
3348 rect->x = attr.h_offs;
3349 rect->y = attr.v_offs;
3350 rect->w = attr.h_size;
3351 rect->h = attr.v_size;
3352 IMGPROC_FUNC_EXIT
3353 return ret;
3354 }
3355
rk_aiq_uapi2_lockFocus(const rk_aiq_sys_ctx_t * ctx)3356 XCamReturn rk_aiq_uapi2_lockFocus(const rk_aiq_sys_ctx_t* ctx)
3357 {
3358 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3359 IMGPROC_FUNC_ENTER
3360 ret = rk_aiq_user_api2_af_Lock(ctx);
3361 IMGPROC_FUNC_EXIT
3362 return ret;
3363 }
3364
rk_aiq_uapi2_unlockFocus(const rk_aiq_sys_ctx_t * ctx)3365 XCamReturn rk_aiq_uapi2_unlockFocus(const rk_aiq_sys_ctx_t* ctx)
3366 {
3367 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3368 IMGPROC_FUNC_ENTER
3369 ret = rk_aiq_user_api2_af_Unlock(ctx);
3370 IMGPROC_FUNC_EXIT
3371 return ret;
3372 }
3373
rk_aiq_uapi2_oneshotFocus(const rk_aiq_sys_ctx_t * ctx)3374 XCamReturn rk_aiq_uapi2_oneshotFocus(const rk_aiq_sys_ctx_t* ctx)
3375 {
3376 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3377 IMGPROC_FUNC_ENTER
3378 ret = rk_aiq_user_api2_af_Oneshot(ctx);
3379 IMGPROC_FUNC_EXIT
3380 return ret;
3381 }
3382
rk_aiq_uapi2_manualTrigerFocus(const rk_aiq_sys_ctx_t * ctx)3383 XCamReturn rk_aiq_uapi2_manualTrigerFocus(const rk_aiq_sys_ctx_t* ctx)
3384 {
3385 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3386 IMGPROC_FUNC_ENTER
3387 ret = rk_aiq_user_api2_af_ManualTriger(ctx);
3388 IMGPROC_FUNC_EXIT
3389 return ret;
3390 }
3391
rk_aiq_uapi2_trackingFocus(const rk_aiq_sys_ctx_t * ctx)3392 XCamReturn rk_aiq_uapi2_trackingFocus(const rk_aiq_sys_ctx_t* ctx)
3393 {
3394 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3395 IMGPROC_FUNC_ENTER
3396 ret = rk_aiq_user_api2_af_Tracking(ctx);
3397 IMGPROC_FUNC_EXIT
3398 return ret;
3399 }
3400
rk_aiq_uapi2_getSearchPath(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_sec_path_t * path)3401 XCamReturn rk_aiq_uapi2_getSearchPath(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_sec_path_t* path)
3402 {
3403 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3404 IMGPROC_FUNC_ENTER
3405 ret = rk_aiq_user_api2_af_GetSearchPath(ctx, path);
3406 IMGPROC_FUNC_EXIT
3407
3408 return ret;
3409 }
3410
rk_aiq_uapi2_getSearchResult(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_result_t * result)3411 XCamReturn rk_aiq_uapi2_getSearchResult(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_result_t* result)
3412 {
3413 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3414
3415 IMGPROC_FUNC_ENTER
3416 ret = rk_aiq_user_api2_af_GetSearchResult(ctx, result);
3417 IMGPROC_FUNC_EXIT
3418
3419 return ret;
3420 }
3421
rk_aiq_uapi2_setOpZoomPosition(const rk_aiq_sys_ctx_t * ctx,int pos)3422 XCamReturn rk_aiq_uapi2_setOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int pos)
3423 {
3424 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3425 IMGPROC_FUNC_ENTER
3426 ret = rk_aiq_user_api2_af_SetZoomIndex(ctx, pos);
3427 IMGPROC_FUNC_EXIT
3428
3429 return ret;
3430 }
3431
rk_aiq_uapi2_getOpZoomPosition(const rk_aiq_sys_ctx_t * ctx,int * pos)3432 XCamReturn rk_aiq_uapi2_getOpZoomPosition(const rk_aiq_sys_ctx_t* ctx, int *pos)
3433 {
3434 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3435 IMGPROC_FUNC_ENTER
3436 ret = rk_aiq_user_api2_af_GetZoomIndex(ctx, pos);
3437 IMGPROC_FUNC_EXIT
3438
3439 return ret;
3440 }
3441
rk_aiq_uapi2_endOpZoomChange(const rk_aiq_sys_ctx_t * ctx)3442 XCamReturn rk_aiq_uapi2_endOpZoomChange(const rk_aiq_sys_ctx_t* ctx)
3443 {
3444 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3445
3446 IMGPROC_FUNC_ENTER
3447 ret = rk_aiq_user_api2_af_EndZoomChg(ctx);
3448 IMGPROC_FUNC_EXIT
3449
3450 return ret;
3451 }
3452
rk_aiq_uapi2_getZoomRange(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_zoomrange * range)3453 XCamReturn rk_aiq_uapi2_getZoomRange(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_zoomrange * range)
3454 {
3455 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3456 IMGPROC_FUNC_ENTER
3457 ret = rk_aiq_user_api2_af_GetZoomRange(ctx, range);
3458 IMGPROC_FUNC_EXIT
3459
3460 return ret;
3461 }
3462
rk_aiq_uapi2_getFocusRange(const rk_aiq_sys_ctx_t * ctx,rk_aiq_af_focusrange * range)3463 XCamReturn rk_aiq_uapi2_getFocusRange(const rk_aiq_sys_ctx_t* ctx, rk_aiq_af_focusrange* range)
3464 {
3465 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3466 IMGPROC_FUNC_ENTER
3467 ret = rk_aiq_user_api2_af_GetFocusRange(ctx, range);
3468 IMGPROC_FUNC_EXIT
3469
3470 return ret;
3471 }
3472
rk_aiq_uapi2_startZoomCalib(const rk_aiq_sys_ctx_t * ctx)3473 XCamReturn rk_aiq_uapi2_startZoomCalib(const rk_aiq_sys_ctx_t* ctx)
3474 {
3475 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3476 IMGPROC_FUNC_ENTER
3477 ret = rk_aiq_user_api2_af_StartZoomCalib(ctx);
3478 IMGPROC_FUNC_EXIT
3479
3480 return ret;
3481 }
3482
rk_aiq_uapi2_resetZoom(const rk_aiq_sys_ctx_t * ctx)3483 XCamReturn rk_aiq_uapi2_resetZoom(const rk_aiq_sys_ctx_t* ctx)
3484 {
3485 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3486 IMGPROC_FUNC_ENTER
3487 ret = rk_aiq_user_api2_af_resetZoom(ctx);
3488 IMGPROC_FUNC_EXIT
3489
3490 return ret;
3491 }
3492
rk_aiq_uapi2_setAngleZ(const rk_aiq_sys_ctx_t * ctx,float angleZ)3493 XCamReturn rk_aiq_uapi2_setAngleZ(const rk_aiq_sys_ctx_t* ctx, float angleZ)
3494 {
3495 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3496 IMGPROC_FUNC_ENTER
3497 ret = rk_aiq_user_api2_af_setAngleZ(ctx, angleZ);
3498 IMGPROC_FUNC_EXIT
3499
3500 return ret;
3501 }
3502
3503 /*
3504 **********************************************************
3505 * Color Correction
3506 **********************************************************
3507 */
3508 /*
3509 *****************************
3510 *
3511 * Desc: set/get color correction mode
3512 * Argument:
3513 * mode:
3514 * auto: auto color correction
3515 * manual: manual color correction
3516 *
3517 *****************************
3518 */
rk_aiq_uapi2_setCCMMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)3519 XCamReturn rk_aiq_uapi2_setCCMMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
3520 {
3521 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3522 #if RKAIQ_HAVE_CCM_V1
3523 rk_aiq_ccm_attrib_t attr;
3524 memset(&attr, 0, sizeof(attr));
3525 IMGPROC_FUNC_ENTER
3526 if (mode >= OP_INVAL || mode < OP_AUTO) {
3527 ret = XCAM_RETURN_ERROR_PARAM;
3528 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!");
3529 }
3530 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
3531 RKAIQ_IMGPROC_CHECK_RET(ret, "setCCMMode failed in getting accm attrib!");
3532
3533 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
3534 if (mode == OP_AUTO) {
3535 attr.mode = RK_AIQ_CCM_MODE_AUTO;
3536 } else if (mode == OP_MANUAL) {
3537 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
3538 } else {
3539 ret = XCAM_RETURN_ERROR_PARAM;
3540 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
3541 }
3542 ret = rk_aiq_user_api2_accm_SetAttrib(ctx, &attr);
3543 #elif RKAIQ_HAVE_CCM_V2
3544 rk_aiq_ccm_v2_attrib_t attr;
3545 memset(&attr, 0, sizeof(attr));
3546 IMGPROC_FUNC_ENTER
3547 if (mode >= OP_INVAL || mode < OP_AUTO) {
3548 ret = XCAM_RETURN_ERROR_PARAM;
3549 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!");
3550 }
3551 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
3552 RKAIQ_IMGPROC_CHECK_RET(ret, "setCCMMode failed in getting accm attrib!");
3553
3554 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
3555 if (mode == OP_AUTO) {
3556 attr.mode = RK_AIQ_CCM_MODE_AUTO;
3557 } else if (mode == OP_MANUAL) {
3558 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
3559 } else {
3560 ret = XCAM_RETURN_ERROR_PARAM;
3561 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
3562 }
3563 ret = rk_aiq_user_api2_accm_v2_SetAttrib(ctx, &attr);
3564 #endif
3565 RKAIQ_IMGPROC_CHECK_RET(ret, "setCCMMode failed!");
3566 IMGPROC_FUNC_EXIT
3567 return ret;
3568 }
3569
rk_aiq_uapi2_getCCMMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)3570 XCamReturn rk_aiq_uapi2_getCCMMode(const rk_aiq_sys_ctx_t* ctx, opMode_t* mode)
3571 {
3572 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3573 #if RKAIQ_HAVE_CCM_V1
3574 rk_aiq_ccm_attrib_t attr;
3575 memset(&attr, 0, sizeof(attr));
3576 IMGPROC_FUNC_ENTER
3577 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
3578 RKAIQ_IMGPROC_CHECK_RET(ret, "getCCMMode failed!");
3579 if (attr.mode == RK_AIQ_CCM_MODE_AUTO) {
3580 *mode = OP_AUTO;
3581 } else if (attr.mode == RK_AIQ_CCM_MODE_MANUAL) {
3582 *mode = OP_MANUAL;
3583 } else {
3584 *mode = OP_INVAL;
3585 }
3586 #elif RKAIQ_HAVE_CCM_V2
3587 rk_aiq_ccm_v2_attrib_t attr;
3588 memset(&attr, 0, sizeof(attr));
3589 IMGPROC_FUNC_ENTER
3590 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
3591 RKAIQ_IMGPROC_CHECK_RET(ret, "getCCMMode failed!");
3592 if (attr.mode == RK_AIQ_CCM_MODE_AUTO) {
3593 *mode = OP_AUTO;
3594 } else if (attr.mode == RK_AIQ_CCM_MODE_MANUAL) {
3595 *mode = OP_MANUAL;
3596 } else {
3597 *mode = OP_INVAL;
3598 }
3599 #endif
3600 IMGPROC_FUNC_EXIT
3601 return ret;
3602 }
3603
3604 /*
3605 *****************************
3606 *
3607 * Desc: set manual color correction matrix
3608 * this function is active for color correction is manual mode
3609 get color correction matrix
3610 * Argument:
3611 * mccm:
3612 * 3x3 matrix
3613 * 1x3 offset
3614 *
3615 *****************************
3616 */
rk_aiq_uapi2_setMCcCoef(const rk_aiq_sys_ctx_t * ctx,rk_aiq_ccm_matrix_t * mccm)3617 XCamReturn rk_aiq_uapi2_setMCcCoef(const rk_aiq_sys_ctx_t* ctx, rk_aiq_ccm_matrix_t* mccm)
3618 {
3619 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3620 #if RKAIQ_HAVE_CCM_V1
3621 rk_aiq_ccm_attrib_t attr;
3622 memset(&attr, 0, sizeof(attr));
3623 IMGPROC_FUNC_ENTER
3624 if ((ctx == NULL) || (mccm == NULL) ) {
3625 ret = XCAM_RETURN_ERROR_PARAM;
3626 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, set CCM Manual Matrix failed!");
3627 }
3628 ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
3629 RKAIQ_IMGPROC_CHECK_RET(ret, "Set CCM Manual Matrix failed in getting accm attrib!!");
3630
3631 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
3632 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
3633 memcpy(attr.stManual.ccMatrix, mccm->ccMatrix, sizeof(float) * 9);
3634 memcpy(attr.stManual.ccOffsets, mccm->ccOffsets, sizeof(float) * 3);
3635 ret = rk_aiq_user_api2_accm_SetAttrib(ctx, &attr);
3636 #elif RKAIQ_HAVE_CCM_V2
3637 rk_aiq_ccm_v2_attrib_t attr;
3638 memset(&attr, 0, sizeof(attr));
3639 IMGPROC_FUNC_ENTER
3640 if ((ctx == NULL) || (mccm == NULL) ) {
3641 ret = XCAM_RETURN_ERROR_PARAM;
3642 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, set CCM Manual Matrix failed!");
3643 }
3644 ret = rk_aiq_user_api2_accm_v2_GetAttrib(ctx, &attr);
3645 RKAIQ_IMGPROC_CHECK_RET(ret, "Set CCM Manual Matrix failed in getting accm attrib!!");
3646
3647 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
3648 attr.mode = RK_AIQ_CCM_MODE_MANUAL;
3649 memcpy(attr.stManual.ccMatrix, mccm->ccMatrix, sizeof(float) * 9);
3650 memcpy(attr.stManual.ccOffsets, mccm->ccOffsets, sizeof(float) * 3);
3651 ret = rk_aiq_user_api2_accm_v2_SetAttrib(ctx, &attr);
3652 #endif
3653 RKAIQ_IMGPROC_CHECK_RET(ret, "set CCM Manual Matrix failed!");
3654 IMGPROC_FUNC_EXIT
3655 return ret;
3656 }
3657
rk_aiq_uapi2_getMCcCoef(const rk_aiq_sys_ctx_t * ctx,rk_aiq_ccm_matrix_t * mccm)3658 XCamReturn rk_aiq_uapi2_getMCcCoef(const rk_aiq_sys_ctx_t* ctx, rk_aiq_ccm_matrix_t* mccm)
3659 {
3660 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3661 rk_aiq_ccm_querry_info_t ccm_querry_info;
3662 IMGPROC_FUNC_ENTER
3663 if ((ctx == NULL) || (mccm == NULL)) {
3664 ret = XCAM_RETURN_ERROR_PARAM;
3665 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get CCM Matrix failed!");
3666 }
3667
3668 ret = rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &ccm_querry_info);
3669 RKAIQ_IMGPROC_CHECK_RET(ret, "get CCM Matrix failed!");
3670
3671 for (int i = 0; i < 9; i++)
3672 mccm->ccMatrix[i] = ccm_querry_info.ccMatrix[i];
3673 for (int i = 0; i < 3; i++)
3674 mccm->ccOffsets[i] = ccm_querry_info.ccOffsets[i];
3675 IMGPROC_FUNC_EXIT
3676 return ret;
3677 }
3678
3679 /*
3680 *****************************
3681 *
3682 * Desc: get auto color correction saturation
3683 * this function is active for color correction is auto mode
3684 * Argument:
3685 * finalsat : range in [0, 100]
3686 *
3687 *****************************
3688 */
rk_aiq_uapi2_getACcmSat(const rk_aiq_sys_ctx_t * ctx,float * finalsat)3689 XCamReturn rk_aiq_uapi2_getACcmSat(const rk_aiq_sys_ctx_t* ctx, float* finalsat)
3690 {
3691 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3692 rk_aiq_ccm_querry_info_t ccm_querry_info;
3693 IMGPROC_FUNC_ENTER
3694 if ((ctx == NULL) || (finalsat == NULL)) {
3695 ret = XCAM_RETURN_ERROR_PARAM;
3696 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get Auto CCM Saturation failed!");
3697 }
3698
3699 ret = rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &ccm_querry_info);
3700 RKAIQ_IMGPROC_CHECK_RET(ret, "get CCM Auto CCM Saturation failed!");
3701 *finalsat = ccm_querry_info.finalSat;
3702 IMGPROC_FUNC_EXIT
3703 return ret;
3704 }
3705
3706 /*
3707 *****************************
3708 *
3709 * Desc: get auto color correction used ccm name
3710 * this function is active for color correction is auto mode
3711 * Argument:
3712 * ccm_name[2]
3713 *
3714 *****************************
3715 */
rk_aiq_uapi2_getACcmMatrixName(const rk_aiq_sys_ctx_t * ctx,char ** ccm_name)3716 XCamReturn rk_aiq_uapi2_getACcmMatrixName(const rk_aiq_sys_ctx_t* ctx, char** ccm_name)
3717 {
3718 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3719 rk_aiq_ccm_querry_info_t ccm_querry_info;
3720 IMGPROC_FUNC_ENTER
3721 if ((ctx == NULL) || (ccm_name == NULL)) {
3722 ret = XCAM_RETURN_ERROR_PARAM;
3723 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get Auto CCM Name failed!");
3724 }
3725
3726 ret = rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &ccm_querry_info);
3727 RKAIQ_IMGPROC_CHECK_RET(ret, "get CCM Auto CCM Name failed!");
3728 strcpy(ccm_name[0], ccm_querry_info.ccmname1);
3729 strcpy(ccm_name[1], ccm_querry_info.ccmname2);
3730 IMGPROC_FUNC_EXIT
3731 return ret;
3732 }
3733
3734 /*
3735 **********************************************************
3736 * 3-Dimensional Look Up Table
3737 **********************************************************
3738 */
3739 /*
3740 *****************************
3741 *
3742 * Desc: set/get 3dlut mode
3743 * Argument:
3744 * mode:
3745 * auto: auto 3dlut
3746 * manual: manual 3dlut
3747 *
3748 *****************************
3749 */
rk_aiq_uapi2_setLut3dMode(const rk_aiq_sys_ctx_t * ctx,opMode_t mode)3750 XCamReturn rk_aiq_uapi2_setLut3dMode(const rk_aiq_sys_ctx_t* ctx, opMode_t mode)
3751 {
3752 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3753 rk_aiq_lut3d_attrib_t attr;
3754 memset(&attr, 0, sizeof(attr));
3755 IMGPROC_FUNC_ENTER
3756 if (mode >= OP_INVAL || mode < OP_AUTO) {
3757 ret = XCAM_RETURN_ERROR_PARAM;
3758 RKAIQ_IMGPROC_CHECK_RET(ret, "mode is invalid!");
3759 }
3760 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
3761 RKAIQ_IMGPROC_CHECK_RET(ret, "set 3DLUT Mode failed in getting 3dlut attrib!");
3762
3763 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
3764 if (mode == OP_AUTO) {
3765 attr.mode = RK_AIQ_LUT3D_MODE_AUTO;
3766 } else if (mode == OP_MANUAL) {
3767 attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
3768 } else {
3769 ret = XCAM_RETURN_ERROR_PARAM;
3770 RKAIQ_IMGPROC_CHECK_RET(ret, "Not supported mode!");
3771 }
3772 ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, &attr);
3773 RKAIQ_IMGPROC_CHECK_RET(ret, "set 3DLUT Mode failed!");
3774 IMGPROC_FUNC_EXIT
3775 return ret;
3776
3777 }
3778
rk_aiq_uapi2_getLut3dMode(const rk_aiq_sys_ctx_t * ctx,opMode_t * mode)3779 XCamReturn rk_aiq_uapi2_getLut3dMode(const rk_aiq_sys_ctx_t* ctx, opMode_t* mode)
3780 {
3781 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3782 rk_aiq_lut3d_attrib_t attr;
3783 memset(&attr, 0, sizeof(attr));
3784 IMGPROC_FUNC_ENTER
3785 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
3786 RKAIQ_IMGPROC_CHECK_RET(ret, "get 3DLUT Mode failed!");
3787 if (attr.mode == RK_AIQ_LUT3D_MODE_AUTO) {
3788 *mode = OP_AUTO;
3789 } else if (attr.mode == RK_AIQ_LUT3D_MODE_MANUAL) {
3790 *mode = OP_MANUAL;
3791 } else {
3792 *mode = OP_INVAL;
3793 }
3794 IMGPROC_FUNC_EXIT
3795 return ret;
3796 }
3797
3798 /*
3799 *****************************
3800 *
3801 * Desc: set manual 3d Look-up-table
3802 * this function is active for 3dlut is manual mode
3803 get 3d Look-up-table
3804 * Argument:
3805 * mlut:
3806 * lut_r[729]
3807 * lut_g[729]
3808 * lut_b[729]
3809 *
3810 *****************************
3811 */
rk_aiq_uapi2_setM3dLut(const rk_aiq_sys_ctx_t * ctx,rk_aiq_lut3d_table_t * mlut)3812 XCamReturn rk_aiq_uapi2_setM3dLut(const rk_aiq_sys_ctx_t* ctx, rk_aiq_lut3d_table_t* mlut)
3813 {
3814 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3815 rk_aiq_lut3d_attrib_t attr;
3816 memset(&attr, 0, sizeof(attr));
3817 IMGPROC_FUNC_ENTER
3818 if ((ctx == NULL) || (mlut == NULL) ) {
3819 ret = XCAM_RETURN_ERROR_PARAM;
3820 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, set manual 3d Look-up-table failed!");
3821 }
3822
3823 ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
3824 RKAIQ_IMGPROC_CHECK_RET(ret, "set manual 3d Look-up-table in getting 3dlut attrib!");
3825
3826 attr.sync.sync_mode = RK_AIQ_UAPI_MODE_DEFAULT;
3827 attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
3828 memcpy(attr.stManual.look_up_table_r, mlut->look_up_table_r, sizeof(unsigned short) * 729);
3829 memcpy(attr.stManual.look_up_table_g, mlut->look_up_table_g, sizeof(unsigned short) * 729);
3830 memcpy(attr.stManual.look_up_table_b, mlut->look_up_table_b, sizeof(unsigned short) * 729);
3831 ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, &attr);
3832 RKAIQ_IMGPROC_CHECK_RET(ret, "set manual 3d Look-up-table failed!");
3833 IMGPROC_FUNC_EXIT
3834 return ret;
3835 }
3836
rk_aiq_uapi2_getM3dLut(const rk_aiq_sys_ctx_t * ctx,rk_aiq_lut3d_table_t * mlut)3837 XCamReturn rk_aiq_uapi2_getM3dLut(const rk_aiq_sys_ctx_t* ctx, rk_aiq_lut3d_table_t* mlut)
3838 {
3839 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3840 rk_aiq_lut3d_querry_info_t lut3d_querry_info;
3841 IMGPROC_FUNC_ENTER
3842 if ((ctx == NULL) || (mlut == NULL)) {
3843 ret = XCAM_RETURN_ERROR_PARAM;
3844 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get 3d Look-up-table failed!");
3845 }
3846
3847 ret = rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &lut3d_querry_info);
3848 RKAIQ_IMGPROC_CHECK_RET(ret, "get 3d Look-up-table failed!");
3849
3850 memcpy(mlut->look_up_table_r, lut3d_querry_info.look_up_table_r, sizeof(unsigned short) * 729);
3851 memcpy(mlut->look_up_table_g, lut3d_querry_info.look_up_table_g, sizeof(unsigned short) * 729);
3852 memcpy(mlut->look_up_table_b, lut3d_querry_info.look_up_table_b, sizeof(unsigned short) * 729);
3853
3854 IMGPROC_FUNC_EXIT
3855 return ret;
3856 }
3857
3858 /*
3859 *****************************
3860 *
3861 * Desc: get auto 3d Look-up-table strength
3862 * this function is active for 3d Look-up-table is auto mode
3863 * Argument:
3864 * alpha : range in [0, 1]
3865 *
3866 *****************************
3867 */
rk_aiq_uapi2_getA3dLutStrth(const rk_aiq_sys_ctx_t * ctx,float * alpha)3868 XCamReturn rk_aiq_uapi2_getA3dLutStrth(const rk_aiq_sys_ctx_t* ctx, float* alpha)
3869 {
3870 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3871 rk_aiq_lut3d_querry_info_t lut3d_querry_info;
3872 IMGPROC_FUNC_ENTER
3873 if ((ctx == NULL) || (alpha == NULL)) {
3874 ret = XCAM_RETURN_ERROR_PARAM;
3875 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAuto3DLUT 3d Look-up-table Strength failed!");
3876 }
3877
3878 ret = rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &lut3d_querry_info);
3879 RKAIQ_IMGPROC_CHECK_RET(ret, "getAuto3DLUT 3d Look-up-table Strength failed!");
3880 *alpha = lut3d_querry_info.alpha;
3881 IMGPROC_FUNC_EXIT
3882 return ret;
3883 }
3884
3885 /*
3886 *****************************
3887 *
3888 * Desc: get auto 3d Look-up-table used lut name
3889 * this function is active for 3d Look-up-table is auto mode
3890 * Argument:
3891 * name
3892 *
3893 *****************************
3894 */
rk_aiq_uapi2_getA3dLutName(const rk_aiq_sys_ctx_t * ctx,char * name)3895 XCamReturn rk_aiq_uapi2_getA3dLutName(const rk_aiq_sys_ctx_t* ctx, char* name)
3896 {
3897 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3898 rk_aiq_lut3d_querry_info_t lut3d_querry_info;
3899 IMGPROC_FUNC_ENTER
3900 if ((ctx == NULL) || (name == NULL)) {
3901 ret = XCAM_RETURN_ERROR_PARAM;
3902 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getAuto3DLUT 3d Look-up-table Name failed!");
3903 }
3904
3905 ret = rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &lut3d_querry_info);
3906 RKAIQ_IMGPROC_CHECK_RET(ret, "getAuto3DLUT 3d Look-up-table Name failed!");
3907 strcpy(name, lut3d_querry_info.name);
3908 IMGPROC_FUNC_EXIT
3909 return ret;
3910 }
3911
rk_aiq_uapi2_setLdchEn(const rk_aiq_sys_ctx_t * ctx,bool en)3912 XCamReturn rk_aiq_uapi2_setLdchEn(const rk_aiq_sys_ctx_t* ctx, bool en)
3913 {
3914 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3915 IMGPROC_FUNC_ENTER
3916 if (ctx == NULL) {
3917 ret = XCAM_RETURN_ERROR_PARAM;
3918 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
3919 }
3920 rk_aiq_ldch_attrib_t ldchAttr;
3921 ret = rk_aiq_user_api2_aldch_GetAttrib(ctx, &ldchAttr);
3922 RKAIQ_IMGPROC_CHECK_RET(ret, "get ldch attrib failed!");
3923 ldchAttr.en = en;
3924 ret = rk_aiq_user_api2_aldch_SetAttrib(ctx, &ldchAttr);
3925 IMGPROC_FUNC_EXIT
3926 return ret;
3927 }
3928
rk_aiq_uapi2_setLdchCorrectLevel(const rk_aiq_sys_ctx_t * ctx,int correctLevel)3929 XCamReturn rk_aiq_uapi2_setLdchCorrectLevel(const rk_aiq_sys_ctx_t* ctx, int correctLevel)
3930 {
3931 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3932 IMGPROC_FUNC_ENTER
3933 if (ctx == NULL) {
3934 ret = XCAM_RETURN_ERROR_PARAM;
3935 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
3936 }
3937 rk_aiq_ldch_attrib_t ldchAttr;
3938 ret = rk_aiq_user_api2_aldch_GetAttrib(ctx, &ldchAttr);
3939 RKAIQ_IMGPROC_CHECK_RET(ret, "get ldch attrib failed!");
3940 ldchAttr.correct_level = correctLevel;
3941 ret = rk_aiq_user_api2_aldch_SetAttrib(ctx, &ldchAttr);
3942 IMGPROC_FUNC_EXIT
3943 return ret;
3944 }
3945
rk_aiq_uapi2_setFecEn(const rk_aiq_sys_ctx_t * ctx,bool en)3946 XCamReturn rk_aiq_uapi2_setFecEn(const rk_aiq_sys_ctx_t* ctx, bool en)
3947 {
3948 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3949 IMGPROC_FUNC_ENTER
3950 if (ctx == NULL) {
3951 ret = XCAM_RETURN_ERROR_PARAM;
3952 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
3953 }
3954 rk_aiq_fec_attrib_t fecAttr;
3955 ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr);
3956 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
3957 fecAttr.en = en;
3958 ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr);
3959 IMGPROC_FUNC_EXIT
3960 return ret;
3961 }
3962
rk_aiq_uapi2_setFecBypass(const rk_aiq_sys_ctx_t * ctx,bool bypass)3963 XCamReturn rk_aiq_uapi2_setFecBypass(const rk_aiq_sys_ctx_t* ctx, bool bypass)
3964 {
3965 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3966 IMGPROC_FUNC_ENTER
3967 if (ctx == NULL) {
3968 ret = XCAM_RETURN_ERROR_PARAM;
3969 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
3970 }
3971 rk_aiq_fec_attrib_t fecAttr;
3972 ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr);
3973 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
3974 fecAttr.bypass = bypass;
3975 ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr);
3976 IMGPROC_FUNC_EXIT
3977 return ret;
3978 }
3979
rk_aiq_uapi2_setFecCorrectLevel(const rk_aiq_sys_ctx_t * ctx,int correctLevel)3980 XCamReturn rk_aiq_uapi2_setFecCorrectLevel(const rk_aiq_sys_ctx_t* ctx, int correctLevel)
3981 {
3982 XCamReturn ret = XCAM_RETURN_NO_ERROR;
3983 IMGPROC_FUNC_ENTER
3984 if (ctx == NULL) {
3985 ret = XCAM_RETURN_ERROR_PARAM;
3986 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
3987 }
3988 rk_aiq_fec_attrib_t fecAttr;
3989 ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr);
3990 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
3991 fecAttr.correct_level = correctLevel;
3992 ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr);
3993 IMGPROC_FUNC_EXIT
3994 return ret;
3995 }
3996
rk_aiq_uapi2_setFecCorrectDirection(const rk_aiq_sys_ctx_t * ctx,const fec_correct_direction_t direction)3997 XCamReturn rk_aiq_uapi2_setFecCorrectDirection(const rk_aiq_sys_ctx_t* ctx,
3998 const fec_correct_direction_t direction)
3999 {
4000 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4001 IMGPROC_FUNC_ENTER
4002 if (ctx == NULL) {
4003 ret = XCAM_RETURN_ERROR_PARAM;
4004 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
4005 }
4006 rk_aiq_fec_attrib_t fecAttr;
4007 ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr);
4008 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
4009 fecAttr.direction = direction;
4010 ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr);
4011 IMGPROC_FUNC_EXIT
4012 return ret;
4013 }
4014
rk_aiq_uapi2_setFecCorrectMode(const rk_aiq_sys_ctx_t * ctx,const fec_correct_mode_t mode)4015 XCamReturn rk_aiq_uapi2_setFecCorrectMode(const rk_aiq_sys_ctx_t* ctx,
4016 const fec_correct_mode_t mode)
4017 {
4018 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4019 IMGPROC_FUNC_ENTER
4020 if (ctx == NULL) {
4021 ret = XCAM_RETURN_ERROR_PARAM;
4022 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
4023 }
4024 rk_aiq_fec_attrib_t fecAttr;
4025 ret = rk_aiq_user_api2_afec_GetAttrib(ctx, &fecAttr);
4026 RKAIQ_IMGPROC_CHECK_RET(ret, "get fec attrib failed!");
4027 fecAttr.mode = mode;
4028 ret = rk_aiq_user_api2_afec_SetAttrib(ctx, fecAttr);
4029 IMGPROC_FUNC_EXIT
4030 return ret;
4031 }
4032
rk_aiq_uapi2_setMirrorFlip(const rk_aiq_sys_ctx_t * ctx,bool mirror,bool flip,int skip_frm_cnt)4033 XCamReturn rk_aiq_uapi2_setMirrorFlip(const rk_aiq_sys_ctx_t* ctx, bool mirror, bool flip,
4034 int skip_frm_cnt) {
4035 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4036 IMGPROC_FUNC_ENTER
4037 if (ctx == NULL) {
4038 ret = XCAM_RETURN_ERROR_PARAM;
4039 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
4040 }
4041 return ctx->_rkAiqManager->setMirrorFlip(mirror, flip, skip_frm_cnt);
4042 }
4043
rk_aiq_uapi2_getMirrorFlip(const rk_aiq_sys_ctx_t * ctx,bool * mirror,bool * flip)4044 XCamReturn rk_aiq_uapi2_getMirrorFlip(const rk_aiq_sys_ctx_t* ctx, bool* mirror, bool* flip) {
4045 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4046 IMGPROC_FUNC_ENTER
4047 if (ctx == NULL || mirror == NULL || flip == NULL) {
4048 ret = XCAM_RETURN_ERROR_PARAM;
4049 RKAIQ_IMGPROC_CHECK_RET(ret, "param error!");
4050 }
4051 return ctx->_rkAiqManager->getMirrorFlip(*mirror, *flip);
4052 }
4053
4054 /*
4055 **********************************************************
4056 * Color Process
4057 **********************************************************
4058 */
4059
4060 /*
4061 *****************************
4062 *
4063 * Desc: Adjust image contrast level
4064 * Argument:
4065 * level: contrast level, [0, 255]
4066 *****************************
4067 */
rk_aiq_uapi2_setContrast(const rk_aiq_sys_ctx_t * ctx,unsigned int level)4068 XCamReturn rk_aiq_uapi2_setContrast(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
4069 {
4070 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4071 IMGPROC_FUNC_ENTER
4072
4073 LOGD("setContrast enter, level=%d\n", level);
4074 acp_attrib_t attrib;
4075 if ((int)level < 0 || level > 255) {
4076 ret = XCAM_RETURN_ERROR_PARAM;
4077 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, setContrast failed!");
4078 }
4079
4080 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4081 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set contrast failed!");
4082 attrib.contrast = level;
4083 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attrib);
4084 RKAIQ_IMGPROC_CHECK_RET(ret, "set contrast failed!");
4085 IMGPROC_FUNC_EXIT
4086
4087 return ret;
4088 }
4089
rk_aiq_uapi2_getContrast(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)4090 XCamReturn rk_aiq_uapi2_getContrast(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
4091 {
4092 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4093 IMGPROC_FUNC_ENTER
4094 acp_attrib_t attrib;
4095 if (level == NULL || ctx == NULL) {
4096 ret = XCAM_RETURN_ERROR_PARAM;
4097 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getContrast failed!");
4098 }
4099 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4100 RKAIQ_IMGPROC_CHECK_RET(ret, "get contrast failed!");
4101 *level = attrib.contrast;
4102 IMGPROC_FUNC_EXIT
4103 return ret;
4104 }
4105
4106 /*
4107 *****************************
4108 *
4109 * Desc: Adjust image brightness level
4110 * Argument:
4111 * level: brightness level, [0, 255]
4112 *****************************
4113 */
rk_aiq_uapi2_setBrightness(const rk_aiq_sys_ctx_t * ctx,unsigned int level)4114 XCamReturn rk_aiq_uapi2_setBrightness(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
4115 {
4116 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4117 acp_attrib_t attrib;
4118
4119 IMGPROC_FUNC_ENTER
4120 if (ctx == NULL) {
4121 ret = XCAM_RETURN_ERROR_PARAM;
4122 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set brightness failed!");
4123 }
4124
4125 LOGD("setBrightness enter, level=%d\n", level);
4126 if ((int)level < 0 || level > 255) {
4127 ret = XCAM_RETURN_ERROR_PARAM;
4128 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set brightness failed!");
4129 }
4130 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4131 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set brightness failed!");
4132 attrib.brightness = level;
4133 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attrib);
4134 RKAIQ_IMGPROC_CHECK_RET(ret, "set brightness failed!");
4135 IMGPROC_FUNC_EXIT
4136 return ret;
4137 }
4138
rk_aiq_uapi2_getBrightness(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)4139 XCamReturn rk_aiq_uapi2_getBrightness(const rk_aiq_sys_ctx_t* ctx, unsigned int *level)
4140 {
4141 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4142 IMGPROC_FUNC_ENTER
4143 acp_attrib_t attrib;
4144 if (level == NULL || ctx == NULL) {
4145 ret = XCAM_RETURN_ERROR_PARAM;
4146 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get brightness failed!");
4147 }
4148 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4149 RKAIQ_IMGPROC_CHECK_RET(ret, "get brightness failed!");
4150 *level = attrib.brightness;
4151 IMGPROC_FUNC_EXIT
4152 return ret;
4153 }
4154
4155 /*
4156 *****************************
4157 *
4158 * Desc: Adjust image saturation level
4159 * Argument:
4160 * level: saturation level, [0, 255]
4161 *****************************
4162 */
rk_aiq_uapi2_setSaturation(const rk_aiq_sys_ctx_t * ctx,unsigned int level)4163 XCamReturn rk_aiq_uapi2_setSaturation(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
4164 {
4165 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4166 acp_attrib_t attrib;
4167
4168 IMGPROC_FUNC_ENTER
4169 if (ctx == NULL) {
4170 ret = XCAM_RETURN_ERROR_PARAM;
4171 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set saturation failed!");
4172 }
4173
4174 LOGD("setSaturation enter, level=%d\n", level);
4175 if ((int)level < 0 || level > 255) {
4176 ret = XCAM_RETURN_ERROR_PARAM;
4177 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set saturation failed!");
4178 }
4179 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4180 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set saturation failed!");
4181 attrib.saturation = level;
4182 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attrib);
4183 RKAIQ_IMGPROC_CHECK_RET(ret, "set saturation failed!");
4184 IMGPROC_FUNC_EXIT
4185 return ret;
4186 }
4187
rk_aiq_uapi2_getSaturation(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)4188 XCamReturn rk_aiq_uapi2_getSaturation(const rk_aiq_sys_ctx_t* ctx, unsigned int* level)
4189 {
4190 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4191 IMGPROC_FUNC_ENTER
4192 acp_attrib_t attrib;
4193 if (level == NULL || ctx == NULL) {
4194 ret = XCAM_RETURN_ERROR_PARAM;
4195 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get saturation failed!");
4196 }
4197 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4198 RKAIQ_IMGPROC_CHECK_RET(ret, "get saturation failed!");
4199 *level = attrib.saturation;
4200 IMGPROC_FUNC_EXIT
4201 return ret;
4202 }
4203
4204 /*
4205 *****************************
4206 *
4207 * Desc: Adjust image hue level
4208 * Argument:
4209 * level: hue level, [0, 255]
4210 *****************************
4211 */
rk_aiq_uapi2_setHue(const rk_aiq_sys_ctx_t * ctx,unsigned int level)4212 XCamReturn rk_aiq_uapi2_setHue(const rk_aiq_sys_ctx_t* ctx, unsigned int level)
4213 {
4214 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4215 acp_attrib_t attrib;
4216
4217 IMGPROC_FUNC_ENTER
4218 if (ctx == NULL) {
4219 ret = XCAM_RETURN_ERROR_PARAM;
4220 RKAIQ_IMGPROC_CHECK_RET(ret, "ctx is null, set hue failed!");
4221 }
4222
4223 LOGD("setHue enter, level=%d\n", level);
4224 if ((int)level < 0 || level > 255) {
4225 ret = XCAM_RETURN_ERROR_PARAM;
4226 RKAIQ_IMGPROC_CHECK_RET(ret, "level out of range, set hue failed!");
4227 }
4228 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4229 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set hue failed!");
4230 attrib.hue = level;
4231 ret = rk_aiq_user_api2_acp_SetAttrib(ctx, &attrib);
4232 RKAIQ_IMGPROC_CHECK_RET(ret, "set hue failed!");
4233 IMGPROC_FUNC_EXIT
4234 return ret;
4235 }
4236
rk_aiq_uapi2_getHue(const rk_aiq_sys_ctx_t * ctx,unsigned int * level)4237 XCamReturn rk_aiq_uapi2_getHue(const rk_aiq_sys_ctx_t* ctx, unsigned int* level)
4238 {
4239 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4240 IMGPROC_FUNC_ENTER
4241 acp_attrib_t attrib;
4242 if (level == NULL || ctx == NULL) {
4243 ret = XCAM_RETURN_ERROR_PARAM;
4244 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, get hue failed!");
4245 }
4246 ret = rk_aiq_user_api2_acp_GetAttrib(ctx, &attrib);
4247 RKAIQ_IMGPROC_CHECK_RET(ret, "get hue failed!");
4248 *level = attrib.hue;
4249 IMGPROC_FUNC_EXIT
4250 return ret;
4251 }
4252
4253 /*
4254 **********************************************************
4255 * Image Effect
4256 **********************************************************
4257 */
4258
4259 /*
4260 *****************************
4261 *
4262 * Desc: Set Color Mode
4263 * Argument:
4264 * mode:
4265 * [0 NONE
4266 * 1 BW
4267 * 2 NEGATIVE
4268 * 3 SEPIA
4269 * 4 EMBOSS
4270 * 5 SKETCH
4271 * 6 SHARPEN]
4272 * Note: rv1106 only support {0,1}
4273 *****************************
4274 */
rk_aiq_uapi2_setColorMode(const rk_aiq_sys_ctx_t * ctx,unsigned int mode)4275 XCamReturn rk_aiq_uapi2_setColorMode(const rk_aiq_sys_ctx_t* ctx, unsigned int mode)
4276 {
4277 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4278 IMGPROC_FUNC_ENTER
4279
4280 LOGD("setColorMode enter, mode=%d\n", mode);
4281 aie_attrib_t attrib;
4282 if ((int)mode < 0 || mode > 6) {
4283 ret = XCAM_RETURN_ERROR_PARAM;
4284 RKAIQ_IMGPROC_CHECK_RET(ret, "mode out of range, setColorMode failed!");
4285 }
4286
4287 ret = rk_aiq_user_api2_aie_GetAttrib(ctx, &attrib);
4288 RKAIQ_IMGPROC_CHECK_RET(ret, "getAttrib error,set ColorMode failed!");
4289 attrib.mode = (rk_aiq_ie_effect_t)mode;
4290 ret = rk_aiq_user_api2_aie_SetAttrib(ctx, &attrib);
4291 RKAIQ_IMGPROC_CHECK_RET(ret, "set ColorMode failed!");
4292 IMGPROC_FUNC_EXIT
4293
4294 return ret;
4295 }
4296
rk_aiq_uapi2_getColorMode(const rk_aiq_sys_ctx_t * ctx,unsigned int * mode)4297 XCamReturn rk_aiq_uapi2_getColorMode(const rk_aiq_sys_ctx_t* ctx, unsigned int *mode)
4298 {
4299 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4300 IMGPROC_FUNC_ENTER
4301 aie_attrib_t attrib;
4302 if (mode == NULL || ctx == NULL) {
4303 ret = XCAM_RETURN_ERROR_PARAM;
4304 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getColorMode failed!");
4305 }
4306 ret = rk_aiq_user_api2_aie_GetAttrib(ctx, &attrib);
4307 RKAIQ_IMGPROC_CHECK_RET(ret, "get ColorMode failed!");
4308 *mode = (unsigned int)attrib.mode;
4309 IMGPROC_FUNC_EXIT
4310 return ret;
4311 }
4312
rk_aiq_uapi2_setGrayMode(const rk_aiq_sys_ctx_t * ctx,rk_aiq_gray_mode_t mode)4313 XCamReturn rk_aiq_uapi2_setGrayMode(const rk_aiq_sys_ctx_t* ctx, rk_aiq_gray_mode_t mode)
4314 {
4315 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4316 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
4317 #ifdef RKAIQ_ENABLE_CAMGROUP
4318 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
4319 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
4320 if (!camCtx)
4321 continue;
4322
4323 ret = camCtx->_analyzer->setGrayMode(mode);
4324 }
4325 #else
4326 return XCAM_RETURN_ERROR_FAILED;
4327 #endif
4328 } else {
4329 ret = ctx->_analyzer->setGrayMode(mode);
4330 }
4331
4332 return ret;
4333 }
4334
rk_aiq_uapi2_getGrayMode(const rk_aiq_sys_ctx_t * ctx)4335 rk_aiq_gray_mode_t rk_aiq_uapi2_getGrayMode(const rk_aiq_sys_ctx_t* ctx)
4336 {
4337 if (ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
4338 #ifdef RKAIQ_ENABLE_CAMGROUP
4339 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)ctx;
4340 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
4341 if (!camCtx)
4342 continue;
4343
4344 return camCtx->_analyzer->getGrayMode();
4345 }
4346 #else
4347 return RK_AIQ_GRAY_MODE_OFF;
4348 #endif
4349 } else {
4350 return ctx->_analyzer->getGrayMode();
4351 }
4352
4353 return RK_AIQ_GRAY_MODE_OFF;
4354 }
4355
4356 /*
4357 **********************************************************
4358 * Color Space
4359 **********************************************************
4360 */
4361
4362 /*
4363 *****************************
4364 *
4365 * Desc: Set Color Space
4366 * Argument:
4367 * Cspace:
4368 * [0 BT.601 FULL
4369 * 1 BT.601 LIMIT
4370 * 2 BT.709 FULL
4371 * 3 BT.709 LIMIT
4372 * 255 OTHER]
4373 *****************************
4374 */
rk_aiq_uapi2_setColorSpace(const rk_aiq_sys_ctx_t * ctx,int Cspace)4375 XCamReturn rk_aiq_uapi2_setColorSpace(const rk_aiq_sys_ctx_t* ctx, int Cspace)
4376 {
4377 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4378 IMGPROC_FUNC_ENTER
4379
4380 LOGD("setColorSpace enter, Cspace=%d\n", Cspace);
4381 rk_aiq_uapi_acsm_attrib_t csm_attrib;
4382 rk_aiq_uapi_acgc_attrib_t cgc_attrib;
4383 memset(&csm_attrib, 0, sizeof(rk_aiq_uapi_acsm_attrib_t));
4384 memset(&cgc_attrib, 0, sizeof(rk_aiq_uapi_acgc_attrib_t));
4385 if (Cspace < 0 || Cspace > 3) {
4386 ret = XCAM_RETURN_ERROR_PARAM;
4387 RKAIQ_IMGPROC_CHECK_RET(ret, "mode out of range, setColorSpace failed!");
4388 }
4389
4390 XCamReturn ret1 = XCAM_RETURN_NO_ERROR;
4391 XCamReturn ret2 = XCAM_RETURN_NO_ERROR;
4392
4393 ret1 = rk_aiq_user_api2_acsm_GetAttrib(ctx, &csm_attrib);
4394 ret2 = rk_aiq_user_api2_acgc_GetAttrib(ctx, &cgc_attrib);
4395 if (ret1 != XCAM_RETURN_NO_ERROR || ret2 != XCAM_RETURN_NO_ERROR) {
4396 LOGE("getAttrib error,set ColorSpace failed!");
4397 return XCAM_RETURN_ERROR_FAILED;
4398 }
4399
4400 csm_attrib.param.op_mode = RK_AIQ_OP_MODE_MANUAL;
4401 cgc_attrib.param.op_mode = RK_AIQ_OP_MODE_MANUAL;
4402 switch (Cspace) {
4403 case 0:
4404 csm_attrib.param.full_range = true;
4405 csm_attrib.param.y_offset = 0;
4406 csm_attrib.param.c_offset = 0;
4407 csm_attrib.param.coeff[0] = 0.299;
4408 csm_attrib.param.coeff[1] = 0.587;
4409 csm_attrib.param.coeff[2] = 0.114;
4410 csm_attrib.param.coeff[3] = -0.169;
4411 csm_attrib.param.coeff[4] = -0.331;
4412 csm_attrib.param.coeff[5] = 0.5;
4413 csm_attrib.param.coeff[6] = 0.5;
4414 csm_attrib.param.coeff[7] = -0.419;
4415 csm_attrib.param.coeff[8] = -0.081;
4416 cgc_attrib.param.cgc_ratio_en = 0;
4417 cgc_attrib.param.cgc_yuv_limit = 0;
4418 break;
4419 case 1:
4420 csm_attrib.param.full_range = true;
4421 csm_attrib.param.y_offset = 0;
4422 csm_attrib.param.c_offset = 0;
4423 csm_attrib.param.coeff[0] = 0.257;
4424 csm_attrib.param.coeff[1] = 0.504;
4425 csm_attrib.param.coeff[2] = 0.098;
4426 csm_attrib.param.coeff[3] = -0.148;
4427 csm_attrib.param.coeff[4] = -0.291;
4428 csm_attrib.param.coeff[5] = 0.439;
4429 csm_attrib.param.coeff[6] = 0.439;
4430 csm_attrib.param.coeff[7] = -0.368;
4431 csm_attrib.param.coeff[8] = -0.071;
4432 cgc_attrib.param.cgc_ratio_en = 0;
4433 cgc_attrib.param.cgc_yuv_limit = 1;
4434 break;
4435 case 2:
4436 csm_attrib.param.full_range = true;
4437 csm_attrib.param.y_offset = 0;
4438 csm_attrib.param.c_offset = 0;
4439 csm_attrib.param.coeff[0] = 0.2126;
4440 csm_attrib.param.coeff[1] = 0.7152;
4441 csm_attrib.param.coeff[2] = 0.0722;
4442 csm_attrib.param.coeff[3] = -0.1146;
4443 csm_attrib.param.coeff[4] = -0.3854;
4444 csm_attrib.param.coeff[5] = 0.5;
4445 csm_attrib.param.coeff[6] = 0.5;
4446 csm_attrib.param.coeff[7] = -0.4542;
4447 csm_attrib.param.coeff[8] = -0.0468;
4448 cgc_attrib.param.cgc_ratio_en = 0;
4449 cgc_attrib.param.cgc_yuv_limit = 0;
4450 break;
4451 case 3:
4452 csm_attrib.param.full_range = true;
4453 csm_attrib.param.y_offset = 0;
4454 csm_attrib.param.c_offset = 0;
4455 csm_attrib.param.coeff[0] = 0.1826;
4456 csm_attrib.param.coeff[1] = 0.6142;
4457 csm_attrib.param.coeff[2] = 0.0620;
4458 csm_attrib.param.coeff[3] = -0.1006;
4459 csm_attrib.param.coeff[4] = -0.3386;
4460 csm_attrib.param.coeff[5] = 0.4392;
4461 csm_attrib.param.coeff[6] = 0.4392;
4462 csm_attrib.param.coeff[7] = -0.3989;
4463 csm_attrib.param.coeff[8] = -0.0403;
4464 cgc_attrib.param.cgc_ratio_en = 0;
4465 cgc_attrib.param.cgc_yuv_limit = 1;
4466 break;
4467 default:
4468 break;
4469 }
4470 ret1 = rk_aiq_user_api2_acsm_SetAttrib(ctx, &csm_attrib);
4471 ret2 = rk_aiq_user_api2_acgc_SetAttrib(ctx, &cgc_attrib);
4472 if (ret1 != XCAM_RETURN_NO_ERROR || ret2 != XCAM_RETURN_NO_ERROR) {
4473 LOGE("set ColorSpace failed!");
4474 return XCAM_RETURN_ERROR_FAILED;
4475 }
4476 IMGPROC_FUNC_EXIT
4477
4478 return ret;
4479 }
4480
rk_aiq_uapi2_getColorSpace(const rk_aiq_sys_ctx_t * ctx,int * Cspace)4481 XCamReturn rk_aiq_uapi2_getColorSpace(const rk_aiq_sys_ctx_t* ctx, int *Cspace)
4482 {
4483 XCamReturn ret = XCAM_RETURN_NO_ERROR;
4484 IMGPROC_FUNC_ENTER
4485 rk_aiq_uapi_acsm_attrib_t csm_attrib;
4486 rk_aiq_uapi_acgc_attrib_t cgc_attrib;
4487 memset(&csm_attrib, 0, sizeof(rk_aiq_uapi_acsm_attrib_t));
4488 memset(&cgc_attrib, 0, sizeof(rk_aiq_uapi_acgc_attrib_t));
4489 if (Cspace == NULL || ctx == NULL) {
4490 ret = XCAM_RETURN_ERROR_PARAM;
4491 RKAIQ_IMGPROC_CHECK_RET(ret, "param error, getColorSpace failed!");
4492 }
4493 XCamReturn ret1 = XCAM_RETURN_NO_ERROR;
4494 XCamReturn ret2 = XCAM_RETURN_NO_ERROR;
4495
4496 ret1 = rk_aiq_user_api2_acsm_GetAttrib(ctx, &csm_attrib);
4497 ret2 = rk_aiq_user_api2_acgc_GetAttrib(ctx, &cgc_attrib);
4498 if (ret1 != XCAM_RETURN_NO_ERROR || ret2 != XCAM_RETURN_NO_ERROR) {
4499 LOGE("getAttrib error,get ColorSpace failed!");
4500 return XCAM_RETURN_ERROR_FAILED;
4501 }
4502
4503 static Csm_Param_t g_csm_601fa_def = {
4504 .op_mode = RK_AIQ_OP_MODE_AUTO,
4505 .full_range = true,
4506 .y_offset = 0,
4507 .c_offset = 0,
4508 .coeff = {
4509 0.299, 0.587, 0.114,
4510 -0.169, -0.331, 0.5,
4511 0.5, -0.419, -0.081
4512 }
4513 };
4514 static Csm_Param_t g_csm_601fm_def = {
4515 .op_mode = RK_AIQ_OP_MODE_MANUAL,
4516 .full_range = true,
4517 .y_offset = 0,
4518 .c_offset = 0,
4519 .coeff = {
4520 0.299, 0.587, 0.114,
4521 -0.169, -0.331, 0.5,
4522 0.5, -0.419, -0.081
4523 }
4524 };
4525 static Csm_Param_t g_csm_601l_def = {
4526 .op_mode = RK_AIQ_OP_MODE_MANUAL,
4527 .full_range = true,
4528 .y_offset = 0,
4529 .c_offset = 0,
4530 .coeff = {
4531 0.257, 0.504, 0.098,
4532 -0.148, -0.291, 0.439,
4533 0.439, -0.368, -0.071
4534 }
4535 };
4536 static Csm_Param_t g_csm_709fa_def = {
4537 .op_mode = RK_AIQ_OP_MODE_AUTO,
4538 .full_range = true,
4539 .y_offset = 0,
4540 .c_offset = 0,
4541 .coeff = {
4542 0.2126, 0.7152, 0.0722,
4543 -0.1146, -0.3854, 0.5000,
4544 0.5000, -0.4542, -0.0468,
4545 }
4546 };
4547 static Csm_Param_t g_csm_709fm_def = {
4548 .op_mode = RK_AIQ_OP_MODE_MANUAL,
4549 .full_range = true,
4550 .y_offset = 0,
4551 .c_offset = 0,
4552 .coeff = {
4553 0.2126, 0.7152, 0.0722,
4554 -0.1146, -0.3854, 0.5000,
4555 0.5000, -0.4542, -0.0468,
4556 }
4557 };
4558 static Csm_Param_t g_csm_709l_def = {
4559 .op_mode = RK_AIQ_OP_MODE_MANUAL,
4560 .full_range = true,
4561 .y_offset = 0,
4562 .c_offset = 0,
4563 .coeff = {
4564 0.1826, 0.6142, 0.0620,
4565 -0.1006, -0.3386, 0.4392,
4566 0.4392, -0.3989, -0.0403
4567 }
4568 };
4569 if (cgc_attrib.param.cgc_yuv_limit == true) {
4570 if (!memcmp(&csm_attrib.param, &g_csm_601l_def, sizeof(g_csm_601l_def)))
4571 *Cspace = 1;
4572 else if (!memcmp(&csm_attrib.param, &g_csm_709l_def, sizeof(g_csm_709l_def)))
4573 *Cspace = 3;
4574 else
4575 *Cspace = 255;
4576 } else {
4577 if (!memcmp(&csm_attrib.param, &g_csm_601fa_def, sizeof(g_csm_601fa_def)) ||
4578 !memcmp(&csm_attrib.param, &g_csm_601fm_def, sizeof(g_csm_601fm_def)))
4579 *Cspace = 0;
4580 else if (!memcmp(&csm_attrib.param, &g_csm_709fa_def, sizeof(g_csm_709fa_def)) ||
4581 !memcmp(&csm_attrib.param, &g_csm_709fm_def, sizeof(g_csm_709fm_def)))
4582 *Cspace = 2;
4583 else
4584 *Cspace = 255;
4585 }
4586
4587 IMGPROC_FUNC_EXIT
4588 return ret;
4589 }
4590 RKAIQ_END_DECLARE
4591