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_accm.h"
17
18 #include "RkAiqCamGroupHandleInt.h"
19 #include "algo_handlers/RkAiqAccmHandle.h"
20
21 #ifdef RK_SIMULATOR_HW
22 #define CHECK_USER_API_ENABLE
23 #endif
24
25 #if RKAIQ_HAVE_CCM_V1
rk_aiq_user_api2_accm_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_ccm_attrib_t * attr)26 XCamReturn rk_aiq_user_api2_accm_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
27 const rk_aiq_ccm_attrib_t* attr)
28 {
29 XCamReturn ret = XCAM_RETURN_NO_ERROR;
30 CHECK_USER_API_ENABLE2(sys_ctx);
31 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ACCM);
32 RKAIQ_API_SMART_LOCK(sys_ctx);
33
34 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
35 #ifdef RKAIQ_ENABLE_CAMGROUP
36 RkAiqCamGroupAccmHandleInt* algo_handle =
37 camgroupAlgoHandle<RkAiqCamGroupAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
38
39 if (algo_handle) {
40 return algo_handle->setAttrib(attr);
41 } else {
42 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
43 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
44 if (!camCtx)
45 continue;
46
47 RkAiqAccmHandleInt* singleCam_algo_handle =
48 algoHandle<RkAiqAccmHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACCM);
49 if (singleCam_algo_handle)
50 ret = singleCam_algo_handle->setAttrib(attr);
51 }
52 }
53 #else
54 return XCAM_RETURN_ERROR_FAILED;
55 #endif
56 } else {
57 RkAiqAccmHandleInt* algo_handle =
58 algoHandle<RkAiqAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
59
60 if (algo_handle) {
61 return algo_handle->setAttrib(attr);
62 }
63 }
64
65 return (ret);
66 }
67
rk_aiq_user_api2_accm_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_attrib_t * attr)68 XCamReturn rk_aiq_user_api2_accm_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
69 rk_aiq_ccm_attrib_t* attr)
70 {
71 RKAIQ_API_SMART_LOCK(sys_ctx);
72 XCamReturn ret = XCAM_RETURN_NO_ERROR;
73
74 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
75 #ifdef RKAIQ_ENABLE_CAMGROUP
76 RkAiqCamGroupAccmHandleInt* algo_handle =
77 camgroupAlgoHandle<RkAiqCamGroupAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
78
79 if (algo_handle) {
80 return algo_handle->getAttrib(attr);
81 } else {
82 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
83 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
84 if (!camCtx)
85 continue;
86
87 RkAiqAccmHandleInt* singleCam_algo_handle =
88 algoHandle<RkAiqAccmHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACCM);
89 if (singleCam_algo_handle)
90 ret = singleCam_algo_handle->getAttrib(attr);
91 }
92 }
93 #else
94 return XCAM_RETURN_ERROR_FAILED;
95 #endif
96 } else {
97 RkAiqAccmHandleInt* algo_handle =
98 algoHandle<RkAiqAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
99
100 if (algo_handle) {
101 return algo_handle->getAttrib(attr);
102 }
103 }
104
105 return (ret);
106 }
107 #else
108
rk_aiq_user_api2_accm_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_ccm_attrib_t * attr)109 XCamReturn rk_aiq_user_api2_accm_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
110 const rk_aiq_ccm_attrib_t* attr)
111 {
112 return XCAM_RETURN_ERROR_UNKNOWN;
113 }
114
rk_aiq_user_api2_accm_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_attrib_t * attr)115 XCamReturn rk_aiq_user_api2_accm_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
116 rk_aiq_ccm_attrib_t* attr)
117 {
118 return XCAM_RETURN_ERROR_UNKNOWN;
119 }
120 #endif
121
122 #if RKAIQ_HAVE_CCM_V2
rk_aiq_user_api2_accm_v2_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_ccm_v2_attrib_t * attr)123 XCamReturn rk_aiq_user_api2_accm_v2_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
124 const rk_aiq_ccm_v2_attrib_t* attr)
125 {
126 XCamReturn ret = XCAM_RETURN_NO_ERROR;
127 CHECK_USER_API_ENABLE2(sys_ctx);
128 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ACCM);
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 RkAiqCamGroupAccmHandleInt* algo_handle =
134 camgroupAlgoHandle<RkAiqCamGroupAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
135
136 if (algo_handle) {
137 return algo_handle->setAttribV2(attr);
138 } else {
139 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
140 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
141 if (!camCtx)
142 continue;
143
144 RkAiqAccmHandleInt* singleCam_algo_handle =
145 algoHandle<RkAiqAccmHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACCM);
146 if (singleCam_algo_handle)
147 ret = singleCam_algo_handle->setAttribV2(attr);
148 }
149 }
150 #else
151 return XCAM_RETURN_ERROR_FAILED;
152 #endif
153 } else {
154 RkAiqAccmHandleInt* algo_handle =
155 algoHandle<RkAiqAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
156
157 if (algo_handle) {
158 return algo_handle->setAttribV2(attr);
159 }
160 }
161
162 return (ret);
163 }
164
rk_aiq_user_api2_accm_v2_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_v2_attrib_t * attr)165 XCamReturn rk_aiq_user_api2_accm_v2_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
166 rk_aiq_ccm_v2_attrib_t* attr)
167 {
168 RKAIQ_API_SMART_LOCK(sys_ctx);
169 XCamReturn ret = XCAM_RETURN_NO_ERROR;
170
171 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
172 #ifdef RKAIQ_ENABLE_CAMGROUP
173 RkAiqCamGroupAccmHandleInt* algo_handle =
174 camgroupAlgoHandle<RkAiqCamGroupAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
175
176 if (algo_handle) {
177 return algo_handle->getAttribV2(attr);
178 } else {
179 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
180 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
181 if (!camCtx)
182 continue;
183
184 RkAiqAccmHandleInt* singleCam_algo_handle =
185 algoHandle<RkAiqAccmHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACCM);
186 if (singleCam_algo_handle)
187 ret = singleCam_algo_handle->getAttribV2(attr);
188 }
189 }
190 #else
191 return XCAM_RETURN_ERROR_FAILED;
192 #endif
193 } else {
194 RkAiqAccmHandleInt* algo_handle =
195 algoHandle<RkAiqAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
196
197 if (algo_handle) {
198 return algo_handle->getAttribV2(attr);
199 }
200 }
201
202 return (ret);
203 }
204 #else
205
rk_aiq_user_api2_accm_v2_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const rk_aiq_ccm_v2_attrib_t * attr)206 XCamReturn rk_aiq_user_api2_accm_v2_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
207 const rk_aiq_ccm_v2_attrib_t* attr)
208 {
209 return XCAM_RETURN_ERROR_UNKNOWN;
210 }
211
rk_aiq_user_api2_accm_v2_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_v2_attrib_t * attr)212 XCamReturn rk_aiq_user_api2_accm_v2_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
213 rk_aiq_ccm_v2_attrib_t* attr)
214 {
215 return XCAM_RETURN_ERROR_UNKNOWN;
216 }
217 #endif
218
219 #if RKAIQ_HAVE_CCM_V1 || RKAIQ_HAVE_CCM_V2
rk_aiq_user_api2_accm_QueryCcmInfo(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_querry_info_t * ccm_querry_info)220 XCamReturn rk_aiq_user_api2_accm_QueryCcmInfo(const rk_aiq_sys_ctx_t* sys_ctx,
221 rk_aiq_ccm_querry_info_t* ccm_querry_info)
222 {
223 RKAIQ_API_SMART_LOCK(sys_ctx);
224
225 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
226 #ifdef RKAIQ_ENABLE_CAMGROUP
227 RkAiqCamGroupAccmHandleInt* algo_handle =
228 camgroupAlgoHandle<RkAiqCamGroupAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
229
230 if (algo_handle) {
231 return algo_handle->queryCcmInfo(ccm_querry_info);
232 } else {
233 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
234 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
235 if (!camCtx)
236 continue;
237
238 RkAiqAccmHandleInt* singleCam_algo_handle =
239 algoHandle<RkAiqAccmHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ACCM);
240 if (singleCam_algo_handle)
241 return singleCam_algo_handle->queryCcmInfo(ccm_querry_info);
242 }
243 }
244 #else
245 return XCAM_RETURN_ERROR_FAILED;
246 #endif
247 } else {
248 RkAiqAccmHandleInt* algo_handle =
249 algoHandle<RkAiqAccmHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ACCM);
250
251 if (algo_handle) {
252 return algo_handle->queryCcmInfo(ccm_querry_info);
253 }
254 }
255
256 return XCAM_RETURN_NO_ERROR;
257 }
258 #else
rk_aiq_user_api2_accm_QueryCcmInfo(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_querry_info_t * ccm_querry_info)259 XCamReturn rk_aiq_user_api2_accm_QueryCcmInfo(const rk_aiq_sys_ctx_t* sys_ctx,
260 rk_aiq_ccm_querry_info_t* ccm_querry_info)
261 {
262 return XCAM_RETURN_ERROR_UNKNOWN;
263 }
264 #endif
265
266
267