1 /*
2 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "uAPI2/rk_aiq_user_api2_awb.h"
17
18 #include "RkAiqCamGroupHandleInt.h"
19 #include "algo_handlers/RkAiqAwbV21Handle.h"
20 //#include "rk_aiq_user_api2_sysctl.h"
21
22 RKAIQ_BEGIN_DECLARE
23
24 #ifdef RK_SIMULATOR_HW
25 #define CHECK_USER_API_ENABLE
26 #endif
27
28
29 XCamReturn
rk_aiq_user_api2_awbV21_SetAllAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV21_attrib_t attr)30 rk_aiq_user_api2_awbV21_SetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV21_attrib_t attr)
31 {
32 #if RKAIQ_HAVE_AWB_V21
33 CHECK_USER_API_ENABLE2(sys_ctx);
34 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
35 RKAIQ_API_SMART_LOCK(sys_ctx);
36
37 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
38 #ifdef RKAIQ_ENABLE_CAMGROUP
39 RkAiqCamGroupAwbHandleInt* algo_handle =
40 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
41
42 if (algo_handle) {
43 return algo_handle->setWbV21Attrib(attr);
44 } else {
45 XCamReturn ret = XCAM_RETURN_NO_ERROR;
46 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
47 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
48 if (!camCtx)
49 continue;
50
51 RkAiqAwbV21HandleInt* singleCam_algo_handle =
52 algoHandle<RkAiqAwbV21HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
53 if (singleCam_algo_handle) {
54 ret = singleCam_algo_handle->setWbV21Attrib(attr);
55 if (ret != XCAM_RETURN_NO_ERROR) LOGE("%s returned: %d", __FUNCTION__, ret);
56 }
57 }
58 return ret;
59 }
60 #else
61 return XCAM_RETURN_ERROR_FAILED;
62 #endif
63 } else {
64 RkAiqAwbV21HandleInt* algo_handle =
65 algoHandle<RkAiqAwbV21HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
66
67 if (algo_handle) {
68 return algo_handle->setWbV21Attrib(attr);
69 }
70 }
71
72 return XCAM_RETURN_NO_ERROR;
73 #else
74 return XCAM_RETURN_ERROR_UNKNOWN;
75 #endif
76 }
77
78 XCamReturn
rk_aiq_user_api2_awbV21_GetAllAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV21_attrib_t * attr)79 rk_aiq_user_api2_awbV21_GetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV21_attrib_t *attr)
80 {
81
82 #if RKAIQ_HAVE_AWB_V21
83
84 RKAIQ_API_SMART_LOCK(sys_ctx);
85
86 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
87 #ifdef RKAIQ_ENABLE_CAMGROUP
88 RkAiqCamGroupAwbHandleInt* algo_handle =
89 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
90
91 if (algo_handle) {
92 return algo_handle->getWbV21Attrib(attr);
93 } else {
94 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
95 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
96 if (!camCtx)
97 continue;
98
99 RkAiqAwbV21HandleInt* singleCam_algo_handle =
100 algoHandle<RkAiqAwbV21HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
101 if (singleCam_algo_handle)
102 return singleCam_algo_handle->getWbV21Attrib(attr);
103 }
104 }
105 #else
106 return XCAM_RETURN_ERROR_FAILED;
107 #endif
108 } else {
109 RkAiqAwbV21HandleInt* algo_handle =
110 algoHandle<RkAiqAwbV21HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
111
112 if (algo_handle) {
113 return algo_handle->getWbV21Attrib(attr);
114 }
115 }
116 return XCAM_RETURN_NO_ERROR;
117 #else
118 return XCAM_RETURN_ERROR_UNKNOWN;
119 #endif
120 }
121
122 XCamReturn
rk_aiq_user_api2_awbV30_SetAllAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV30_attrib_t attr)123 rk_aiq_user_api2_awbV30_SetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV30_attrib_t attr)
124 {
125
126 #if RKAIQ_HAVE_AWB_V21
127
128 CHECK_USER_API_ENABLE2(sys_ctx);
129 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
130 RKAIQ_API_SMART_LOCK(sys_ctx);
131 XCamReturn ret = XCAM_RETURN_NO_ERROR;
132 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
133 #ifdef RKAIQ_ENABLE_CAMGROUP
134 RkAiqCamGroupAwbHandleInt* algo_handle =
135 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
136
137 if (algo_handle) {
138 return algo_handle->setWbV21Attrib((rk_aiq_uapiV2_wbV21_attrib_t&)attr);
139 } else {
140 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
141 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
142 if (!camCtx)
143 continue;
144
145 RkAiqAwbV21HandleInt* singleCam_algo_handle =
146 algoHandle<RkAiqAwbV21HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
147 if (singleCam_algo_handle)
148 ret = singleCam_algo_handle->setWbV21Attrib((rk_aiq_uapiV2_wbV21_attrib_t&)attr);
149 }
150 }
151 #else
152 return XCAM_RETURN_ERROR_FAILED;
153 #endif
154 } else {
155 RkAiqAwbV21HandleInt* algo_handle =
156 algoHandle<RkAiqAwbV21HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
157
158 if (algo_handle) {
159 return algo_handle->setWbV21Attrib((rk_aiq_uapiV2_wbV21_attrib_t&)attr);
160 }
161 }
162
163 return ret;
164 #else
165 return XCAM_RETURN_ERROR_UNKNOWN;
166 #endif
167 }
168
169 XCamReturn
rk_aiq_user_api2_awbV30_GetAllAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV30_attrib_t * attr)170 rk_aiq_user_api2_awbV30_GetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV30_attrib_t *attr)
171 {
172
173 #if RKAIQ_HAVE_AWB_V21
174
175 RKAIQ_API_SMART_LOCK(sys_ctx);
176
177 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
178 #ifdef RKAIQ_ENABLE_CAMGROUP
179 RkAiqCamGroupAwbHandleInt* algo_handle =
180 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
181
182 if (algo_handle) {
183 return algo_handle->getWbV21Attrib((rk_aiq_uapiV2_wbV21_attrib_t*)attr);
184 } else {
185 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
186 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
187 if (!camCtx)
188 continue;
189
190 RkAiqAwbV21HandleInt* singleCam_algo_handle =
191 algoHandle<RkAiqAwbV21HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
192 if (singleCam_algo_handle)
193 return singleCam_algo_handle->getWbV21Attrib((rk_aiq_uapiV2_wbV21_attrib_t*)attr);
194 }
195 }
196 #else
197 return XCAM_RETURN_ERROR_FAILED;
198 #endif
199 } else {
200 RkAiqAwbV21HandleInt* algo_handle =
201 algoHandle<RkAiqAwbV21HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
202
203 if (algo_handle) {
204 return algo_handle->getWbV21Attrib((rk_aiq_uapiV2_wbV21_attrib_t*)attr);
205 }
206 }
207 return XCAM_RETURN_NO_ERROR;
208 #else
209 return XCAM_RETURN_ERROR_UNKNOWN;
210 #endif
211 }
212
213 XCamReturn
rk_aiq_user_api2_awbV32_SetAllAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV32_attrib_t attr)214 rk_aiq_user_api2_awbV32_SetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV32_attrib_t attr)
215 {
216
217 #if RKAIQ_HAVE_AWB_V32
218
219 CHECK_USER_API_ENABLE2(sys_ctx);
220 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
221 RKAIQ_API_SMART_LOCK(sys_ctx);
222 RkAiqAwbV32HandleInt* algo_handle =
223 algoHandle<RkAiqAwbV32HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
224
225 if (algo_handle) {
226 return algo_handle->setWbV32Attrib((rk_aiq_uapiV2_wbV32_attrib_t&)attr);
227 }
228
229 return XCAM_RETURN_NO_ERROR;
230 #else
231 return XCAM_RETURN_ERROR_UNKNOWN;
232 #endif
233 }
234
235 XCamReturn
rk_aiq_user_api2_awbV32_GetAllAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV32_attrib_t * attr)236 rk_aiq_user_api2_awbV32_GetAllAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV32_attrib_t *attr)
237 {
238
239 #if RKAIQ_HAVE_AWB_V32
240
241 RKAIQ_API_SMART_LOCK(sys_ctx);
242 RkAiqAwbV32HandleInt* algo_handle =
243 algoHandle<RkAiqAwbV32HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
244
245 if (algo_handle) {
246 return algo_handle->getWbV32Attrib((rk_aiq_uapiV2_wbV32_attrib_t*)attr);
247 }
248 return XCAM_RETURN_NO_ERROR;
249 #else
250 return XCAM_RETURN_ERROR_UNKNOWN;
251 #endif
252 }
253
254 XCamReturn
rk_aiq_user_api2_awb_GetCCT(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_wb_cct_t * cct)255 rk_aiq_user_api2_awb_GetCCT(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_wb_cct_t *cct)
256 {
257 RKAIQ_API_SMART_LOCK(sys_ctx);
258
259 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
260 #if 0
261 RkAiqCamGroupAwbHandleInt* algo_handle =
262 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
263
264 if (algo_handle) {
265 return algo_handle->getCct(cct);
266 } else {
267 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
268 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
269 if (!camCtx)
270 continue;
271
272 RkAiqAwbHandleInt* singleCam_algo_handle =
273 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
274 if (singleCam_algo_handle)
275 return singleCam_algo_handle->getCct(cct);
276 }
277 }
278 #else
279 return XCAM_RETURN_ERROR_FAILED;
280 #endif
281 } else {
282 RkAiqAwbHandleInt* algo_handle =
283 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
284
285 if (algo_handle) {
286 return algo_handle->getCct(cct);
287 }
288 }
289 return XCAM_RETURN_NO_ERROR;
290 }
291
292 XCamReturn
rk_aiq_user_api2_awb_QueryWBInfo(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_wb_querry_info_t * wb_querry_info)293 rk_aiq_user_api2_awb_QueryWBInfo(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_wb_querry_info_t *wb_querry_info)
294 {
295 RKAIQ_API_SMART_LOCK(sys_ctx);
296
297 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
298 #ifdef RKAIQ_ENABLE_CAMGROUP
299 RkAiqCamGroupAwbHandleInt* algo_handle =
300 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
301
302 if (algo_handle) {
303 return algo_handle->queryWBInfo(wb_querry_info);
304 } else {
305 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
306 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
307 if (!camCtx)
308 continue;
309
310 RkAiqAwbHandleInt* singleCam_algo_handle =
311 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
312 if (singleCam_algo_handle)
313 return singleCam_algo_handle->queryWBInfo(wb_querry_info);
314 }
315 }
316 #else
317 return XCAM_RETURN_ERROR_FAILED;
318 #endif
319 } else {
320 RkAiqAwbHandleInt* algo_handle =
321 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
322
323 if (algo_handle) {
324 return algo_handle->queryWBInfo(wb_querry_info);
325 }
326 }
327 return XCAM_RETURN_NO_ERROR;
328 }
329
330 XCamReturn
rk_aiq_user_api2_awb_Lock(const rk_aiq_sys_ctx_t * sys_ctx)331 rk_aiq_user_api2_awb_Lock(const rk_aiq_sys_ctx_t* sys_ctx)
332 {
333 RKAIQ_API_SMART_LOCK(sys_ctx);
334 XCamReturn ret = XCAM_RETURN_NO_ERROR;
335
336 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
337 #ifdef RKAIQ_ENABLE_CAMGROUP
338 RkAiqCamGroupAwbHandleInt* algo_handle =
339 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
340
341 if (algo_handle) {
342 return algo_handle->lock();
343 } else {
344 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
345 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
346 if (!camCtx)
347 continue;
348
349 RkAiqAwbHandleInt* singleCam_algo_handle =
350 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
351 if (singleCam_algo_handle)
352 ret = singleCam_algo_handle->lock();
353 }
354 }
355 #else
356 return XCAM_RETURN_ERROR_FAILED;
357 #endif
358 } else {
359 RkAiqAwbHandleInt* algo_handle =
360 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
361
362 if (algo_handle) {
363 return algo_handle->lock();
364 }
365 }
366 return ret;
367 }
368
369 XCamReturn
rk_aiq_user_api2_awb_Unlock(const rk_aiq_sys_ctx_t * sys_ctx)370 rk_aiq_user_api2_awb_Unlock(const rk_aiq_sys_ctx_t* sys_ctx)
371 {
372 RKAIQ_API_SMART_LOCK(sys_ctx);
373 XCamReturn ret = XCAM_RETURN_NO_ERROR;
374
375 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
376 #ifdef RKAIQ_ENABLE_CAMGROUP
377 RkAiqCamGroupAwbHandleInt* algo_handle =
378 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
379
380 if (algo_handle) {
381 return algo_handle->unlock();
382 } else {
383 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
384 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
385 if (!camCtx)
386 continue;
387
388 RkAiqAwbHandleInt* singleCam_algo_handle =
389 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
390 if (singleCam_algo_handle)
391 ret = singleCam_algo_handle->unlock();
392 }
393 }
394 #else
395 return XCAM_RETURN_ERROR_FAILED;
396 #endif
397 } else {
398 RkAiqAwbHandleInt* algo_handle =
399 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
400
401 if (algo_handle) {
402 return algo_handle->unlock();
403 }
404 }
405 return ret;
406 }
407
408 XCamReturn
rk_aiq_user_api2_awb_SetWpModeAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_opMode_t attr)409 rk_aiq_user_api2_awb_SetWpModeAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_opMode_t attr)
410 {
411 CHECK_USER_API_ENABLE2(sys_ctx);
412 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
413 RKAIQ_API_SMART_LOCK(sys_ctx);
414 XCamReturn ret = XCAM_RETURN_NO_ERROR;
415
416 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
417 #ifdef RKAIQ_ENABLE_CAMGROUP
418 RkAiqCamGroupAwbHandleInt* algo_handle =
419 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
420
421 if (algo_handle) {
422 return algo_handle->setWbOpModeAttrib(attr);
423 } else {
424 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
425 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
426 if (!camCtx)
427 continue;
428
429 RkAiqAwbHandleInt* singleCam_algo_handle =
430 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
431 if (singleCam_algo_handle)
432 ret = singleCam_algo_handle->setWbOpModeAttrib(attr);
433 }
434 }
435 #else
436 return XCAM_RETURN_ERROR_FAILED;
437 #endif
438 } else {
439 RkAiqAwbHandleInt* algo_handle =
440 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
441
442 if (algo_handle) {
443 return algo_handle->setWbOpModeAttrib(attr);
444 }
445 }
446 return ret;
447 }
448
449 XCamReturn
rk_aiq_user_api2_awb_GetWpModeAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_opMode_t * attr)450 rk_aiq_user_api2_awb_GetWpModeAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_opMode_t *attr)
451 {
452 RKAIQ_API_SMART_LOCK(sys_ctx);
453
454 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
455 #ifdef RKAIQ_ENABLE_CAMGROUP
456 RkAiqCamGroupAwbHandleInt* algo_handle =
457 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
458
459 if (algo_handle) {
460 return algo_handle->getWbOpModeAttrib(attr);
461 } else {
462 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
463 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
464 if (!camCtx)
465 continue;
466
467 RkAiqAwbHandleInt* singleCam_algo_handle =
468 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
469 if (singleCam_algo_handle)
470 return singleCam_algo_handle->getWbOpModeAttrib(attr);
471 }
472 }
473 #else
474 return XCAM_RETURN_ERROR_FAILED;
475 #endif
476 } else {
477 RkAiqAwbHandleInt* algo_handle =
478 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
479
480 if (algo_handle) {
481 return algo_handle->getWbOpModeAttrib(attr);
482 }
483 }
484 return XCAM_RETURN_NO_ERROR;
485 }
486
487 XCamReturn
rk_aiq_user_api2_awb_SetMwbAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_wb_mwb_attrib_t attr)488 rk_aiq_user_api2_awb_SetMwbAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_wb_mwb_attrib_t attr)
489 {
490 CHECK_USER_API_ENABLE2(sys_ctx);
491 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
492 RKAIQ_API_SMART_LOCK(sys_ctx);
493 XCamReturn ret = XCAM_RETURN_NO_ERROR;
494
495 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
496 #ifdef RKAIQ_ENABLE_CAMGROUP
497 RkAiqCamGroupAwbHandleInt* algo_handle =
498 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
499
500 if (algo_handle) {
501 return algo_handle->setMwbAttrib(attr);
502 } else {
503 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
504 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
505 if (!camCtx)
506 continue;
507
508 RkAiqAwbHandleInt* singleCam_algo_handle =
509 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
510 if (singleCam_algo_handle)
511 ret = singleCam_algo_handle->setMwbAttrib(attr);
512 }
513 }
514 #else
515 return XCAM_RETURN_ERROR_FAILED;
516 #endif
517 } else {
518 RkAiqAwbHandleInt* algo_handle =
519 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
520
521 if (algo_handle) {
522 return algo_handle->setMwbAttrib(attr);
523 }
524 }
525 return ret;
526 }
527
528 XCamReturn
rk_aiq_user_api2_awb_GetMwbAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_wb_mwb_attrib_t * attr)529 rk_aiq_user_api2_awb_GetMwbAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_wb_mwb_attrib_t *attr)
530 {
531 RKAIQ_API_SMART_LOCK(sys_ctx);
532 XCamReturn ret = XCAM_RETURN_NO_ERROR;
533
534 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
535 #ifdef RKAIQ_ENABLE_CAMGROUP
536 RkAiqCamGroupAwbHandleInt* algo_handle =
537 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
538
539 if (algo_handle) {
540 return algo_handle->getMwbAttrib(attr);
541 } else {
542 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
543 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
544 if (!camCtx)
545 continue;
546
547 RkAiqAwbHandleInt* singleCam_algo_handle =
548 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
549 if (singleCam_algo_handle)
550 ret = singleCam_algo_handle->getMwbAttrib(attr);
551 }
552 }
553 #else
554 return XCAM_RETURN_ERROR_FAILED;
555 #endif
556 } else {
557 RkAiqAwbHandleInt* algo_handle =
558 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
559
560 if (algo_handle) {
561 return algo_handle->getMwbAttrib(attr);
562 }
563 }
564 return ret;
565 }
566
567
568
569 XCamReturn
rk_aiq_user_api2_awb_SetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr)570 rk_aiq_user_api2_awb_SetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_awb_wbGainAdjust_t attr)
571 {
572 CHECK_USER_API_ENABLE2(sys_ctx);
573 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
574 RKAIQ_API_SMART_LOCK(sys_ctx);
575 XCamReturn ret = XCAM_RETURN_NO_ERROR;
576
577 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
578 #ifdef RKAIQ_ENABLE_CAMGROUP
579 RkAiqCamGroupAwbHandleInt* algo_handle =
580 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
581
582 if (algo_handle) {
583 return algo_handle->setWbAwbWbGainAdjustAttrib(attr);
584 } else {
585 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
586 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
587 if (!camCtx)
588 continue;
589
590 RkAiqAwbHandleInt* singleCam_algo_handle =
591 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
592 if (singleCam_algo_handle)
593 ret = singleCam_algo_handle->setWbAwbWbGainAdjustAttrib(attr);
594 }
595 }
596 #else
597 return XCAM_RETURN_ERROR_FAILED;
598 #endif
599 } else {
600 RkAiqAwbHandleInt* algo_handle =
601 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
602
603 if (algo_handle) {
604 return algo_handle->setWbAwbWbGainAdjustAttrib(attr);
605 }
606 }
607 return ret;
608 }
609
610 XCamReturn
rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_awb_wbGainAdjust_t * attr)611 rk_aiq_user_api2_awb_GetWbGainAdjustAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_awb_wbGainAdjust_t *attr)
612 {
613 RKAIQ_API_SMART_LOCK(sys_ctx);
614
615 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
616 #ifdef RKAIQ_ENABLE_CAMGROUP
617 RkAiqCamGroupAwbHandleInt* algo_handle =
618 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
619
620 if (algo_handle) {
621 return algo_handle->getWbAwbWbGainAdjustAttrib(attr);
622 } else {
623 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
624 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
625 if (!camCtx)
626 continue;
627
628 RkAiqAwbHandleInt* singleCam_algo_handle =
629 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
630 if (singleCam_algo_handle)
631 return singleCam_algo_handle->getWbAwbWbGainAdjustAttrib(attr);
632 }
633 }
634 #else
635 return XCAM_RETURN_ERROR_FAILED;
636 #endif
637 } else {
638 RkAiqAwbHandleInt* algo_handle =
639 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
640
641 if (algo_handle) {
642 return algo_handle->getWbAwbWbGainAdjustAttrib(attr);
643 }
644 }
645 return XCAM_RETURN_NO_ERROR;
646 }
647
648 XCamReturn
rk_aiq_user_api2_awb_SetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr)649 rk_aiq_user_api2_awb_SetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_awb_wbGainOffset_t attr)
650 {
651 CHECK_USER_API_ENABLE2(sys_ctx);
652 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
653 RKAIQ_API_SMART_LOCK(sys_ctx);
654 XCamReturn ret = XCAM_RETURN_NO_ERROR;
655
656 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
657 #ifdef RKAIQ_ENABLE_CAMGROUP
658 RkAiqCamGroupAwbHandleInt* algo_handle =
659 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
660
661 if (algo_handle) {
662 return algo_handle->setWbAwbWbGainOffsetAttrib(attr);
663 } else {
664 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
665 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
666 if (!camCtx)
667 continue;
668
669 RkAiqAwbHandleInt* singleCam_algo_handle =
670 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
671 if (singleCam_algo_handle)
672 ret = singleCam_algo_handle->setWbAwbWbGainOffsetAttrib(attr);
673 }
674 }
675 #else
676 return XCAM_RETURN_ERROR_FAILED;
677 #endif
678 } else {
679 RkAiqAwbHandleInt* algo_handle =
680 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
681
682 if (algo_handle) {
683 return algo_handle->setWbAwbWbGainOffsetAttrib(attr);
684 }
685 }
686 return ret;
687 }
688
689 XCamReturn
rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_awb_wbGainOffset_t * attr)690 rk_aiq_user_api2_awb_GetWbGainOffsetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_awb_wbGainOffset_t *attr)
691 {
692 RKAIQ_API_SMART_LOCK(sys_ctx);
693
694 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
695 #ifdef RKAIQ_ENABLE_CAMGROUP
696 RkAiqCamGroupAwbHandleInt* algo_handle =
697 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
698
699 if (algo_handle) {
700 return algo_handle->getWbAwbWbGainOffsetAttrib(attr);
701 } else {
702 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
703 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
704 if (!camCtx)
705 continue;
706
707 RkAiqAwbHandleInt* singleCam_algo_handle =
708 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
709 if (singleCam_algo_handle)
710 return singleCam_algo_handle->getWbAwbWbGainOffsetAttrib(attr);
711 }
712 }
713 #else
714 return XCAM_RETURN_ERROR_FAILED;
715 #endif
716 } else {
717 RkAiqAwbHandleInt* algo_handle =
718 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
719
720 if (algo_handle) {
721 return algo_handle->getWbAwbWbGainOffsetAttrib(attr);
722 }
723 }
724 return XCAM_RETURN_NO_ERROR;
725 }
726
727 XCamReturn
rk_aiq_user_api2_awb_SetMultiWindowAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_awb_mulWindow_t attr)728 rk_aiq_user_api2_awb_SetMultiWindowAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_awb_mulWindow_t attr)
729 {
730 #if RKAIQ_HAVE_AWB_V21
731
732 CHECK_USER_API_ENABLE2(sys_ctx);
733 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
734 RKAIQ_API_SMART_LOCK(sys_ctx);
735 XCamReturn ret = XCAM_RETURN_NO_ERROR;
736
737 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
738 #ifdef RKAIQ_ENABLE_CAMGROUP
739 RkAiqCamGroupAwbHandleInt* algo_handle =
740 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
741
742 if (algo_handle) {
743 return algo_handle->setWbAwbMultiWindowAttrib(attr);
744 } else {
745 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
746 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
747 if (!camCtx)
748 continue;
749
750 RkAiqAwbV21HandleInt* singleCam_algo_handle =
751 algoHandle<RkAiqAwbV21HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
752 if (singleCam_algo_handle)
753 ret = singleCam_algo_handle->setWbAwbMultiWindowAttrib(attr);
754 }
755 }
756 #else
757 return XCAM_RETURN_ERROR_FAILED;
758 #endif
759 } else {
760 RkAiqAwbV21HandleInt* algo_handle =
761 algoHandle<RkAiqAwbV21HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
762
763 if (algo_handle) {
764 return algo_handle->setWbAwbMultiWindowAttrib(attr);
765 }
766 }
767 return ret;
768 #else
769 return XCAM_RETURN_ERROR_UNKNOWN;
770 #endif
771 }
772
773 XCamReturn
rk_aiq_user_api2_awb_GetMultiWindowAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wb_awb_mulWindow_t * attr)774 rk_aiq_user_api2_awb_GetMultiWindowAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wb_awb_mulWindow_t *attr)
775 {
776 #if RKAIQ_HAVE_AWB_V21
777
778 RKAIQ_API_SMART_LOCK(sys_ctx);
779
780 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
781 #ifdef RKAIQ_ENABLE_CAMGROUP
782 RkAiqCamGroupAwbHandleInt* algo_handle =
783 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
784
785 if (algo_handle) {
786 return algo_handle->getWbAwbMultiWindowAttrib(attr);
787 } else {
788 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
789 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
790 if (!camCtx)
791 continue;
792
793 RkAiqAwbV21HandleInt* singleCam_algo_handle =
794 algoHandle<RkAiqAwbV21HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
795 if (singleCam_algo_handle)
796 return singleCam_algo_handle->getWbAwbMultiWindowAttrib(attr);
797 }
798 }
799 #else
800 return XCAM_RETURN_ERROR_FAILED;
801 #endif
802 } else {
803 RkAiqAwbV21HandleInt* algo_handle =
804 algoHandle<RkAiqAwbV21HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
805
806 if (algo_handle) {
807 return algo_handle->getWbAwbMultiWindowAttrib(attr);
808 }
809 }
810 return XCAM_RETURN_NO_ERROR;
811 #else
812 return XCAM_RETURN_ERROR_UNKNOWN;
813 #endif
814 }
815
816 XCamReturn
rk_aiq_user_api2_awb_getStrategyResult(const rk_aiq_sys_ctx_t * sys_ctx,rk_tool_awb_strategy_result_t * attr)817 rk_aiq_user_api2_awb_getStrategyResult(const rk_aiq_sys_ctx_t* sys_ctx, rk_tool_awb_strategy_result_t *attr)
818 {
819
820 RKAIQ_API_SMART_LOCK(sys_ctx);
821
822 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
823 #ifdef RKAIQ_ENABLE_CAMGROUP
824 RkAiqCamGroupAwbHandleInt* algo_handle =
825 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
826
827 if (algo_handle) {
828 return algo_handle->getStrategyResult((rk_tool_awb_strategy_result_t*)attr);
829 } else {
830 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
831 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
832 if (!camCtx)
833 continue;
834
835 RkAiqAwbHandleInt* singleCam_algo_handle =
836 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
837 if (singleCam_algo_handle)
838 return singleCam_algo_handle->getStrategyResult((rk_tool_awb_strategy_result_t*)attr);
839 }
840 }
841 #else
842 return XCAM_RETURN_ERROR_FAILED;
843 #endif
844 } else {
845 RkAiqAwbHandleInt* algo_handle =
846 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
847
848 if (algo_handle) {
849 return algo_handle->getStrategyResult((rk_tool_awb_strategy_result_t*)attr);
850 }
851 }
852 return XCAM_RETURN_NO_ERROR;
853 }
854
855 XCamReturn
rk_aiq_user_api2_awb_getAlgoSta(const rk_aiq_sys_ctx_t * sys_ctx,rk_tool_awb_stat_res_full_t * attr)856 rk_aiq_user_api2_awb_getAlgoSta(const rk_aiq_sys_ctx_t* sys_ctx, rk_tool_awb_stat_res_full_t *attr)
857 {
858
859 RKAIQ_API_SMART_LOCK(sys_ctx);
860
861 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
862 #ifdef RKAIQ_ENABLE_CAMGROUP
863 RkAiqCamGroupAwbHandleInt* algo_handle =
864 camgroupAlgoHandle<RkAiqCamGroupAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
865
866 if (algo_handle) {
867 return algo_handle->getAlgoStat((rk_tool_awb_stat_res_full_t*)attr);
868 } else {
869 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
870 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
871 if (!camCtx)
872 continue;
873
874 RkAiqAwbHandleInt* singleCam_algo_handle =
875 algoHandle<RkAiqAwbHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AWB);
876 if (singleCam_algo_handle)
877 return singleCam_algo_handle->getAlgoStat((rk_tool_awb_stat_res_full_t*)attr);
878 }
879 }
880 #else
881 return XCAM_RETURN_ERROR_FAILED;
882 #endif
883 } else {
884 RkAiqAwbHandleInt* algo_handle =
885 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
886
887 if (algo_handle) {
888 return algo_handle->getAlgoStat((rk_tool_awb_stat_res_full_t*)attr);
889 }
890 }
891 return XCAM_RETURN_NO_ERROR;
892 }
893
894 XCamReturn
rk_aiq_user_api2_awbV32_SetMultiWindowAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV32_awb_mulWindow_t attr)895 rk_aiq_user_api2_awbV32_SetMultiWindowAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV32_awb_mulWindow_t attr)
896 {
897 #if RKAIQ_HAVE_AWB_V32
898
899 CHECK_USER_API_ENABLE2(sys_ctx);
900 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
901 RKAIQ_API_SMART_LOCK(sys_ctx);
902
903
904 RkAiqAwbV32HandleInt* algo_handle =
905 algoHandle<RkAiqAwbV32HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
906
907 if (algo_handle) {
908 return algo_handle->setWbV32AwbMultiWindowAttrib(attr);
909 }
910 return XCAM_RETURN_NO_ERROR;
911 #else
912 return XCAM_RETURN_ERROR_UNKNOWN;
913 #endif
914 }
915
916 XCamReturn
rk_aiq_user_api2_awbV32_GetMultiWindowAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_wbV32_awb_mulWindow_t * attr)917 rk_aiq_user_api2_awbV32_GetMultiWindowAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_wbV32_awb_mulWindow_t *attr)
918 {
919 #if RKAIQ_HAVE_AWB_V32
920
921 RKAIQ_API_SMART_LOCK(sys_ctx);
922
923 RkAiqAwbV32HandleInt* algo_handle =
924 algoHandle<RkAiqAwbV32HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
925
926 if (algo_handle) {
927 return algo_handle->getWbV32AwbMultiWindowAttrib(attr);
928 }
929 return XCAM_RETURN_NO_ERROR;
930 #else
931 return XCAM_RETURN_ERROR_UNKNOWN;
932 #endif
933 }
934
935 XCamReturn
rk_aiq_user_api2_awb_WriteAwbIn(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_awb_wrtIn_attr_t attr)936 rk_aiq_user_api2_awb_WriteAwbIn(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_awb_wrtIn_attr_t attr)
937 {
938 #if RKAIQ_HAVE_AWB_V32
939
940 CHECK_USER_API_ENABLE2(sys_ctx);
941 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
942 RKAIQ_API_SMART_LOCK(sys_ctx);
943
944
945 RkAiqAwbV32HandleInt* algo_handle =
946 algoHandle<RkAiqAwbV32HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
947
948 if (algo_handle) {
949 return algo_handle->writeAwbIn(attr);
950 }
951 return XCAM_RETURN_NO_ERROR;
952 #else
953 return XCAM_RETURN_ERROR_UNKNOWN;
954 #endif
955 }
956
957 XCamReturn
rk_aiq_user_api2_awb_SetFFWbgainAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_uapiV2_awb_ffwbgain_attr_t attr)958 rk_aiq_user_api2_awb_SetFFWbgainAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_uapiV2_awb_ffwbgain_attr_t attr)
959 {
960 CHECK_USER_API_ENABLE2(sys_ctx);
961 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AWB);
962 RKAIQ_API_SMART_LOCK(sys_ctx);
963
964 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
965 return XCAM_RETURN_ERROR_FAILED;
966 } else {
967 RkAiqAwbHandleInt* algo_handle =
968 algoHandle<RkAiqAwbHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AWB);
969
970 if (algo_handle) {
971 return algo_handle->setFFWbgainAttrib(attr);
972 }
973 }
974 return XCAM_RETURN_NO_ERROR;
975 }
976
977 RKAIQ_END_DECLARE
978