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_amerge.h"
17
18 #include "RkAiqCamGroupHandleInt.h"
19 #include "algo_handlers/RkAiqAmergeHandle.h"
20
21 RKAIQ_BEGIN_DECLARE
22
23 #ifdef RK_SIMULATOR_HW
24 #define CHECK_USER_API_ENABLE
25 #endif
26
rk_aiq_user_api2_amerge_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,amerge_attrib_t attr)27 XCamReturn rk_aiq_user_api2_amerge_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
28 amerge_attrib_t attr) {
29 XCamReturn ret = XCAM_RETURN_NO_ERROR;
30 #if RKAIQ_HAVE_MERGE_V10
31 mergeAttrV10_t attr_v10;
32 memset(&attr_v10, 0x0, sizeof(mergeAttrV10_t));
33
34 attr_v10.sync.sync_mode = attr.sync.sync_mode;
35 attr_v10.sync.done = attr.sync.done;
36 if (attr.attrV21.opMode == MERGE_OPMODE_API_OFF) attr_v10.opMode = MERGE_OPMODE_AUTO;
37 if (attr.attrV21.opMode == MERGE_OPMODE_MANU) attr_v10.opMode = MERGE_OPMODE_MANUAL;
38 attr_v10.stManual.OECurve = attr.attrV21.stManual.OECurve;
39 attr_v10.stManual.MDCurve = attr.attrV21.stManual.MDCurve;
40 ret = rk_aiq_user_api2_amerge_v10_SetAttrib(sys_ctx, &attr_v10);
41 #endif
42 #if RKAIQ_HAVE_MERGE_V11
43 mergeAttrV11_t attr_v11;
44 memset(&attr_v11, 0x0, sizeof(mergeAttrV11_t));
45
46 attr_v11.sync.sync_mode = attr.sync.sync_mode;
47 attr_v11.sync.done = attr.sync.done;
48 if (attr.attrV30.opMode == MERGE_OPMODE_API_OFF) attr_v11.opMode = MERGE_OPMODE_AUTO;
49 if (attr.attrV30.opMode == MERGE_OPMODE_MANU) attr_v11.opMode = MERGE_OPMODE_MANUAL;
50 attr_v11.stManual.BaseFrm = attr.attrV30.stManual.BaseFrm;
51 attr_v11.stManual.LongFrmModeData.OECurve = attr.attrV30.stManual.LongFrmModeData.OECurve;
52 attr_v11.stManual.LongFrmModeData.MDCurve = attr.attrV30.stManual.LongFrmModeData.MDCurve;
53 attr_v11.stManual.ShortFrmModeData.OECurve = attr.attrV30.stManual.ShortFrmModeData.OECurve;
54 attr_v11.stManual.ShortFrmModeData.MDCurve = attr.attrV30.stManual.ShortFrmModeData.MDCurve;
55 ret = rk_aiq_user_api2_amerge_v11_SetAttrib(sys_ctx, &attr_v11);
56 #endif
57 return ret;
58 }
rk_aiq_user_api2_amerge_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,amerge_attrib_t * attr)59 XCamReturn rk_aiq_user_api2_amerge_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
60 amerge_attrib_t* attr) {
61 XCamReturn ret = XCAM_RETURN_NO_ERROR;
62 #if RKAIQ_HAVE_MERGE_V10
63 mergeAttrV10_t attr_v10;
64 memset(&attr_v10, 0x0, sizeof(mergeAttrV10_t));
65 ret = rk_aiq_user_api2_amerge_v10_GetAttrib(sys_ctx, &attr_v10);
66
67 attr->sync.sync_mode = attr_v10.sync.sync_mode;
68 attr->sync.done = attr_v10.sync.done;
69 if (attr_v10.opMode == MERGE_OPMODE_AUTO) attr->attrV21.opMode = MERGE_OPMODE_API_OFF;
70 if (attr_v10.opMode == MERGE_OPMODE_MANUAL) attr->attrV21.opMode = MERGE_OPMODE_MANU;
71 attr->attrV21.stManual.OECurve = attr_v10.stManual.OECurve;
72 attr->attrV21.stManual.MDCurve = attr_v10.stManual.MDCurve;
73 attr->attrV21.CtlInfo = attr_v10.Info;
74 #endif
75 #if RKAIQ_HAVE_MERGE_V11
76 mergeAttrV11_t attr_v11;
77 memset(&attr_v11, 0x0, sizeof(mergeAttrV11_t));
78 ret = rk_aiq_user_api2_amerge_v11_GetAttrib(sys_ctx, &attr_v11);
79
80 attr->sync.sync_mode = attr_v11.sync.sync_mode;
81 attr->sync.done = attr_v11.sync.done;
82 if (attr_v11.opMode == MERGE_OPMODE_AUTO) attr->attrV30.opMode = MERGE_OPMODE_API_OFF;
83 if (attr_v11.opMode == MERGE_OPMODE_MANUAL) attr->attrV30.opMode = MERGE_OPMODE_MANU;
84 attr->attrV30.stManual.BaseFrm = attr_v11.stManual.BaseFrm;
85 attr->attrV30.stManual.LongFrmModeData.OECurve = attr_v11.stManual.LongFrmModeData.OECurve;
86 attr->attrV30.stManual.LongFrmModeData.MDCurve = attr_v11.stManual.LongFrmModeData.MDCurve;
87 attr->attrV30.stManual.ShortFrmModeData.OECurve = attr_v11.stManual.ShortFrmModeData.OECurve;
88 attr->attrV30.stManual.ShortFrmModeData.MDCurve = attr_v11.stManual.ShortFrmModeData.MDCurve;
89 attr->attrV30.CtlInfo = attr_v11.Info;
90 #endif
91 return ret;
92 }
93
94 #if RKAIQ_HAVE_MERGE_V10
rk_aiq_user_api2_amerge_v10_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const mergeAttrV10_t * attr)95 XCamReturn rk_aiq_user_api2_amerge_v10_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
96 const mergeAttrV10_t* attr) {
97 CHECK_USER_API_ENABLE2(sys_ctx);
98 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AMERGE);
99
100 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
101 #ifdef RKAIQ_ENABLE_CAMGROUP
102
103 RkAiqCamGroupAmergeHandleInt* algo_handle =
104 camgroupAlgoHandle<RkAiqCamGroupAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
105
106 if (algo_handle) {
107 return algo_handle->setAttribV10(attr);
108 } else {
109 XCamReturn ret = XCAM_RETURN_NO_ERROR;
110 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
111 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
112 if (!camCtx)
113 continue;
114
115 RkAiqAmergeHandleInt* singleCam_algo_handle =
116 algoHandle<RkAiqAmergeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AMERGE);
117 if (singleCam_algo_handle) {
118 ret = singleCam_algo_handle->setAttribV10(attr);
119 if (ret != XCAM_RETURN_NO_ERROR) LOGE("%s returned: %d", __FUNCTION__, ret);
120 }
121 }
122 }
123 #else
124 return XCAM_RETURN_ERROR_FAILED;
125 #endif
126 } else {
127 RkAiqAmergeHandleInt* algo_handle =
128 algoHandle<RkAiqAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
129
130 if (algo_handle) {
131 return algo_handle->setAttribV10(attr);
132 }
133 }
134
135 return XCAM_RETURN_NO_ERROR;
136 }
137
rk_aiq_user_api2_amerge_v10_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,mergeAttrV10_t * attr)138 XCamReturn rk_aiq_user_api2_amerge_v10_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
139 mergeAttrV10_t* attr) {
140 RKAIQ_API_SMART_LOCK(sys_ctx);
141
142 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
143 #ifdef RKAIQ_ENABLE_CAMGROUP
144 RkAiqCamGroupAmergeHandleInt* algo_handle =
145 camgroupAlgoHandle<RkAiqCamGroupAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
146
147 if (algo_handle) {
148 return algo_handle->getAttribV10(attr);
149 } else {
150 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
151 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
152 if (!camCtx)
153 continue;
154
155 RkAiqAmergeHandleInt* singleCam_algo_handle =
156 algoHandle<RkAiqAmergeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AMERGE);
157 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV10(attr);
158 }
159 }
160 #else
161 return XCAM_RETURN_ERROR_FAILED;
162 #endif
163 } else {
164 RkAiqAmergeHandleInt* algo_handle =
165 algoHandle<RkAiqAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
166
167 if (algo_handle) {
168 return algo_handle->getAttribV10(attr);
169 }
170 }
171
172 return XCAM_RETURN_NO_ERROR;
173 }
174 #else
rk_aiq_user_api2_amerge_v10_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const mergeAttrV10_t * attr)175 XCamReturn rk_aiq_user_api2_amerge_v10_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
176 const mergeAttrV10_t* attr) {
177 return XCAM_RETURN_ERROR_UNKNOWN;
178 }
179
rk_aiq_user_api2_amerge_v10_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,mergeAttrV10_t * attr)180 XCamReturn rk_aiq_user_api2_amerge_v10_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
181 mergeAttrV10_t* attr) {
182 return XCAM_RETURN_ERROR_UNKNOWN;
183 }
184
185 #endif
186
187 #if RKAIQ_HAVE_MERGE_V11
rk_aiq_user_api2_amerge_v11_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const mergeAttrV11_t * attr)188 XCamReturn rk_aiq_user_api2_amerge_v11_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
189 const mergeAttrV11_t* attr) {
190 CHECK_USER_API_ENABLE2(sys_ctx);
191 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AMERGE);
192 XCamReturn ret = XCAM_RETURN_NO_ERROR;
193
194 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
195 #ifdef RKAIQ_ENABLE_CAMGROUP
196 RkAiqCamGroupAmergeHandleInt* algo_handle =
197 camgroupAlgoHandle<RkAiqCamGroupAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
198
199 if (algo_handle) {
200 return algo_handle->setAttribV11(attr);
201 } else {
202 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
203 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
204 if (!camCtx) continue;
205
206 RkAiqAmergeHandleInt* singleCam_algo_handle =
207 algoHandle<RkAiqAmergeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AMERGE);
208 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttribV11(attr);
209 }
210 }
211 #else
212 return XCAM_RETURN_ERROR_FAILED;
213 #endif
214 } else {
215 RkAiqAmergeHandleInt* algo_handle =
216 algoHandle<RkAiqAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
217
218 if (algo_handle) {
219 return algo_handle->setAttribV11(attr);
220 }
221 }
222
223 return ret;
224 }
225
rk_aiq_user_api2_amerge_v11_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,mergeAttrV11_t * attr)226 XCamReturn rk_aiq_user_api2_amerge_v11_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
227 mergeAttrV11_t* attr) {
228 RKAIQ_API_SMART_LOCK(sys_ctx);
229
230 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
231 #ifdef RKAIQ_ENABLE_CAMGROUP
232 RkAiqCamGroupAmergeHandleInt* algo_handle =
233 camgroupAlgoHandle<RkAiqCamGroupAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
234
235 if (algo_handle) {
236 return algo_handle->getAttribV11(attr);
237 } else {
238 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
239 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
240 if (!camCtx) continue;
241
242 RkAiqAmergeHandleInt* singleCam_algo_handle =
243 algoHandle<RkAiqAmergeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AMERGE);
244 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV11(attr);
245 }
246 }
247 #else
248 return XCAM_RETURN_ERROR_FAILED;
249 #endif
250 } else {
251 RkAiqAmergeHandleInt* algo_handle =
252 algoHandle<RkAiqAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
253
254 if (algo_handle) {
255 return algo_handle->getAttribV11(attr);
256 }
257 }
258
259 return XCAM_RETURN_NO_ERROR;
260 }
261 #else
rk_aiq_user_api2_amerge_v11_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const mergeAttrV11_t * attr)262 XCamReturn rk_aiq_user_api2_amerge_v11_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
263 const mergeAttrV11_t* attr) {
264 return XCAM_RETURN_ERROR_UNKNOWN;
265 }
266
rk_aiq_user_api2_amerge_v11_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,mergeAttrV11_t * attr)267 XCamReturn rk_aiq_user_api2_amerge_v11_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
268 mergeAttrV11_t* attr) {
269 return XCAM_RETURN_ERROR_UNKNOWN;
270 }
271
272 #endif
273
274 #if RKAIQ_HAVE_MERGE_V12
rk_aiq_user_api2_amerge_v12_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const mergeAttrV12_t * attr)275 XCamReturn rk_aiq_user_api2_amerge_v12_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
276 const mergeAttrV12_t* attr) {
277 CHECK_USER_API_ENABLE2(sys_ctx);
278 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_AMERGE);
279 XCamReturn ret = XCAM_RETURN_NO_ERROR;
280
281 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
282 #ifdef RKAIQ_ENABLE_CAMGROUP
283 RkAiqCamGroupAmergeHandleInt* algo_handle =
284 camgroupAlgoHandle<RkAiqCamGroupAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
285
286 if (algo_handle) {
287 return algo_handle->setAttribV12(attr);
288 } else {
289 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
290 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
291 if (!camCtx) continue;
292
293 RkAiqAmergeHandleInt* singleCam_algo_handle =
294 algoHandle<RkAiqAmergeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AMERGE);
295 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttribV12(attr);
296 }
297 }
298 #else
299 return XCAM_RETURN_ERROR_FAILED;
300 #endif
301 } else {
302 RkAiqAmergeHandleInt* algo_handle =
303 algoHandle<RkAiqAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
304
305 if (algo_handle) {
306 return algo_handle->setAttribV12(attr);
307 }
308 }
309
310 return ret;
311 }
312
rk_aiq_user_api2_amerge_v12_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,mergeAttrV12_t * attr)313 XCamReturn rk_aiq_user_api2_amerge_v12_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
314 mergeAttrV12_t* attr) {
315 RKAIQ_API_SMART_LOCK(sys_ctx);
316
317 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
318 #ifdef RKAIQ_ENABLE_CAMGROUP
319 RkAiqCamGroupAmergeHandleInt* algo_handle =
320 camgroupAlgoHandle<RkAiqCamGroupAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
321
322 if (algo_handle) {
323 return algo_handle->getAttribV12(attr);
324 } else {
325 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
326 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
327 if (!camCtx) continue;
328
329 RkAiqAmergeHandleInt* singleCam_algo_handle =
330 algoHandle<RkAiqAmergeHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_AMERGE);
331 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV12(attr);
332 }
333 }
334 #else
335 return XCAM_RETURN_ERROR_FAILED;
336 #endif
337 } else {
338 RkAiqAmergeHandleInt* algo_handle =
339 algoHandle<RkAiqAmergeHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_AMERGE);
340
341 if (algo_handle) {
342 return algo_handle->getAttribV12(attr);
343 }
344 }
345
346 return XCAM_RETURN_NO_ERROR;
347 }
348 #else
rk_aiq_user_api2_amerge_v12_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const mergeAttrV12_t * attr)349 XCamReturn rk_aiq_user_api2_amerge_v12_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
350 const mergeAttrV12_t* attr) {
351 return XCAM_RETURN_ERROR_UNKNOWN;
352 }
353
rk_aiq_user_api2_amerge_v12_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,mergeAttrV12_t * attr)354 XCamReturn rk_aiq_user_api2_amerge_v12_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
355 mergeAttrV12_t* attr) {
356 return XCAM_RETURN_ERROR_UNKNOWN;
357 }
358
359 #endif
360
361 RKAIQ_END_DECLARE
362