1 /*
2 * Copyright (c) 2022 Rockchip Electronics Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "rk_aiq_user_api2_acac.h"
17
18 #include "Isp20_module_dbg.h"
19 #include "aiq_core/algo_camgroup_handlers/RkAiqCamGroupAcacHandle.h"
20 #include "aiq_core/algo_handlers/RkAiqAcacV11Handle.h"
21 #include "algos/acac/rk_aiq_types_acac_algo_int.h"
22 #include "common/rk_aiq.h"
23 #include "uAPI/rk_aiq_api_private.h"
24 #include "xcore/base/xcam_common.h"
25
26 RKAIQ_BEGIN_DECLARE
27
28 using namespace RkCam;
29
30 typedef struct rk_aiq_sys_ctx_s rk_aiq_sys_ctx_t;
31
32 #ifdef RK_SIMULATOR_HW
33 #define CHECK_USER_API_ENABLE
34 #endif
35
36 #if RKAIQ_HAVE_CAC_V03
rk_aiq_user_api2_acac_v03_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rkaiq_cac_v03_api_attr_t * attr)37 XCamReturn rk_aiq_user_api2_acac_v03_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
38 const rkaiq_cac_v03_api_attr_t* attr) {
39 CHECK_USER_API_ENABLE2(sys_ctx);
40 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ACAC);
41 XCamReturn ret = XCAM_RETURN_NO_ERROR;
42 XCAM_ASSERT(attr != nullptr);
43
44 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
45 #ifdef RKAIQ_ENABLE_CAMGROUP
46 RkAiqCamGroupAcacHandleInt* algo_handle =
47 camgroupAlgoHandle<RkAiqCamGroupAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
48
49 if (algo_handle) {
50 return algo_handle->setAttribV03(attr);
51 } else {
52 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
53 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
54 if (!camCtx) continue;
55
56 RkAiqAcacV3HandleInt* singleCam_algo_handle =
57 algoHandle<RkAiqAcacV3HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACAC);
58 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttrib(attr);
59 }
60 }
61 #else
62 return XCAM_RETURN_ERROR_FAILED;
63 #endif
64 } else {
65 RkAiqAcacV3HandleInt* algo_handle =
66 algoHandle<RkAiqAcacV3HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
67
68 if (algo_handle) {
69 return algo_handle->setAttrib(attr);
70 }
71 }
72
73 return ret;
74
75 }
76
rk_aiq_user_api2_acac_v03_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rkaiq_cac_v03_api_attr_t * attr)77 XCamReturn rk_aiq_user_api2_acac_v03_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
78 rkaiq_cac_v03_api_attr_t* attr) {
79 RKAIQ_API_SMART_LOCK(sys_ctx);
80
81 XCAM_ASSERT(attr != nullptr);
82
83 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
84 #ifdef RKAIQ_ENABLE_CAMGROUP
85 RkAiqCamGroupAcacHandleInt* algo_handle =
86 camgroupAlgoHandle<RkAiqCamGroupAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
87
88 if (algo_handle) {
89 return algo_handle->getAttribV03(attr);
90 } else {
91 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
92 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
93 if (!camCtx) continue;
94
95 RkAiqAcacV3HandleInt* singleCam_algo_handle =
96 algoHandle<RkAiqAcacV3HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACAC);
97 if (singleCam_algo_handle) return singleCam_algo_handle->getAttrib(attr);
98 }
99 }
100 #else
101 return XCAM_RETURN_ERROR_FAILED;
102 #endif
103 } else {
104 RkAiqAcacV3HandleInt* algo_handle =
105 algoHandle<RkAiqAcacV3HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
106
107 if (algo_handle) {
108 return algo_handle->getAttrib(attr);
109 }
110 }
111
112 return XCAM_RETURN_NO_ERROR;
113 }
114 #else
rk_aiq_user_api2_acac_v03_SetAttrib(const rk_aiq_sys_ctx_t *,const rkaiq_cac_v03_api_attr_t *)115 XCamReturn rk_aiq_user_api2_acac_v03_SetAttrib(const rk_aiq_sys_ctx_t* /* sys_ctx */,
116 const rkaiq_cac_v03_api_attr_t* /* attr */) {
117 return XCAM_RETURN_ERROR_FAILED;
118 }
rk_aiq_user_api2_acac_v03_GetAttrib(const rk_aiq_sys_ctx_t *,rkaiq_cac_v03_api_attr_t *)119 XCamReturn rk_aiq_user_api2_acac_v03_GetAttrib(const rk_aiq_sys_ctx_t* /* sys_ctx */,
120 rkaiq_cac_v03_api_attr_t* /* attr */) {
121 return XCAM_RETURN_ERROR_FAILED;
122 }
123 #endif
124
125 #if RKAIQ_HAVE_CAC_V10
rk_aiq_user_api2_acac_v10_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rkaiq_cac_v10_api_attr_t * attr)126 XCamReturn rk_aiq_user_api2_acac_v10_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
127 const rkaiq_cac_v10_api_attr_t* attr) {
128 CHECK_USER_API_ENABLE2(sys_ctx);
129 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ACAC);
130
131 XCAM_ASSERT(attr != nullptr);
132 XCamReturn ret = XCAM_RETURN_NO_ERROR;
133
134 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
135 #ifdef RKAIQ_ENABLE_CAMGROUP
136 RkAiqCamGroupAcacHandleInt* algo_handle =
137 camgroupAlgoHandle<RkAiqCamGroupAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
138
139 if (algo_handle) {
140 return algo_handle->setAttribV10(attr);
141 } else {
142 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
143 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
144 if (!camCtx) continue;
145
146 RkAiqAcacHandleInt* singleCam_algo_handle =
147 algoHandle<RkAiqAcacHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACAC);
148 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttrib(attr);
149 }
150 }
151 #else
152 return XCAM_RETURN_ERROR_FAILED;
153 #endif
154 } else {
155 RkAiqAcacHandleInt* algo_handle =
156 algoHandle<RkAiqAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
157
158 if (algo_handle) {
159 return algo_handle->setAttrib(attr);
160 }
161 }
162
163 return ret;
164 }
165
rk_aiq_user_api2_acac_v10_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rkaiq_cac_v10_api_attr_t * attr)166 XCamReturn rk_aiq_user_api2_acac_v10_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
167 rkaiq_cac_v10_api_attr_t* attr) {
168 RKAIQ_API_SMART_LOCK(sys_ctx);
169
170 XCAM_ASSERT(attr != nullptr);
171
172 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
173 #ifdef RKAIQ_ENABLE_CAMGROUP
174 RkAiqCamGroupAcacHandleInt* algo_handle =
175 camgroupAlgoHandle<RkAiqCamGroupAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
176
177 if (algo_handle) {
178 return algo_handle->getAttribV10(attr);
179 } else {
180 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
181 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
182 if (!camCtx) continue;
183
184 RkAiqAcacHandleInt* singleCam_algo_handle =
185 algoHandle<RkAiqAcacHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACAC);
186 if (singleCam_algo_handle) return singleCam_algo_handle->getAttrib(attr);
187 }
188 }
189 #else
190 return XCAM_RETURN_ERROR_FAILED;
191 #endif
192 } else {
193 RkAiqAcacHandleInt* algo_handle =
194 algoHandle<RkAiqAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
195
196 if (algo_handle) {
197 return algo_handle->getAttrib(attr);
198 }
199 }
200
201 return XCAM_RETURN_NO_ERROR;
202 }
203 #else
rk_aiq_user_api2_acac_v10_SetAttrib(const rk_aiq_sys_ctx_t *,const rkaiq_cac_v10_api_attr_t *)204 XCamReturn rk_aiq_user_api2_acac_v10_SetAttrib(const rk_aiq_sys_ctx_t* /* sys_ctx */,
205 const rkaiq_cac_v10_api_attr_t* /* attr */) {
206 return XCAM_RETURN_ERROR_FAILED;
207 }
rk_aiq_user_api2_acac_v10_GetAttrib(const rk_aiq_sys_ctx_t *,rkaiq_cac_v10_api_attr_t *)208 XCamReturn rk_aiq_user_api2_acac_v10_GetAttrib(const rk_aiq_sys_ctx_t* /* sys_ctx */,
209 rkaiq_cac_v10_api_attr_t* /* attr */) {
210 return XCAM_RETURN_ERROR_FAILED;
211 }
212 #endif
213
214 #if RKAIQ_HAVE_CAC_V11
rk_aiq_user_api2_acac_v11_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rkaiq_cac_v11_api_attr_t * attr)215 XCamReturn rk_aiq_user_api2_acac_v11_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
216 const rkaiq_cac_v11_api_attr_t* attr) {
217 CHECK_USER_API_ENABLE2(sys_ctx);
218 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ACAC);
219 XCamReturn ret = XCAM_RETURN_NO_ERROR;
220
221 XCAM_ASSERT(attr != nullptr);
222
223 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
224 #ifdef RKAIQ_ENABLE_CAMGROUP
225 RkAiqCamGroupAcacHandleInt* algo_handle =
226 camgroupAlgoHandle<RkAiqCamGroupAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
227
228 if (algo_handle) {
229 return algo_handle->setAttribV11(attr);
230 } else {
231 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
232 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
233 if (!camCtx) continue;
234
235 RkAiqAcacV11HandleInt* singleCam_algo_handle =
236 algoHandle<RkAiqAcacV11HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACAC);
237 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttrib(attr);
238 }
239 }
240 #else
241 return XCAM_RETURN_ERROR_FAILED;
242 #endif
243 } else {
244 RkAiqAcacV11HandleInt* algo_handle =
245 algoHandle<RkAiqAcacV11HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
246
247 if (algo_handle) {
248 return algo_handle->setAttrib(attr);
249 }
250 }
251
252 return ret;
253 }
254
rk_aiq_user_api2_acac_v11_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rkaiq_cac_v11_api_attr_t * attr)255 XCamReturn rk_aiq_user_api2_acac_v11_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
256 rkaiq_cac_v11_api_attr_t* attr) {
257 RKAIQ_API_SMART_LOCK(sys_ctx);
258
259 XCAM_ASSERT(attr != nullptr);
260
261 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
262 #ifdef RKAIQ_ENABLE_CAMGROUP
263 RkAiqCamGroupAcacHandleInt* algo_handle =
264 camgroupAlgoHandle<RkAiqCamGroupAcacHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
265
266 if (algo_handle) {
267 return algo_handle->getAttribV11(attr);
268 } else {
269 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
270 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
271 if (!camCtx) continue;
272
273 RkAiqAcacV11HandleInt* singleCam_algo_handle =
274 algoHandle<RkAiqAcacV11HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACAC);
275 if (singleCam_algo_handle) return singleCam_algo_handle->getAttrib(attr);
276 }
277 }
278 #else
279 return XCAM_RETURN_ERROR_FAILED;
280 #endif
281 } else {
282 RkAiqAcacV11HandleInt* algo_handle =
283 algoHandle<RkAiqAcacV11HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACAC);
284
285 if (algo_handle) {
286 return algo_handle->getAttrib(attr);
287 }
288 }
289
290 return XCAM_RETURN_NO_ERROR;
291 }
292 #else
rk_aiq_user_api2_acac_v11_SetAttrib(const rk_aiq_sys_ctx_t *,const rkaiq_cac_v11_api_attr_t *)293 XCamReturn rk_aiq_user_api2_acac_v11_SetAttrib(const rk_aiq_sys_ctx_t* /* sys_ctx */,
294 const rkaiq_cac_v11_api_attr_t* /* attr */) {
295 return XCAM_RETURN_ERROR_FAILED;
296 }
rk_aiq_user_api2_acac_v11_GetAttrib(const rk_aiq_sys_ctx_t *,rkaiq_cac_v11_api_attr_t *)297 XCamReturn rk_aiq_user_api2_acac_v11_GetAttrib(const rk_aiq_sys_ctx_t* /* sys_ctx */,
298 rkaiq_cac_v11_api_attr_t* /* attr */) {
299 return XCAM_RETURN_ERROR_FAILED;
300 }
301 #endif
302
303 RKAIQ_END_DECLARE
304