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 "rk_aiq_user_api_adebayer.h"
17
18 #include "RkAiqCamGroupHandleInt.h"
19 #include "algo_handlers/RkAiqAdebayerHandle.h"
20 #include "hwi/isp20/Isp20_module_dbg.h"
21
22 RKAIQ_BEGIN_DECLARE
23
24 #ifdef RK_SIMULATOR_HW
25 #define CHECK_USER_API_ENABLE
26 #endif
27
28 XCamReturn
rk_aiq_user_api_adebayer_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_attrib_t attr)29 rk_aiq_user_api_adebayer_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, adebayer_attrib_t attr)
30 {
31 #if RKAIQ_HAVE_DEBAYER_V1
32 CHECK_USER_API_ENABLE2(sys_ctx);
33 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ADEBAYER);
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 RkAiqCamGroupAdebayerHandleInt* algo_handle =
39 camgroupAlgoHandle<RkAiqCamGroupAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
40
41 if (algo_handle) {
42 return algo_handle->setAttrib(attr);
43 } else {
44 XCamReturn ret = XCAM_RETURN_ERROR_FAILED;
45 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
46 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
47 if (!camCtx)
48 continue;
49
50 RkAiqAdebayerHandleInt* singleCam_algo_handle =
51 algoHandle<RkAiqAdebayerHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADEBAYER);
52 if (singleCam_algo_handle)
53 ret = singleCam_algo_handle->setAttrib(attr);
54 }
55 return ret;
56 }
57 #else
58 return XCAM_RETURN_ERROR_FAILED;
59 #endif
60 } else {
61 RkAiqAdebayerHandleInt* algo_handle =
62 algoHandle<RkAiqAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
63
64 if (algo_handle) {
65 return algo_handle->setAttrib(attr);
66 }
67 }
68
69 return XCAM_RETURN_NO_ERROR;
70
71 #else
72 return XCAM_RETURN_ERROR_UNKNOWN;
73 #endif
74 }
75
76 XCamReturn
rk_aiq_user_api_adebayer_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_attrib_t * attr)77 rk_aiq_user_api_adebayer_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, adebayer_attrib_t *attr)
78 {
79 #if RKAIQ_HAVE_DEBAYER_V1
80
81 RKAIQ_API_SMART_LOCK(sys_ctx);
82 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
83 #ifdef RKAIQ_ENABLE_CAMGROUP
84 RkAiqCamGroupAdebayerHandleInt* algo_handle =
85 camgroupAlgoHandle<RkAiqCamGroupAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
86
87 if (algo_handle) {
88 return algo_handle->getAttrib(attr);
89 } else {
90 XCamReturn ret = XCAM_RETURN_ERROR_FAILED;
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)
94 continue;
95
96 RkAiqAdebayerHandleInt* singleCam_algo_handle =
97 algoHandle<RkAiqAdebayerHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADEBAYER);
98 if (singleCam_algo_handle)
99 ret = singleCam_algo_handle->getAttrib(attr);
100 }
101 return ret;
102 }
103 #else
104 return XCAM_RETURN_ERROR_FAILED;
105 #endif
106 } else {
107 RkAiqAdebayerHandleInt* algo_handle =
108 algoHandle<RkAiqAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
109
110 if (algo_handle) {
111 return algo_handle->getAttrib(attr);
112 }
113 }
114
115 return XCAM_RETURN_ERROR_FAILED;
116
117 #else
118 return XCAM_RETURN_ERROR_UNKNOWN;
119 #endif
120 }
121
122 XCamReturn
rk_aiq_user_api_adebayer_v2_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_v2_attrib_t attr)123 rk_aiq_user_api_adebayer_v2_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, adebayer_v2_attrib_t attr)
124 {
125 #if RKAIQ_HAVE_DEBAYER_V2
126
127 CHECK_USER_API_ENABLE2(sys_ctx);
128 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ADEBAYER);
129 RKAIQ_API_SMART_LOCK(sys_ctx);
130
131 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
132 #ifdef RKAIQ_ENABLE_CAMGROUP
133 RkAiqCamGroupAdebayerHandleInt* algo_handle =
134 camgroupAlgoHandle<RkAiqCamGroupAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
135
136 if (algo_handle) {
137 return algo_handle->setAttribV2(attr);
138 } else {
139 XCamReturn ret = XCAM_RETURN_ERROR_FAILED;
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 RkAiqAdebayerHandleInt* singleCam_algo_handle =
146 algoHandle<RkAiqAdebayerHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADEBAYER);
147 if (singleCam_algo_handle)
148 ret = singleCam_algo_handle->setAttribV2(attr);
149 }
150 return ret;
151 }
152 #else
153 return XCAM_RETURN_ERROR_FAILED;
154 #endif
155 } else {
156 RkAiqAdebayerHandleInt* algo_handle =
157 algoHandle<RkAiqAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
158
159 if (algo_handle) {
160 return algo_handle->setAttribV2(attr);
161 }
162 }
163
164 return XCAM_RETURN_NO_ERROR;
165
166 #else
167 return XCAM_RETURN_ERROR_UNKNOWN;
168 #endif
169 }
170
171 XCamReturn
rk_aiq_user_api_adebayer_v2_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_v2_attrib_t * attr)172 rk_aiq_user_api_adebayer_v2_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, adebayer_v2_attrib_t *attr)
173 {
174 #if RKAIQ_HAVE_DEBAYER_V2
175
176 RKAIQ_API_SMART_LOCK(sys_ctx);
177 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
178 #ifdef RKAIQ_ENABLE_CAMGROUP
179 RkAiqCamGroupAdebayerHandleInt* algo_handle =
180 camgroupAlgoHandle<RkAiqCamGroupAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
181
182 if (algo_handle) {
183 return algo_handle->getAttribV2(attr);
184 } else {
185 XCamReturn ret = XCAM_RETURN_ERROR_FAILED;
186 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
187 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
188 if (!camCtx)
189 continue;
190
191 RkAiqAdebayerHandleInt* singleCam_algo_handle =
192 algoHandle<RkAiqAdebayerHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADEBAYER);
193 if (singleCam_algo_handle)
194 ret = singleCam_algo_handle->getAttribV2(attr);
195 }
196 return ret;
197 }
198 #else
199 return XCAM_RETURN_ERROR_FAILED;
200 #endif
201 } else {
202 RkAiqAdebayerHandleInt* algo_handle =
203 algoHandle<RkAiqAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
204
205 if (algo_handle) {
206 return algo_handle->getAttribV2(attr);
207 }
208 }
209
210 return XCAM_RETURN_ERROR_FAILED;
211
212 #else
213 return XCAM_RETURN_ERROR_UNKNOWN;
214 #endif
215 }
216
217 XCamReturn
rk_aiq_user_api_adebayer_v2_lite_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_v2lite_attrib_t attr)218 rk_aiq_user_api_adebayer_v2_lite_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, adebayer_v2lite_attrib_t attr)
219 {
220 #if RKAIQ_HAVE_DEBAYER_V2_LITE
221
222 CHECK_USER_API_ENABLE2(sys_ctx);
223 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ADEBAYER);
224 RKAIQ_API_SMART_LOCK(sys_ctx);
225
226 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
227 #ifdef RKAIQ_ENABLE_CAMGROUP
228 RkAiqCamGroupAdebayerHandleInt* algo_handle =
229 camgroupAlgoHandle<RkAiqCamGroupAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
230
231 if (algo_handle) {
232 return algo_handle->setAttribV2(attr);
233 } else {
234 XCamReturn ret = XCAM_RETURN_ERROR_FAILED;
235 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
236 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
237 if (!camCtx)
238 continue;
239
240 RkAiqAdebayerHandleInt* singleCam_algo_handle =
241 algoHandle<RkAiqAdebayerHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADEBAYER);
242 if (singleCam_algo_handle)
243 ret = singleCam_algo_handle->setAttribV2(attr);
244 }
245 return ret;
246 }
247 #else
248 return XCAM_RETURN_ERROR_FAILED;
249 #endif
250 } else {
251 RkAiqAdebayerHandleInt* algo_handle =
252 algoHandle<RkAiqAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
253
254 if (algo_handle) {
255 return algo_handle->setAttribV2(attr);
256 }
257 }
258
259 return XCAM_RETURN_NO_ERROR;
260
261 #else
262 return XCAM_RETURN_ERROR_UNKNOWN;
263 #endif
264 }
265
266 XCamReturn
rk_aiq_user_api_adebayer_v2_lite_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_v2lite_attrib_t * attr)267 rk_aiq_user_api_adebayer_v2_lite_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, adebayer_v2lite_attrib_t *attr)
268 {
269 #if RKAIQ_HAVE_DEBAYER_V2_LITE
270
271 RKAIQ_API_SMART_LOCK(sys_ctx);
272 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
273 #ifdef RKAIQ_ENABLE_CAMGROUP
274 RkAiqCamGroupAdebayerHandleInt* algo_handle =
275 camgroupAlgoHandle<RkAiqCamGroupAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
276
277 if (algo_handle) {
278 return algo_handle->getAttribV2(attr);
279 } else {
280 XCamReturn ret = XCAM_RETURN_ERROR_FAILED;
281 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
282 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
283 if (!camCtx)
284 continue;
285
286 RkAiqAdebayerHandleInt* singleCam_algo_handle =
287 algoHandle<RkAiqAdebayerHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADEBAYER);
288 if (singleCam_algo_handle)
289 ret = singleCam_algo_handle->getAttribV2(attr);
290 }
291 return ret;
292 }
293 #else
294 return XCAM_RETURN_ERROR_FAILED;
295 #endif
296 } else {
297 RkAiqAdebayerHandleInt* algo_handle =
298 algoHandle<RkAiqAdebayerHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADEBAYER);
299
300 if (algo_handle) {
301 return algo_handle->getAttribV2(attr);
302 }
303 }
304
305 return XCAM_RETURN_ERROR_FAILED;
306
307 #else
308 return XCAM_RETURN_ERROR_UNKNOWN;
309 #endif
310 }
311
312 RKAIQ_END_DECLARE
313