1 /*
2 * rk_aiq_user_api2_asharp_v33.c
3 *
4 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18 #include "uAPI2/rk_aiq_user_api2_asharp_v33.h"
19
20 #include "RkAiqCamGroupHandleInt.h"
21 #include "algo_handlers/RkAiqAsharpV33Handle.h"
22
23 RKAIQ_BEGIN_DECLARE
24
25 #ifdef RK_SIMULATOR_HW
26 #define CHECK_USER_API_ENABLE
27 #endif
28
29 #if (RKAIQ_HAVE_SHARP_V33 || RKAIQ_HAVE_SHARP_V33_LITE)
30
rk_aiq_user_api2_asharpV33_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_sharp_attrib_v33_t * attr)31 XCamReturn rk_aiq_user_api2_asharpV33_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
32 const rk_aiq_sharp_attrib_v33_t* attr) {
33 CHECK_USER_API_ENABLE2(sys_ctx);
34 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ASHARP);
35 XCamReturn ret = XCAM_RETURN_NO_ERROR;
36
37 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
38 #ifdef RKAIQ_ENABLE_CAMGROUP
39 RkAiqCamGroupAsharpV33HandleInt* algo_handle =
40 camgroupAlgoHandle<RkAiqCamGroupAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
41
42 if (algo_handle) {
43 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
44 return algo_handle->setAttrib(attr);
45 } else {
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) continue;
49
50 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
51 RkAiqAsharpV33HandleInt* singleCam_algo_handle =
52 algoHandle<RkAiqAsharpV33HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
53 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttrib(attr);
54 }
55 }
56 #else
57 return XCAM_RETURN_ERROR_FAILED;
58 #endif // RKAIQ_ENABLE_CAMGROUP
59 } else {
60 RkAiqAsharpV33HandleInt* algo_handle =
61 algoHandle<RkAiqAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
62 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
63 if (algo_handle) {
64 return algo_handle->setAttrib(attr);
65 }
66 }
67
68 return XCAM_RETURN_NO_ERROR;
69 }
70
rk_aiq_user_api2_asharpV33_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_attrib_v33_t * attr)71 XCamReturn rk_aiq_user_api2_asharpV33_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
72 rk_aiq_sharp_attrib_v33_t* attr) {
73 XCamReturn ret = XCAM_RETURN_NO_ERROR;
74
75 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
76 #ifdef RKAIQ_ENABLE_CAMGROUP
77 RkAiqCamGroupAsharpV33HandleInt* algo_handle =
78 camgroupAlgoHandle<RkAiqCamGroupAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
79
80 if (algo_handle) {
81 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
82 return algo_handle->getAttrib(attr);
83 } else {
84 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
85 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
86 if (!camCtx) continue;
87
88 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
89 RkAiqAsharpV33HandleInt* singleCam_algo_handle =
90 algoHandle<RkAiqAsharpV33HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
91 if (singleCam_algo_handle) ret = singleCam_algo_handle->getAttrib(attr);
92 }
93 }
94 #else
95 return XCAM_RETURN_ERROR_FAILED;
96 #endif // RKAIQ_ENABLE_CAMGROUP
97 } else {
98 RkAiqAsharpV33HandleInt* algo_handle =
99 algoHandle<RkAiqAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
100 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
101 if (algo_handle) {
102 return algo_handle->getAttrib(attr);
103 }
104 }
105
106 return XCAM_RETURN_NO_ERROR;
107 }
108
rk_aiq_user_api2_asharpV33Lite_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_sharp_attrib_v33LT_t * attr)109 XCamReturn rk_aiq_user_api2_asharpV33Lite_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
110 const rk_aiq_sharp_attrib_v33LT_t* attr) {
111 CHECK_USER_API_ENABLE2(sys_ctx);
112 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ASHARP);
113 XCamReturn ret = XCAM_RETURN_NO_ERROR;
114
115 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
116 #ifdef RKAIQ_ENABLE_CAMGROUP
117 RkAiqCamGroupAsharpV33HandleInt* algo_handle =
118 camgroupAlgoHandle<RkAiqCamGroupAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
119
120 if (algo_handle) {
121 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
122 return algo_handle->setAttribLite(attr);
123 } else {
124 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
125 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
126 if (!camCtx) continue;
127
128 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
129 RkAiqAsharpV33HandleInt* singleCam_algo_handle =
130 algoHandle<RkAiqAsharpV33HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
131 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttribLite(attr);
132 }
133 }
134 #else
135 return XCAM_RETURN_ERROR_FAILED;
136 #endif // RKAIQ_ENABLE_CAMGROUP
137 } else {
138 RkAiqAsharpV33HandleInt* algo_handle =
139 algoHandle<RkAiqAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
140 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
141 if (algo_handle) {
142 return algo_handle->setAttribLite(attr);
143 }
144 }
145
146 return XCAM_RETURN_NO_ERROR;
147 }
148
rk_aiq_user_api2_asharpV33Lite_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_attrib_v33LT_t * attr)149 XCamReturn rk_aiq_user_api2_asharpV33Lite_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
150 rk_aiq_sharp_attrib_v33LT_t* attr) {
151 XCamReturn ret = XCAM_RETURN_NO_ERROR;
152
153 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
154 #ifdef RKAIQ_ENABLE_CAMGROUP
155 RkAiqCamGroupAsharpV33HandleInt* algo_handle =
156 camgroupAlgoHandle<RkAiqCamGroupAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
157
158 if (algo_handle) {
159 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
160 return algo_handle->getAttribLite(attr);
161 } else {
162 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
163 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
164 if (!camCtx) continue;
165
166 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
167 RkAiqAsharpV33HandleInt* singleCam_algo_handle =
168 algoHandle<RkAiqAsharpV33HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
169 if (singleCam_algo_handle) ret = singleCam_algo_handle->getAttribLite(attr);
170 }
171 }
172 #else
173 return XCAM_RETURN_ERROR_FAILED;
174 #endif // RKAIQ_ENABLE_CAMGROUP
175 } else {
176 RkAiqAsharpV33HandleInt* algo_handle =
177 algoHandle<RkAiqAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
178 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
179 if (algo_handle) {
180 return algo_handle->getAttribLite(attr);
181 }
182 }
183
184 return XCAM_RETURN_NO_ERROR;
185 }
186
rk_aiq_user_api2_asharpV33_SetStrength(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_sharp_strength_v33_t * pStrength)187 XCamReturn rk_aiq_user_api2_asharpV33_SetStrength(const rk_aiq_sys_ctx_t* sys_ctx,
188 const rk_aiq_sharp_strength_v33_t* pStrength) {
189 XCamReturn ret = XCAM_RETURN_NO_ERROR;
190 RKAIQ_API_SMART_LOCK(sys_ctx);
191
192 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
193 #ifdef RKAIQ_ENABLE_CAMGROUP
194 RkAiqCamGroupAsharpV33HandleInt* algo_handle =
195 camgroupAlgoHandle<RkAiqCamGroupAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
196
197 if (algo_handle) {
198 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
199 return algo_handle->setStrength(pStrength);
200 } else {
201 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
202 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
203 if (!camCtx) continue;
204
205 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
206 RkAiqAsharpV33HandleInt* singleCam_algo_handle =
207 algoHandle<RkAiqAsharpV33HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
208 if (singleCam_algo_handle) ret = singleCam_algo_handle->setStrength(pStrength);
209 }
210 }
211 #else
212 return XCAM_RETURN_ERROR_FAILED;
213 #endif // RKAIQ_ENABLE_CAMGROUP
214 } else {
215 RkAiqAsharpV33HandleInt* algo_handle =
216 algoHandle<RkAiqAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
217 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
218 if (algo_handle) {
219 return algo_handle->setStrength(pStrength);
220 }
221 }
222
223 return ret;
224 }
225
rk_aiq_user_api2_asharpV33_GetStrength(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_strength_v33_t * pStrength)226 XCamReturn rk_aiq_user_api2_asharpV33_GetStrength(const rk_aiq_sys_ctx_t* sys_ctx,
227 rk_aiq_sharp_strength_v33_t* pStrength) {
228 XCamReturn ret = XCAM_RETURN_NO_ERROR;
229 RKAIQ_API_SMART_LOCK(sys_ctx);
230
231 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
232 #ifdef RKAIQ_ENABLE_CAMGROUP
233 RkAiqCamGroupAsharpV33HandleInt* algo_handle =
234 camgroupAlgoHandle<RkAiqCamGroupAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
235
236 if (algo_handle) {
237 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
238 return algo_handle->getStrength(pStrength);
239 } else {
240 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
241 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
242 if (!camCtx) continue;
243
244 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
245 RkAiqAsharpV33HandleInt* singleCam_algo_handle =
246 algoHandle<RkAiqAsharpV33HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
247 if (singleCam_algo_handle) ret = singleCam_algo_handle->getStrength(pStrength);
248 }
249 }
250 #else
251 return XCAM_RETURN_ERROR_FAILED;
252 #endif // RKAIQ_ENABLE_CAMGROUP
253 } else {
254 RkAiqAsharpV33HandleInt* algo_handle =
255 algoHandle<RkAiqAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
256 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
257 if (algo_handle) {
258 return algo_handle->getStrength(pStrength);
259 }
260 }
261
262 return ret;
263 }
264
rk_aiq_user_api2_asharpV33_GetInfo(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_info_v33_t * pInfo)265 XCamReturn rk_aiq_user_api2_asharpV33_GetInfo(const rk_aiq_sys_ctx_t* sys_ctx,
266 rk_aiq_sharp_info_v33_t* pInfo) {
267 XCamReturn ret = XCAM_RETURN_NO_ERROR;
268 RKAIQ_API_SMART_LOCK(sys_ctx);
269
270 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
271 #ifdef RKAIQ_ENABLE_CAMGROUP
272 RkAiqCamGroupAsharpV33HandleInt* algo_handle =
273 camgroupAlgoHandle<RkAiqCamGroupAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
274
275 if (algo_handle) {
276 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
277 return algo_handle->getInfo(pInfo);
278 } else {
279 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
280 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
281 if (!camCtx) continue;
282
283 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
284 RkAiqAsharpV33HandleInt* singleCam_algo_handle =
285 algoHandle<RkAiqAsharpV33HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
286 if (singleCam_algo_handle) ret = singleCam_algo_handle->getInfo(pInfo);
287 }
288 }
289 #else
290 return XCAM_RETURN_ERROR_FAILED;
291 #endif // RKAIQ_ENABLE_CAMGROUP
292 } else {
293 RkAiqAsharpV33HandleInt* algo_handle =
294 algoHandle<RkAiqAsharpV33HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
295 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
296 if (algo_handle) {
297 return algo_handle->getInfo(pInfo);
298 }
299 }
300
301 return ret;
302 }
303
304
305 #else // RKAIQ_HAVE_SHARP_V33
306
307 XCamReturn rk_aiq_user_api2_asharpV33_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
308 const rk_aiq_sharp_attrib_v33_t* attr) {
309 return XCAM_RETURN_ERROR_UNKNOWN;
310 }
311
312 XCamReturn rk_aiq_user_api2_asharpV33_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
313 rk_aiq_sharp_attrib_v33_t* attr) {
314 return XCAM_RETURN_ERROR_UNKNOWN;
315 }
316
317 XCamReturn rk_aiq_user_api2_asharpV33Lite_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
318 const rk_aiq_sharp_attrib_v33LT_t* attr) {
319 return XCAM_RETURN_ERROR_UNKNOWN;
320 }
321
322 XCamReturn rk_aiq_user_api2_asharpV33Lite_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
323 rk_aiq_sharp_attrib_v33LT_t* attr) {
324 return XCAM_RETURN_ERROR_UNKNOWN;
325 }
326
327 XCamReturn rk_aiq_user_api2_asharpV33_SetStrength(const rk_aiq_sys_ctx_t* sys_ctx,
328 const rk_aiq_sharp_strength_v33_t* pStrength) {
329 return XCAM_RETURN_ERROR_UNKNOWN;
330 }
331
332 XCamReturn rk_aiq_user_api2_asharpV33_GetStrength(const rk_aiq_sys_ctx_t* sys_ctx,
333 rk_aiq_sharp_strength_v33_t* pStrength) {
334 return XCAM_RETURN_ERROR_UNKNOWN;
335 }
336
337 XCamReturn rk_aiq_user_api2_asharpV33_GetInfo(const rk_aiq_sys_ctx_t* sys_ctx,
338 rk_aiq_sharp_info_v33_t* pInfo) {
339 return XCAM_RETURN_ERROR_UNKNOWN;
340 }
341
342 #endif
343
344 RKAIQ_END_DECLARE
345