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_asharp_v4.h"
17
18 #include "RkAiqCamGroupHandleInt.h"
19 #include "algo_handlers/RkAiqAsharpV4Handle.h"
20
21 RKAIQ_BEGIN_DECLARE
22
23 #ifdef RK_SIMULATOR_HW
24 #define CHECK_USER_API_ENABLE
25 #endif
26
27 #if RKAIQ_HAVE_SHARP_V4
28
29 XCamReturn
rk_aiq_user_api2_asharpV4_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_attrib_v4_t * attr)30 rk_aiq_user_api2_asharpV4_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_attrib_v4_t* attr)
31 {
32 CHECK_USER_API_ENABLE2(sys_ctx);
33 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ASHARP);
34 XCamReturn ret = XCAM_RETURN_NO_ERROR;
35
36 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
37 #ifdef RKAIQ_ENABLE_CAMGROUP
38 RkAiqCamGroupAsharpV4HandleInt* algo_handle =
39 camgroupAlgoHandle<RkAiqCamGroupAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
40
41 if (algo_handle) {
42 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
43 return algo_handle->setAttrib(attr);
44 } else {
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 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
51 RkAiqAsharpV4HandleInt* singleCam_algo_handle =
52 algoHandle<RkAiqAsharpV4HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
53 if (singleCam_algo_handle)
54 ret = singleCam_algo_handle->setAttrib(attr);
55 }
56 }
57 #else
58 return XCAM_RETURN_ERROR_FAILED;
59 #endif
60 } else {
61 RkAiqAsharpV4HandleInt* algo_handle =
62 algoHandle<RkAiqAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
63 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
64 if (algo_handle) {
65 return algo_handle->setAttrib(attr);
66 }
67 }
68
69 return XCAM_RETURN_NO_ERROR;
70 }
71
72 XCamReturn
rk_aiq_user_api2_asharpV4_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_attrib_v4_t * attr)73 rk_aiq_user_api2_asharpV4_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_attrib_v4_t* attr)
74 {
75
76 XCamReturn ret = XCAM_RETURN_NO_ERROR;
77
78 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
79 #ifdef RKAIQ_ENABLE_CAMGROUP
80 RkAiqCamGroupAsharpV4HandleInt* algo_handle =
81 camgroupAlgoHandle<RkAiqCamGroupAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
82
83 if (algo_handle) {
84 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
85 return algo_handle->getAttrib(attr);
86 } else {
87 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
88 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
89 if (!camCtx)
90 continue;
91
92 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
93 RkAiqAsharpV4HandleInt* singleCam_algo_handle =
94 algoHandle<RkAiqAsharpV4HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
95 if (singleCam_algo_handle)
96 ret = singleCam_algo_handle->getAttrib(attr);
97 }
98 }
99 #else
100 return XCAM_RETURN_ERROR_FAILED;
101 #endif
102 } else {
103 RkAiqAsharpV4HandleInt* algo_handle =
104 algoHandle<RkAiqAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
105 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
106 if (algo_handle) {
107 return algo_handle->getAttrib(attr);
108 }
109 }
110
111 return XCAM_RETURN_NO_ERROR;
112 }
113
114 XCamReturn
rk_aiq_user_api2_asharpV4_SetStrength(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_strength_v4_t * pStrength)115 rk_aiq_user_api2_asharpV4_SetStrength(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_strength_v4_t *pStrength)
116 {
117 XCamReturn ret = XCAM_RETURN_NO_ERROR;
118 RKAIQ_API_SMART_LOCK(sys_ctx);
119
120
121 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
122 #ifdef RKAIQ_ENABLE_CAMGROUP
123 RkAiqCamGroupAsharpV4HandleInt* algo_handle =
124 camgroupAlgoHandle<RkAiqCamGroupAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
125
126 if (algo_handle) {
127 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
128 return algo_handle->setStrength(pStrength);
129 } else {
130 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
131 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
132 if (!camCtx)
133 continue;
134
135 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
136 RkAiqAsharpV4HandleInt* singleCam_algo_handle =
137 algoHandle<RkAiqAsharpV4HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
138 if (singleCam_algo_handle)
139 ret = singleCam_algo_handle->setStrength(pStrength);
140 }
141 }
142 #else
143 return XCAM_RETURN_ERROR_FAILED;
144 #endif
145 } else {
146 RkAiqAsharpV4HandleInt* algo_handle =
147 algoHandle<RkAiqAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
148 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
149 if (algo_handle) {
150 return algo_handle->setStrength(pStrength);
151 }
152 }
153
154 return ret;
155 }
156
157
158 XCamReturn
rk_aiq_user_api2_asharpV4_GetStrength(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_strength_v4_t * pStrength)159 rk_aiq_user_api2_asharpV4_GetStrength(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_strength_v4_t *pStrength)
160 {
161 XCamReturn ret = XCAM_RETURN_NO_ERROR;
162 RKAIQ_API_SMART_LOCK(sys_ctx);
163
164
165 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
166 #ifdef RKAIQ_ENABLE_CAMGROUP
167 RkAiqCamGroupAsharpV4HandleInt* algo_handle =
168 camgroupAlgoHandle<RkAiqCamGroupAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
169
170 if (algo_handle) {
171 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
172 return algo_handle->getStrength(pStrength);
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 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
180 RkAiqAsharpV4HandleInt* singleCam_algo_handle =
181 algoHandle<RkAiqAsharpV4HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
182 if (singleCam_algo_handle)
183 ret = singleCam_algo_handle->getStrength(pStrength);
184 }
185 }
186 #else
187 return XCAM_RETURN_ERROR_FAILED;
188 #endif
189 } else {
190 RkAiqAsharpV4HandleInt* algo_handle =
191 algoHandle<RkAiqAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
192 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
193 if (algo_handle) {
194 return algo_handle->getStrength(pStrength);
195 }
196 }
197
198 return ret;
199 }
200
201 XCamReturn
rk_aiq_user_api2_asharpV4_GetInfo(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_sharp_info_v4_t * pInfo)202 rk_aiq_user_api2_asharpV4_GetInfo(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_info_v4_t *pInfo)
203 {
204 XCamReturn ret = XCAM_RETURN_NO_ERROR;
205 RKAIQ_API_SMART_LOCK(sys_ctx);
206
207
208 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
209 #ifdef RKAIQ_ENABLE_CAMGROUP
210 RkAiqCamGroupAsharpV4HandleInt* algo_handle =
211 camgroupAlgoHandle<RkAiqCamGroupAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
212
213 if (algo_handle) {
214 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!group!!!!!!!!\n", __FUNCTION__, __LINE__);
215 return algo_handle->getInfo(pInfo);
216 } else {
217 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
218 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
219 if (!camCtx)
220 continue;
221
222 LOGD_ASHARP("%s:%d !!!!!!!!!!!!!multi single!!!!!!!!\n", __FUNCTION__, __LINE__);
223 RkAiqAsharpV4HandleInt* singleCam_algo_handle =
224 algoHandle<RkAiqAsharpV4HandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ASHARP);
225 if (singleCam_algo_handle)
226 ret = singleCam_algo_handle->getInfo(pInfo);
227 }
228 }
229 #else
230 return XCAM_RETURN_ERROR_FAILED;
231 #endif
232 } else {
233 RkAiqAsharpV4HandleInt* algo_handle =
234 algoHandle<RkAiqAsharpV4HandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ASHARP);
235 LOGD_ASHARP("%s:%d !!!!!!!!!!!!! single!!!!!!!!\n", __FUNCTION__, __LINE__);
236 if (algo_handle) {
237 return algo_handle->getInfo(pInfo);
238 }
239 }
240
241 return ret;
242 }
243
244 #else
245
246 XCamReturn
247 rk_aiq_user_api2_asharpV4_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_attrib_v4_t* attr)
248 {
249 return XCAM_RETURN_ERROR_UNKNOWN;
250 }
251
252 XCamReturn
253 rk_aiq_user_api2_asharpV4_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_attrib_v4_t* attr)
254 {
255 return XCAM_RETURN_ERROR_UNKNOWN;
256 }
257
258 XCamReturn
259 rk_aiq_user_api2_asharpV4_SetStrength(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_strength_v4_t *pStrength)
260 {
261 return XCAM_RETURN_ERROR_UNKNOWN;
262 }
263
264 XCamReturn
265 rk_aiq_user_api2_asharpV4_GetStrength(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_strength_v4_t *pStrength)
266 {
267 return XCAM_RETURN_ERROR_UNKNOWN;
268 }
269
270 XCamReturn
271 rk_aiq_user_api2_asharpV4_GetInfo(const rk_aiq_sys_ctx_t* sys_ctx, rk_aiq_sharp_info_v4_t *pInfo)
272 {
273 return XCAM_RETURN_ERROR_UNKNOWN;
274 }
275
276 #endif
277
278 RKAIQ_END_DECLARE
279