1 /******************************************************************************
2 *
3 * Copyright 2019, Fuzhou Rockchip Electronics Co.Ltd . All rights reserved.
4 * No part of this work may be reproduced, modified, distributed, transmitted,
5 * transcribed, or translated into any language or computer format, in any form
6 * or by any means without written permission of:
7 * Fuzhou Rockchip Electronics Co.Ltd .
8 *
9 *
10 *****************************************************************************/
11
12 #include "uAPI2/rk_aiq_user_api2_ae.h"
13
14 #include "RkAiqCamGroupHandleInt.h"
15 #include "algo_handlers/RkAiqAeHandle.h"
16 #include "base/xcam_common.h"
17
18 RKAIQ_BEGIN_DECLARE
19
20 #ifdef RK_SIMULATOR_HW
21 #define CHECK_USER_API_ENABLE
22 #endif
23
24 #if RKAIQ_HAVE_AE_V1
25
rk_aiq_user_api2_ae_setExpSwAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_ExpSwAttrV2_t expSwAttr)26 XCamReturn rk_aiq_user_api2_ae_setExpSwAttr
27 (
28 const rk_aiq_sys_ctx_t* sys_ctx,
29 const Uapi_ExpSwAttrV2_t expSwAttr
30 ) {
31 XCamReturn ret = XCAM_RETURN_NO_ERROR;
32 CHECK_USER_API_ENABLE2(sys_ctx);
33 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
34 RKAIQ_API_SMART_LOCK(sys_ctx);
35
36 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
37 #ifdef RKAIQ_ENABLE_CAMGROUP
38 RkAiqCamGroupAeHandleInt* algo_handle =
39 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
40
41 if (algo_handle) {
42 return algo_handle->setExpSwAttr(expSwAttr);
43 } else {
44 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
45 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
46 if (!camCtx)
47 continue;
48
49 RkAiqAeHandleInt* singleCam_algo_handle =
50 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
51 if (singleCam_algo_handle)
52 ret = singleCam_algo_handle->setExpSwAttr(expSwAttr);
53 }
54 }
55 #else
56 return XCAM_RETURN_ERROR_FAILED;
57 #endif
58 } else {
59
60 RkAiqAeHandleInt* algo_handle =
61 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
62
63 if (algo_handle) {
64 return algo_handle->setExpSwAttr(expSwAttr);
65 }
66 }
67
68 return (ret);
69
70 }
rk_aiq_user_api2_ae_getExpSwAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_ExpSwAttrV2_t * pExpSwAttr)71 XCamReturn rk_aiq_user_api2_ae_getExpSwAttr
72 (
73 const rk_aiq_sys_ctx_t* sys_ctx,
74 Uapi_ExpSwAttrV2_t* pExpSwAttr
75 ) {
76 RKAIQ_API_SMART_LOCK(sys_ctx);
77 XCamReturn ret = XCAM_RETURN_NO_ERROR;
78
79
80 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
81 #ifdef RKAIQ_ENABLE_CAMGROUP
82 RkAiqCamGroupAeHandleInt* algo_handle =
83 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
84
85 if (algo_handle) {
86 return algo_handle->getExpSwAttr(pExpSwAttr);
87 } else {
88 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
89 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
90 if (!camCtx)
91 continue;
92
93 RkAiqAeHandleInt* singleCam_algo_handle =
94 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
95 if (singleCam_algo_handle)
96 ret = singleCam_algo_handle->getExpSwAttr(pExpSwAttr);
97 }
98 }
99 #else
100 return XCAM_RETURN_ERROR_FAILED;
101 #endif
102 } else {
103
104 RkAiqAeHandleInt* algo_handle =
105 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
106
107 if (algo_handle) {
108 return algo_handle->getExpSwAttr(pExpSwAttr);
109 }
110 }
111
112 return (ret);
113 }
rk_aiq_user_api2_ae_setLinExpAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_LinExpAttrV2_t linExpAttr)114 XCamReturn rk_aiq_user_api2_ae_setLinExpAttr
115 (
116 const rk_aiq_sys_ctx_t* sys_ctx,
117 const Uapi_LinExpAttrV2_t linExpAttr
118 ) {
119 XCamReturn ret = XCAM_RETURN_NO_ERROR;
120 CHECK_USER_API_ENABLE2(sys_ctx);
121 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
122 RKAIQ_API_SMART_LOCK(sys_ctx);
123
124 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
125 #ifdef RKAIQ_ENABLE_CAMGROUP
126 RkAiqCamGroupAeHandleInt* algo_handle =
127 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
128
129 if (algo_handle) {
130 return algo_handle->setLinExpAttr(linExpAttr);
131 } else {
132 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
133 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
134 if (!camCtx)
135 continue;
136
137 RkAiqAeHandleInt* singleCam_algo_handle =
138 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
139 if (singleCam_algo_handle)
140 ret = singleCam_algo_handle->setLinExpAttr(linExpAttr);
141 }
142 }
143 #else
144 return XCAM_RETURN_ERROR_FAILED;
145 #endif
146 } else {
147 RkAiqAeHandleInt* algo_handle =
148 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
149
150 if (algo_handle) {
151 return algo_handle->setLinExpAttr(linExpAttr);
152 }
153 }
154
155 return(ret);
156
157 }
rk_aiq_user_api2_ae_getLinExpAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_LinExpAttrV2_t * pLinExpAttr)158 XCamReturn rk_aiq_user_api2_ae_getLinExpAttr
159 (
160 const rk_aiq_sys_ctx_t* sys_ctx,
161 Uapi_LinExpAttrV2_t* pLinExpAttr
162 ) {
163 RKAIQ_API_SMART_LOCK(sys_ctx);
164 XCamReturn ret = XCAM_RETURN_NO_ERROR;
165
166 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
167 #ifdef RKAIQ_ENABLE_CAMGROUP
168 RkAiqCamGroupAeHandleInt* algo_handle =
169 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
170
171 if (algo_handle) {
172 return algo_handle->getLinExpAttr(pLinExpAttr);
173 } else {
174 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
175 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
176 if (!camCtx)
177 continue;
178
179 RkAiqAeHandleInt* singleCam_algo_handle =
180 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
181 if (singleCam_algo_handle)
182 ret = singleCam_algo_handle->getLinExpAttr(pLinExpAttr);
183 }
184 }
185 #else
186 return XCAM_RETURN_ERROR_FAILED;
187 #endif
188 } else {
189
190 RkAiqAeHandleInt* algo_handle =
191 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
192
193 if (algo_handle) {
194 return algo_handle->getLinExpAttr(pLinExpAttr);
195 }
196 }
197 return(ret);
198
199 }
rk_aiq_user_api2_ae_setHdrExpAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_HdrExpAttrV2_t hdrExpAttr)200 XCamReturn rk_aiq_user_api2_ae_setHdrExpAttr
201 (
202 const rk_aiq_sys_ctx_t* sys_ctx,
203 const Uapi_HdrExpAttrV2_t hdrExpAttr
204 ) {
205 XCamReturn ret = XCAM_RETURN_NO_ERROR;
206 CHECK_USER_API_ENABLE2(sys_ctx);
207 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
208 RKAIQ_API_SMART_LOCK(sys_ctx);
209
210 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
211 #ifdef RKAIQ_ENABLE_CAMGROUP
212 RkAiqCamGroupAeHandleInt* algo_handle =
213 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
214
215 if (algo_handle) {
216 return algo_handle->setHdrExpAttr(hdrExpAttr);
217 } else {
218 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
219 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
220 if (!camCtx)
221 continue;
222
223 RkAiqAeHandleInt* singleCam_algo_handle =
224 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
225 if (singleCam_algo_handle)
226 ret = singleCam_algo_handle->setHdrExpAttr(hdrExpAttr);
227 }
228 }
229 #else
230 return XCAM_RETURN_ERROR_FAILED;
231 #endif
232 } else {
233
234 RkAiqAeHandleInt* algo_handle =
235 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
236
237 if (algo_handle) {
238 return algo_handle->setHdrExpAttr(hdrExpAttr);
239 }
240 }
241 return(ret);
242
243 }
rk_aiq_user_api2_ae_getHdrExpAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_HdrExpAttrV2_t * pHdrExpAttr)244 XCamReturn rk_aiq_user_api2_ae_getHdrExpAttr
245 (
246 const rk_aiq_sys_ctx_t* sys_ctx,
247 Uapi_HdrExpAttrV2_t* pHdrExpAttr
248 ) {
249 RKAIQ_API_SMART_LOCK(sys_ctx);
250 XCamReturn ret = XCAM_RETURN_NO_ERROR;
251
252 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
253 #ifdef RKAIQ_ENABLE_CAMGROUP
254
255 RkAiqCamGroupAeHandleInt* algo_handle =
256 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
257
258 if (algo_handle) {
259 return algo_handle->getHdrExpAttr(pHdrExpAttr);
260 } else {
261 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
262 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
263 if (!camCtx)
264 continue;
265
266 RkAiqAeHandleInt* singleCam_algo_handle =
267 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
268 if (singleCam_algo_handle)
269 ret = singleCam_algo_handle->getHdrExpAttr(pHdrExpAttr);
270 }
271 }
272 #else
273 return XCAM_RETURN_ERROR_FAILED;
274 #endif
275 } else {
276
277 RkAiqAeHandleInt* algo_handle =
278 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
279
280 if (algo_handle) {
281 return algo_handle->getHdrExpAttr(pHdrExpAttr);
282 }
283 }
284 return(ret);
285
286 }
287
rk_aiq_user_api2_ae_setLinAeRouteAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_LinAeRouteAttr_t linAeRouteAttr)288 XCamReturn rk_aiq_user_api2_ae_setLinAeRouteAttr
289 (
290 const rk_aiq_sys_ctx_t* sys_ctx,
291 const Uapi_LinAeRouteAttr_t linAeRouteAttr
292 ) {
293 XCamReturn ret = XCAM_RETURN_NO_ERROR;
294 CHECK_USER_API_ENABLE2(sys_ctx);
295 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
296 RKAIQ_API_SMART_LOCK(sys_ctx);
297
298 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
299 #ifdef RKAIQ_ENABLE_CAMGROUP
300 RkAiqCamGroupAeHandleInt* algo_handle =
301 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
302
303 if (algo_handle) {
304 return algo_handle->setLinAeRouteAttr(linAeRouteAttr);
305 } else {
306 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
307 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
308 if (!camCtx)
309 continue;
310
311 RkAiqAeHandleInt* singleCam_algo_handle =
312 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
313 if (singleCam_algo_handle)
314 ret = singleCam_algo_handle->setLinAeRouteAttr(linAeRouteAttr);
315 }
316 }
317 #else
318 return XCAM_RETURN_ERROR_FAILED;
319 #endif
320 } else {
321
322 RkAiqAeHandleInt* algo_handle =
323 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
324
325 if (algo_handle) {
326 return algo_handle->setLinAeRouteAttr(linAeRouteAttr);
327 }
328 }
329
330 return(ret);
331 }
rk_aiq_user_api2_ae_getLinAeRouteAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_LinAeRouteAttr_t * pLinAeRouteAttr)332 XCamReturn rk_aiq_user_api2_ae_getLinAeRouteAttr
333 (
334 const rk_aiq_sys_ctx_t* sys_ctx,
335 Uapi_LinAeRouteAttr_t* pLinAeRouteAttr
336 ) {
337 RKAIQ_API_SMART_LOCK(sys_ctx);
338 XCamReturn ret = XCAM_RETURN_NO_ERROR;
339 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
340 #ifdef RKAIQ_ENABLE_CAMGROUP
341 RkAiqCamGroupAeHandleInt* algo_handle =
342 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
343
344 if (algo_handle) {
345 return algo_handle->getLinAeRouteAttr(pLinAeRouteAttr);
346 } else {
347 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
348 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
349 if (!camCtx)
350 continue;
351
352 RkAiqAeHandleInt* singleCam_algo_handle =
353 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
354 if (singleCam_algo_handle)
355 ret = singleCam_algo_handle->getLinAeRouteAttr(pLinAeRouteAttr);
356 }
357 }
358 #else
359 return XCAM_RETURN_ERROR_FAILED;
360 #endif
361 } else {
362
363 RkAiqAeHandleInt* algo_handle =
364 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
365
366 if (algo_handle) {
367 return algo_handle->getLinAeRouteAttr(pLinAeRouteAttr);
368 }
369 }
370 return(ret);
371
372 }
rk_aiq_user_api2_ae_setHdrAeRouteAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_HdrAeRouteAttr_t hdrAeRouteAttr)373 XCamReturn rk_aiq_user_api2_ae_setHdrAeRouteAttr
374 (
375 const rk_aiq_sys_ctx_t* sys_ctx,
376 const Uapi_HdrAeRouteAttr_t hdrAeRouteAttr
377 ) {
378 XCamReturn ret = XCAM_RETURN_NO_ERROR;
379 CHECK_USER_API_ENABLE2(sys_ctx);
380 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
381 RKAIQ_API_SMART_LOCK(sys_ctx);
382
383 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
384 #ifdef RKAIQ_ENABLE_CAMGROUP
385 RkAiqCamGroupAeHandleInt* algo_handle =
386 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
387
388 if (algo_handle) {
389 return algo_handle->setHdrAeRouteAttr(hdrAeRouteAttr);
390 } else {
391 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
392 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
393 if (!camCtx)
394 continue;
395
396 RkAiqAeHandleInt* singleCam_algo_handle =
397 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
398 if (singleCam_algo_handle)
399 ret = singleCam_algo_handle->setHdrAeRouteAttr(hdrAeRouteAttr);
400 }
401 }
402 #else
403 return XCAM_RETURN_ERROR_FAILED;
404 #endif
405 } else {
406 RkAiqAeHandleInt* algo_handle =
407 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
408
409 if (algo_handle) {
410 return algo_handle->setHdrAeRouteAttr(hdrAeRouteAttr);
411 }
412 }
413 return(ret);
414
415 }
rk_aiq_user_api2_ae_getHdrAeRouteAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_HdrAeRouteAttr_t * pHdrAeRouteAttr)416 XCamReturn rk_aiq_user_api2_ae_getHdrAeRouteAttr
417 (
418 const rk_aiq_sys_ctx_t* sys_ctx,
419 Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr
420 ) {
421 RKAIQ_API_SMART_LOCK(sys_ctx);
422 XCamReturn ret = XCAM_RETURN_NO_ERROR;
423
424 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
425 #ifdef RKAIQ_ENABLE_CAMGROUP
426 RkAiqCamGroupAeHandleInt* algo_handle =
427 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
428
429 if (algo_handle) {
430 return algo_handle->getHdrAeRouteAttr(pHdrAeRouteAttr);
431 } else {
432 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
433 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
434 if (!camCtx)
435 continue;
436
437 RkAiqAeHandleInt* singleCam_algo_handle =
438 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
439 if (singleCam_algo_handle)
440 ret = singleCam_algo_handle->getHdrAeRouteAttr(pHdrAeRouteAttr);
441 }
442 }
443 #else
444 return XCAM_RETURN_ERROR_FAILED;
445 #endif
446 } else {
447 RkAiqAeHandleInt* algo_handle =
448 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
449
450 if (algo_handle) {
451 return algo_handle->getHdrAeRouteAttr(pHdrAeRouteAttr);
452 }
453 }
454 return(ret);
455
456 }
rk_aiq_user_api2_ae_setIrisAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_IrisAttrV2_t irisAttr)457 XCamReturn rk_aiq_user_api2_ae_setIrisAttr
458 (
459 const rk_aiq_sys_ctx_t * sys_ctx,
460 const Uapi_IrisAttrV2_t irisAttr
461 )
462 {
463 XCamReturn ret = XCAM_RETURN_NO_ERROR;
464 CHECK_USER_API_ENABLE2(sys_ctx);
465 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
466 RKAIQ_API_SMART_LOCK(sys_ctx);
467
468 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
469 #ifdef RKAIQ_ENABLE_CAMGROUP
470 LOGW("%s: not support camgroup mode!", __FUNCTION__);
471 return(ret);
472 #else
473 return XCAM_RETURN_ERROR_FAILED;
474 #endif
475
476 } else {
477
478 RkAiqAeHandleInt* algo_handle =
479 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
480
481 if (algo_handle) {
482 return algo_handle->setIrisAttr(irisAttr);
483 }
484 }
485
486 return(ret);
487
488 }
rk_aiq_user_api2_ae_getIrisAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_IrisAttrV2_t * pIrisAttr)489 XCamReturn rk_aiq_user_api2_ae_getIrisAttr
490 (
491 const rk_aiq_sys_ctx_t * sys_ctx,
492 Uapi_IrisAttrV2_t * pIrisAttr
493 ) {
494 RKAIQ_API_SMART_LOCK(sys_ctx);
495 XCamReturn ret = XCAM_RETURN_NO_ERROR;
496
497 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
498 #ifdef RKAIQ_ENABLE_CAMGROUP
499 LOGW("%s: not support camgroup mode!", __FUNCTION__);
500 return(ret);
501 #else
502 return XCAM_RETURN_ERROR_FAILED;
503 #endif
504
505 } else {
506
507 RkAiqAeHandleInt* algo_handle =
508 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
509
510 if (algo_handle) {
511 return algo_handle->getIrisAttr(pIrisAttr);
512 }
513 }
514 return(ret);
515
516 }
rk_aiq_user_api2_ae_setSyncTestAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_AecSyncTest_t syncTestAttr)517 XCamReturn rk_aiq_user_api2_ae_setSyncTestAttr
518 (
519 const rk_aiq_sys_ctx_t * sys_ctx,
520 const Uapi_AecSyncTest_t syncTestAttr
521 ) {
522 XCamReturn ret = XCAM_RETURN_NO_ERROR;
523 CHECK_USER_API_ENABLE2(sys_ctx);
524 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
525 RKAIQ_API_SMART_LOCK(sys_ctx);
526
527 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
528 #ifdef RKAIQ_ENABLE_CAMGROUP
529 RkAiqCamGroupAeHandleInt* algo_handle =
530 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
531
532 if (algo_handle) {
533 return algo_handle->setSyncTestAttr(syncTestAttr);
534 } else {
535 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
536 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
537 if (!camCtx)
538 continue;
539
540 RkAiqAeHandleInt* singleCam_algo_handle =
541 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
542 if (singleCam_algo_handle)
543 ret = singleCam_algo_handle->setSyncTestAttr(syncTestAttr);
544 }
545 }
546 #else
547 return XCAM_RETURN_ERROR_FAILED;
548 #endif
549 } else {
550 RkAiqAeHandleInt* algo_handle =
551 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
552
553 if (algo_handle) {
554 return algo_handle->setSyncTestAttr(syncTestAttr);
555 }
556 }
557 return(ret);
558
559 }
560
rk_aiq_user_api2_ae_getSyncTestAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_AecSyncTest_t * psyncTestAttr)561 XCamReturn rk_aiq_user_api2_ae_getSyncTestAttr
562 (
563 const rk_aiq_sys_ctx_t * sys_ctx,
564 Uapi_AecSyncTest_t * psyncTestAttr
565 ) {
566 RKAIQ_API_SMART_LOCK(sys_ctx);
567 XCamReturn ret = XCAM_RETURN_NO_ERROR;
568
569 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
570 #ifdef RKAIQ_ENABLE_CAMGROUP
571 RkAiqCamGroupAeHandleInt* algo_handle =
572 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
573
574 if (algo_handle) {
575 return algo_handle->getSyncTestAttr(psyncTestAttr);
576 } else {
577 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
578 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
579 if (!camCtx)
580 continue;
581
582 RkAiqAeHandleInt* singleCam_algo_handle =
583 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
584 if (singleCam_algo_handle)
585 ret = singleCam_algo_handle->getSyncTestAttr(psyncTestAttr);
586 }
587 }
588 #else
589 return XCAM_RETURN_ERROR_FAILED;
590 #endif
591 } else {
592 RkAiqAeHandleInt* algo_handle =
593 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
594
595 if (algo_handle) {
596 return algo_handle->getSyncTestAttr(psyncTestAttr);
597 }
598 }
599
600 return(ret);
601
602 }
rk_aiq_user_api2_ae_queryExpResInfo(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_ExpQueryInfo_t * pExpResInfo)603 XCamReturn rk_aiq_user_api2_ae_queryExpResInfo
604 (
605 const rk_aiq_sys_ctx_t* sys_ctx,
606 Uapi_ExpQueryInfo_t* pExpResInfo
607 ) {
608 RKAIQ_API_SMART_LOCK(sys_ctx);
609 XCamReturn ret = XCAM_RETURN_NO_ERROR;
610
611 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
612 #ifdef RKAIQ_ENABLE_CAMGROUP
613 RkAiqCamGroupAeHandleInt* algo_handle =
614 camgroupAlgoHandle<RkAiqCamGroupAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
615
616 if (algo_handle) {
617 return algo_handle->queryExpInfo(pExpResInfo);
618 } else {
619 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
620 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
621 if (!camCtx)
622 continue;
623
624 RkAiqAeHandleInt* singleCam_algo_handle =
625 algoHandle<RkAiqAeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AE);
626 if (singleCam_algo_handle)
627 ret = singleCam_algo_handle->queryExpInfo(pExpResInfo);
628 }
629 }
630 #else
631 return XCAM_RETURN_ERROR_FAILED;
632 #endif
633
634 } else {
635 RkAiqAeHandleInt* algo_handle =
636 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
637
638 if (algo_handle) {
639 return algo_handle->queryExpInfo(pExpResInfo);
640 }
641 }
642 return(ret);
643
644 }
645
rk_aiq_user_api2_ae_setExpWinAttr(const rk_aiq_sys_ctx_t * sys_ctx,const Uapi_ExpWin_t ExpWin)646 XCamReturn rk_aiq_user_api2_ae_setExpWinAttr
647 (
648 const rk_aiq_sys_ctx_t* sys_ctx,
649 const Uapi_ExpWin_t ExpWin
650 ) {
651 XCamReturn ret = XCAM_RETURN_NO_ERROR;
652 CHECK_USER_API_ENABLE2(sys_ctx);
653 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AE);
654 RKAIQ_API_SMART_LOCK(sys_ctx);
655
656 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
657 #ifdef RKAIQ_ENABLE_CAMGROUP
658 LOGW("%s: not support camgroup mode!", __FUNCTION__);
659 return(ret);
660 #else
661 return XCAM_RETURN_ERROR_FAILED;
662 #endif
663
664 } else {
665
666 RkAiqAeHandleInt* algo_handle =
667 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
668
669 if (algo_handle) {
670 return algo_handle->setExpWinAttr(ExpWin);
671 }
672 }
673
674 return(ret);
675
676 }
rk_aiq_user_api2_ae_getExpWinAttr(const rk_aiq_sys_ctx_t * sys_ctx,Uapi_ExpWin_t * pExpWin)677 XCamReturn rk_aiq_user_api2_ae_getExpWinAttr
678 (
679 const rk_aiq_sys_ctx_t* sys_ctx,
680 Uapi_ExpWin_t* pExpWin
681 ) {
682 RKAIQ_API_SMART_LOCK(sys_ctx);
683 XCamReturn ret = XCAM_RETURN_NO_ERROR;
684
685 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
686 #ifdef RKAIQ_ENABLE_CAMGROUP
687 LOGW("%s: not support camgroup mode!", __FUNCTION__);
688 return(ret);
689 #else
690 return XCAM_RETURN_ERROR_FAILED;
691 #endif
692 } else {
693
694 RkAiqAeHandleInt* algo_handle =
695 algoHandle<RkAiqAeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AE);
696
697 if (algo_handle) {
698 return algo_handle->getExpWinAttr(pExpWin);
699 }
700 }
701
702 return(ret);
703
704 }
705
706 #else
707
708 XCamReturn rk_aiq_user_api2_ae_setExpSwAttr
709 (
710 const rk_aiq_sys_ctx_t* sys_ctx,
711 const Uapi_ExpSwAttrV2_t expSwAttr
712 ) {
713 return XCAM_RETURN_ERROR_UNKNOWN;
714 }
715 XCamReturn rk_aiq_user_api2_ae_getExpSwAttr
716 (
717 const rk_aiq_sys_ctx_t* sys_ctx,
718 Uapi_ExpSwAttrV2_t* pExpSwAttr
719 ) {
720 return XCAM_RETURN_ERROR_UNKNOWN;
721 }
722 XCamReturn rk_aiq_user_api2_ae_setLinExpAttr
723 (
724 const rk_aiq_sys_ctx_t* sys_ctx,
725 const Uapi_LinExpAttrV2_t linExpAttr
726 ) {
727 return XCAM_RETURN_ERROR_UNKNOWN;
728 }
729 XCamReturn rk_aiq_user_api2_ae_getLinExpAttr
730 (
731 const rk_aiq_sys_ctx_t* sys_ctx,
732 Uapi_LinExpAttrV2_t* pLinExpAttr
733 ) {
734 return XCAM_RETURN_ERROR_UNKNOWN;
735 }
736 XCamReturn rk_aiq_user_api2_ae_setHdrExpAttr
737 (
738 const rk_aiq_sys_ctx_t* sys_ctx,
739 const Uapi_HdrExpAttrV2_t hdrExpAttr
740 ) {
741 return XCAM_RETURN_ERROR_UNKNOWN;
742 }
743 XCamReturn rk_aiq_user_api2_ae_getHdrExpAttr
744 (
745 const rk_aiq_sys_ctx_t* sys_ctx,
746 Uapi_HdrExpAttrV2_t* pHdrExpAttr
747 ) {
748 return XCAM_RETURN_ERROR_UNKNOWN;
749 }
750
751 XCamReturn rk_aiq_user_api2_ae_setLinAeRouteAttr
752 (
753 const rk_aiq_sys_ctx_t* sys_ctx,
754 const Uapi_LinAeRouteAttr_t linAeRouteAttr
755 ) {
756 return XCAM_RETURN_ERROR_UNKNOWN;
757 }
758 XCamReturn rk_aiq_user_api2_ae_getLinAeRouteAttr
759 (
760 const rk_aiq_sys_ctx_t* sys_ctx,
761 Uapi_LinAeRouteAttr_t* pLinAeRouteAttr
762 ) {
763 return XCAM_RETURN_ERROR_UNKNOWN;
764 }
765 XCamReturn rk_aiq_user_api2_ae_setHdrAeRouteAttr
766 (
767 const rk_aiq_sys_ctx_t* sys_ctx,
768 const Uapi_HdrAeRouteAttr_t hdrAeRouteAttr
769 ) {
770 return XCAM_RETURN_ERROR_UNKNOWN;
771 }
772 XCamReturn rk_aiq_user_api2_ae_getHdrAeRouteAttr
773 (
774 const rk_aiq_sys_ctx_t* sys_ctx,
775 Uapi_HdrAeRouteAttr_t* pHdrAeRouteAttr
776 ) {
777 return XCAM_RETURN_ERROR_UNKNOWN;
778 }
779 XCamReturn rk_aiq_user_api2_ae_setIrisAttr
780 (
781 const rk_aiq_sys_ctx_t * sys_ctx,
782 const Uapi_IrisAttrV2_t irisAttr
783 )
784 {
785 return XCAM_RETURN_ERROR_UNKNOWN;
786 }
787 XCamReturn rk_aiq_user_api2_ae_getIrisAttr
788 (
789 const rk_aiq_sys_ctx_t * sys_ctx,
790 Uapi_IrisAttrV2_t * pIrisAttr
791 ) {
792 return XCAM_RETURN_ERROR_UNKNOWN;
793 }
794 XCamReturn rk_aiq_user_api2_ae_setSyncTestAttr
795 (
796 const rk_aiq_sys_ctx_t * sys_ctx,
797 const Uapi_AecSyncTest_t syncTestAttr
798 ) {
799 return XCAM_RETURN_ERROR_UNKNOWN;
800 }
801
802 XCamReturn rk_aiq_user_api2_ae_getSyncTestAttr
803 (
804 const rk_aiq_sys_ctx_t * sys_ctx,
805 Uapi_AecSyncTest_t * psyncTestAttr
806 ) {
807 return XCAM_RETURN_ERROR_UNKNOWN;
808 }
809 XCamReturn rk_aiq_user_api2_ae_queryExpResInfo
810 (
811 const rk_aiq_sys_ctx_t* sys_ctx,
812 Uapi_ExpQueryInfo_t* pExpResInfo
813 ) {
814 return XCAM_RETURN_ERROR_UNKNOWN;
815 }
816 XCamReturn rk_aiq_user_api2_ae_setExpWinAttr
817 (
818 const rk_aiq_sys_ctx_t* sys_ctx,
819 const Uapi_ExpWin_t ExpWin
820 ) {
821 return XCAM_RETURN_ERROR_UNKNOWN;
822 }
823 XCamReturn rk_aiq_user_api2_ae_getExpWinAttr
824 (
825 const rk_aiq_sys_ctx_t* sys_ctx,
826 Uapi_ExpWin_t* pExpWin
827 ) {
828 return XCAM_RETURN_ERROR_UNKNOWN;
829 }
830
831 #endif
832
833 RKAIQ_END_DECLARE
834
835