1 /*
2 * Copyright (c) 2021 Rockchip Corporation
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 */
17
18 #include "RkAiqCalibDbV2.h"
19 #include "RkAiqUapitypes.h"
20 #include "cJSON.h"
21 #include "cJSON_Utils.h"
22 #include "j2s.h"
23 #include "stdlib.h"
24 #include "string.h"
25 #include "uAPI2/rk_aiq_user_api2_wrapper.h"
26 #include "uAPI2/rk_aiq_user_api2_sysctl.h"
27 #include "rk_aiq_user_api_sysctl.h"
28 #include "uAPI2/rk_aiq_user_api2_ae.h"
29 #include "uAPI2/rk_aiq_user_api2_imgproc.h"
30 #include "uAPI/include/rk_aiq_user_api_sysctl.h"
31 #include "uAPI2/rk_aiq_user_api2_acsm.h"
32 #include "uAPI2/rk_aiq_user_api2_acgc.h"
33 #include "uAPI2/rk_aiq_user_api2_ablc_v32.h"
34 #include "uAPI2/rk_aiq_user_api2_a3dlut.h"
35 #include "uAPI/rk_aiq_api_private.h"
36
37 static camgroup_uapi_t last_camindex;
38
rk_aiq_uapi_sysctl_swWorkingModeDyn2(const rk_aiq_sys_ctx_t * ctx,work_mode_t * mode)39 int rk_aiq_uapi_sysctl_swWorkingModeDyn2(const rk_aiq_sys_ctx_t *ctx,
40 work_mode_t *mode) {
41 return rk_aiq_uapi_sysctl_swWorkingModeDyn(ctx, mode->mode);
42 }
43
rk_aiq_uapi_sysctl_getWorkingModeDyn(const rk_aiq_sys_ctx_t * ctx,work_mode_t * mode)44 int rk_aiq_uapi_sysctl_getWorkingModeDyn(const rk_aiq_sys_ctx_t *ctx,
45 work_mode_t *mode) {
46 return rk_aiq_uapi2_sysctl_getWorkingMode(ctx, &mode->mode);
47 }
48
rk_aiq_uapi2_setWBMode2(rk_aiq_sys_ctx_t * ctx,uapi_wb_mode_t * mode)49 int rk_aiq_uapi2_setWBMode2(rk_aiq_sys_ctx_t *ctx, uapi_wb_mode_t *mode) {
50 return rk_aiq_uapi2_setWBMode(ctx, mode->mode);
51 }
52
rk_aiq_uapi2_getWBMode2(rk_aiq_sys_ctx_t * ctx,uapi_wb_mode_t * mode)53 int rk_aiq_uapi2_getWBMode2(rk_aiq_sys_ctx_t *ctx, uapi_wb_mode_t *mode) {
54 return rk_aiq_uapi2_getWBMode(ctx, &mode->mode);
55 }
56
rk_aiq_user_api2_set_scene(const rk_aiq_sys_ctx_t * sys_ctx,aiq_scene_t * scene)57 int rk_aiq_user_api2_set_scene(const rk_aiq_sys_ctx_t* sys_ctx, aiq_scene_t* scene)
58 {
59 return rk_aiq_uapi_sysctl_switch_scene(sys_ctx, scene->main_scene, scene->sub_scene);
60 }
61
rk_aiq_user_api2_get_scene(const rk_aiq_sys_ctx_t * sys_ctx,aiq_scene_t * scene)62 int rk_aiq_user_api2_get_scene(const rk_aiq_sys_ctx_t* sys_ctx, aiq_scene_t* scene)
63 {
64 (void)sys_ctx;
65 scene->main_scene = strdup("normal");
66 scene->sub_scene = strdup("day");
67
68 return 0;
69 }
70
rk_aiq_uapi_get_ae_hwstats(const rk_aiq_sys_ctx_t * sys_ctx,uapi_ae_hwstats_t * ae_hwstats)71 int rk_aiq_uapi_get_ae_hwstats(const rk_aiq_sys_ctx_t* sys_ctx, uapi_ae_hwstats_t* ae_hwstats)
72 {
73 rk_aiq_isp_stats_t isp_stats;
74
75 #if RKAIQ_ENABLE_CAMGROUP
76 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
77 LOGE("Can't read 3A stats for group ctx!");
78 return XCAM_RETURN_ERROR_PARAM;
79 }
80 #endif
81
82 rk_aiq_uapi_sysctl_get3AStats(sys_ctx, &isp_stats);
83
84 memcpy(ae_hwstats, &isp_stats.aec_stats.ae_data, sizeof(uapi_ae_hwstats_t));
85
86 return 0;
87 }
88
rk_aiq_uapi_get_awb_stat(const rk_aiq_sys_ctx_t * sys_ctx,rk_tool_awb_stat_res2_v30_t * awb_stat)89 int rk_aiq_uapi_get_awb_stat(const rk_aiq_sys_ctx_t* sys_ctx, rk_tool_awb_stat_res2_v30_t* awb_stat)
90 {
91 rk_aiq_isp_stats_t isp_stats;
92
93 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
94 LOGE("Can't read 3A stats for group ctx!");
95 return XCAM_RETURN_ERROR_PARAM;
96 }
97
98 rk_aiq_uapi_sysctl_get3AStats(sys_ctx, &isp_stats);
99 memcpy(awb_stat, &isp_stats.awb_stats_v3x, sizeof(rk_aiq_isp_awb_stats2_v3x_t));
100
101 return 0;
102 }
rk_aiq_uapi_get_awbV21_stat(const rk_aiq_sys_ctx_t * sys_ctx,rk_tool_awb_stat_res2_v201_t * awb_stat)103 int rk_aiq_uapi_get_awbV21_stat(const rk_aiq_sys_ctx_t* sys_ctx, rk_tool_awb_stat_res2_v201_t* awb_stat)
104 {
105 rk_aiq_isp_stats_t isp_stats;
106
107 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
108 LOGE("Can't read 3A stats for group ctx!");
109 return XCAM_RETURN_ERROR_PARAM;
110 }
111
112 rk_aiq_uapi_sysctl_get3AStats(sys_ctx, &isp_stats);
113
114 memcpy(awb_stat, &isp_stats.awb_stats_v21, sizeof(rk_aiq_awb_stat_res2_v201_t));
115
116 return 0;
117 }
rk_aiq_uapi_get_awbV32_stat(const rk_aiq_sys_ctx_t * sys_ctx,rk_tool_isp_awb_stats_v32_t * awb_stat)118 int rk_aiq_uapi_get_awbV32_stat(const rk_aiq_sys_ctx_t* sys_ctx, rk_tool_isp_awb_stats_v32_t* awb_stat)
119 {
120 rk_aiq_isp_stats_t isp_stats;
121
122 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
123 LOGE("Can't read 3A stats for group ctx!");
124 return XCAM_RETURN_ERROR_PARAM;
125 }
126
127 rk_aiq_uapi_sysctl_get3AStats(sys_ctx, &isp_stats);
128 memcpy(awb_stat->light, isp_stats.awb_stats_v32.light, sizeof(awb_stat->light));
129 memcpy(awb_stat->blockResult, isp_stats.awb_stats_v32.blockResult, sizeof(isp_stats.awb_stats_v32.blockResult));
130 memcpy(awb_stat->WpNo2, isp_stats.awb_stats_v32.WpNo2, sizeof(awb_stat->WpNo2));
131 memcpy(awb_stat->WpNoHist, isp_stats.awb_stats_v32.WpNoHist, sizeof(awb_stat->WpNoHist));
132 memcpy(awb_stat->excWpRangeResult, isp_stats.awb_stats_v32.excWpRangeResult, sizeof(awb_stat->excWpRangeResult));
133
134 return 0;
135 }
136
rk_aiq_get_adpcc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,Adpcc_Manual_Attr_t * manual)137 XCamReturn rk_aiq_get_adpcc_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
138 Adpcc_Manual_Attr_t *manual) {
139 rk_aiq_dpcc_attrib_V20_t adpcc_attr;
140
141 memset(&adpcc_attr, 0, sizeof(rk_aiq_dpcc_attrib_V20_t));
142 rk_aiq_user_api2_adpcc_GetAttrib(sys_ctx, &adpcc_attr);
143 memcpy(manual, &adpcc_attr.stManual, sizeof(Adpcc_Manual_Attr_t));
144
145 return XCAM_RETURN_NO_ERROR;
146 }
147
rk_aiq_set_adpcc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,Adpcc_Manual_Attr_t * manual)148 XCamReturn rk_aiq_set_adpcc_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
149 Adpcc_Manual_Attr_t *manual) {
150 rk_aiq_dpcc_attrib_V20_t adpcc_attr;
151
152 memset(&adpcc_attr, 0, sizeof(rk_aiq_dpcc_attrib_V20_t));
153 rk_aiq_user_api2_adpcc_GetAttrib(sys_ctx, &adpcc_attr);
154 memcpy(&adpcc_attr.stManual, manual, sizeof(Adpcc_Manual_Attr_t));
155 rk_aiq_user_api2_adpcc_SetAttrib(sys_ctx, &adpcc_attr);
156
157 return XCAM_RETURN_NO_ERROR;
158 }
159
160 #if RKAIQ_HAVE_MERGE_V10
rk_aiq_user_api2_amerge_v10_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,uapiMergeCurrCtlData_t * merge_info)161 XCamReturn rk_aiq_user_api2_amerge_v10_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
162 uapiMergeCurrCtlData_t* merge_info) {
163 XCamReturn ret = XCAM_RETURN_NO_ERROR;
164
165 mergeAttrV10_t merge_attr_v10;
166 ret = rk_aiq_user_api2_amerge_v10_GetAttrib(sys_ctx, &merge_attr_v10);
167 *merge_info = merge_attr_v10.Info;
168
169 return ret;
170 }
171
rk_aiq_set_amerge_v10_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mMergeAttrV10_t * manual)172 XCamReturn rk_aiq_set_amerge_v10_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
173 mMergeAttrV10_t* manual) {
174 XCamReturn ret = XCAM_RETURN_NO_ERROR;
175
176 mergeAttrV10_t merge_attr_v10;
177 ret = rk_aiq_user_api2_amerge_v10_GetAttrib(sys_ctx, &merge_attr_v10);
178 merge_attr_v10.stManual = *manual;
179 ret = rk_aiq_user_api2_amerge_v10_SetAttrib(sys_ctx, &merge_attr_v10);
180
181 return ret;
182 }
183
rk_aiq_get_amerge_v10_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mMergeAttrV10_t * manual)184 XCamReturn rk_aiq_get_amerge_v10_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
185 mMergeAttrV10_t* manual) {
186 XCamReturn ret = XCAM_RETURN_NO_ERROR;
187
188 mergeAttrV10_t merge_attr_v10;
189 ret = rk_aiq_user_api2_amerge_v10_GetAttrib(sys_ctx, &merge_attr_v10);
190 *manual = merge_attr_v10.stManual;
191
192 return ret;
193 }
194 #endif
195 #if RKAIQ_HAVE_MERGE_V11
rk_aiq_user_api2_amerge_v11_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,uapiMergeCurrCtlData_t * merge_info)196 XCamReturn rk_aiq_user_api2_amerge_v11_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
197 uapiMergeCurrCtlData_t* merge_info) {
198 XCamReturn ret = XCAM_RETURN_NO_ERROR;
199
200 mergeAttrV11_t merge_attr_v11;
201 ret = rk_aiq_user_api2_amerge_v11_GetAttrib(sys_ctx, &merge_attr_v11);
202 *merge_info = merge_attr_v11.Info;
203
204 return ret;
205 }
206
rk_aiq_set_amerge_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mMergeAttrV11_t * manual)207 XCamReturn rk_aiq_set_amerge_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
208 mMergeAttrV11_t* manual) {
209 XCamReturn ret = XCAM_RETURN_NO_ERROR;
210
211 mergeAttrV11_t merge_attr_v11;
212 ret = rk_aiq_user_api2_amerge_v11_GetAttrib(sys_ctx, &merge_attr_v11);
213 merge_attr_v11.stManual = *manual;
214 ret = rk_aiq_user_api2_amerge_v11_SetAttrib(sys_ctx, &merge_attr_v11);
215
216 return ret;
217 }
218
rk_aiq_get_amerge_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mMergeAttrV11_t * manual)219 XCamReturn rk_aiq_get_amerge_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
220 mMergeAttrV11_t* manual) {
221 XCamReturn ret = XCAM_RETURN_NO_ERROR;
222
223 mergeAttrV11_t merge_attr_v11;
224 ret = rk_aiq_user_api2_amerge_v11_GetAttrib(sys_ctx, &merge_attr_v11);
225 *manual = merge_attr_v11.stManual;
226
227 return ret;
228 }
229 #endif
230 #if RKAIQ_HAVE_MERGE_V12
rk_aiq_user_api2_amerge_v12_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,uapiMergeCurrCtlData_t * merge_info)231 XCamReturn rk_aiq_user_api2_amerge_v12_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
232 uapiMergeCurrCtlData_t* merge_info) {
233 XCamReturn ret = XCAM_RETURN_NO_ERROR;
234
235 mergeAttrV12_t merge_attr_v12;
236 ret = rk_aiq_user_api2_amerge_v12_GetAttrib(sys_ctx, &merge_attr_v12);
237 *merge_info = merge_attr_v12.Info;
238
239 return ret;
240 }
241
rk_aiq_set_amerge_v12_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mMergeAttrV12_t * manual)242 XCamReturn rk_aiq_set_amerge_v12_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
243 mMergeAttrV12_t* manual) {
244 XCamReturn ret = XCAM_RETURN_NO_ERROR;
245
246 mergeAttrV12_t merge_attr_v12;
247 ret = rk_aiq_user_api2_amerge_v12_GetAttrib(sys_ctx, &merge_attr_v12);
248 merge_attr_v12.stManual = *manual;
249 ret = rk_aiq_user_api2_amerge_v12_SetAttrib(sys_ctx, &merge_attr_v12);
250
251 return ret;
252 }
253
rk_aiq_get_amerge_v12_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mMergeAttrV12_t * manual)254 XCamReturn rk_aiq_get_amerge_v12_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
255 mMergeAttrV12_t* manual) {
256 XCamReturn ret = XCAM_RETURN_NO_ERROR;
257
258 mergeAttrV12_t merge_attr_v12;
259 ret = rk_aiq_user_api2_amerge_v12_GetAttrib(sys_ctx, &merge_attr_v12);
260 *manual = merge_attr_v12.stManual;
261
262 return ret;
263 }
264 #endif
265
266 #if RKAIQ_HAVE_DRC_V10
rk_aiq_user_api2_adrc_v10_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,DrcInfoV10_t * drc_info)267 XCamReturn rk_aiq_user_api2_adrc_v10_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
268 DrcInfoV10_t* drc_info) {
269 XCamReturn ret = XCAM_RETURN_NO_ERROR;
270
271 drcAttrV10_t drc_attr_v10;
272 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(sys_ctx, &drc_attr_v10);
273 *drc_info = drc_attr_v10.Info;
274
275 return ret;
276 }
277
rk_aiq_set_adrc_v10_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_V10_t * manual)278 XCamReturn rk_aiq_set_adrc_v10_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
279 mdrcAttr_V10_t* manual) {
280 XCamReturn ret = XCAM_RETURN_NO_ERROR;
281
282 drcAttrV10_t drc_attr_v10;
283 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(sys_ctx, &drc_attr_v10);
284 drc_attr_v10.stManual = *manual;
285 ret = rk_aiq_user_api2_adrc_v10_SetAttrib(sys_ctx, &drc_attr_v10);
286
287 return ret;
288 }
rk_aiq_get_adrc_v10_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_V10_t * manual)289 XCamReturn rk_aiq_get_adrc_v10_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
290 mdrcAttr_V10_t* manual) {
291 XCamReturn ret = XCAM_RETURN_NO_ERROR;
292
293 drcAttrV10_t drc_attr_v10;
294 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(sys_ctx, &drc_attr_v10);
295 *manual = drc_attr_v10.stManual;
296
297 return ret;
298 }
299 #endif
300 #if RKAIQ_HAVE_DRC_V11
rk_aiq_user_api2_adrc_v11_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,DrcInfoV11_t * drc_info)301 XCamReturn rk_aiq_user_api2_adrc_v11_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
302 DrcInfoV11_t* drc_info) {
303 XCamReturn ret = XCAM_RETURN_NO_ERROR;
304
305 drcAttrV11_t drc_attr_v11;
306 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(sys_ctx, &drc_attr_v11);
307 *drc_info = drc_attr_v11.Info;
308
309 return ret;
310 }
311
rk_aiq_set_adrc_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_V11_t * manual)312 XCamReturn rk_aiq_set_adrc_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
313 mdrcAttr_V11_t* manual) {
314 XCamReturn ret = XCAM_RETURN_NO_ERROR;
315
316 drcAttrV11_t drc_attr_v11;
317 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(sys_ctx, &drc_attr_v11);
318 drc_attr_v11.stManual = *manual;
319 ret = rk_aiq_user_api2_adrc_v11_SetAttrib(sys_ctx, &drc_attr_v11);
320
321 return ret;
322 }
rk_aiq_get_adrc_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_V11_t * manual)323 XCamReturn rk_aiq_get_adrc_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
324 mdrcAttr_V11_t* manual) {
325 XCamReturn ret = XCAM_RETURN_NO_ERROR;
326
327 drcAttrV11_t drc_attr_v11;
328 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(sys_ctx, &drc_attr_v11);
329 *manual = drc_attr_v11.stManual;
330
331 return ret;
332 }
333 #endif
334 #if RKAIQ_HAVE_DRC_V12
rk_aiq_user_api2_adrc_v12_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,DrcInfoV12_t * drc_info)335 XCamReturn rk_aiq_user_api2_adrc_v12_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
336 DrcInfoV12_t* drc_info) {
337 XCamReturn ret = XCAM_RETURN_NO_ERROR;
338
339 drcAttrV12_t drc_attr_v12;
340 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(sys_ctx, &drc_attr_v12);
341 *drc_info = drc_attr_v12.Info;
342
343 return ret;
344 }
345
rk_aiq_set_adrc_v12_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_V12_t * manual)346 XCamReturn rk_aiq_set_adrc_v12_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
347 mdrcAttr_V12_t* manual) {
348 XCamReturn ret = XCAM_RETURN_NO_ERROR;
349
350 drcAttrV12_t drc_attr_v12;
351 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(sys_ctx, &drc_attr_v12);
352 drc_attr_v12.stManual = *manual;
353 ret = rk_aiq_user_api2_adrc_v12_SetAttrib(sys_ctx, &drc_attr_v12);
354
355 return ret;
356 }
rk_aiq_get_adrc_v12_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_V12_t * manual)357 XCamReturn rk_aiq_get_adrc_v12_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
358 mdrcAttr_V12_t* manual) {
359 XCamReturn ret = XCAM_RETURN_NO_ERROR;
360
361 drcAttrV12_t drc_attr_v12;
362 ret = rk_aiq_user_api2_adrc_v12_GetAttrib(sys_ctx, &drc_attr_v12);
363 *manual = drc_attr_v12.stManual;
364
365 return ret;
366 }
367 #endif
368 #if RKAIQ_HAVE_DRC_V12_LITE
rk_aiq_user_api2_adrc_v12_lite_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,DrcInfoV12Lite_t * drc_info)369 XCamReturn rk_aiq_user_api2_adrc_v12_lite_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
370 DrcInfoV12Lite_t* drc_info) {
371 XCamReturn ret = XCAM_RETURN_NO_ERROR;
372
373 drcAttrV12Lite_t drc_attr_v12_lite;
374 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(sys_ctx, &drc_attr_v12_lite);
375 *drc_info = drc_attr_v12_lite.Info;
376
377 return ret;
378 }
379
rk_aiq_set_adrc_v12_lite_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_v12_lite_t * manual)380 XCamReturn rk_aiq_set_adrc_v12_lite_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
381 mdrcAttr_v12_lite_t* manual) {
382 XCamReturn ret = XCAM_RETURN_NO_ERROR;
383
384 drcAttrV12Lite_t drc_attr_v12_lite;
385 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(sys_ctx, &drc_attr_v12_lite);
386 drc_attr_v12_lite.stManual = *manual;
387 ret = rk_aiq_user_api2_adrc_v12_lite_SetAttrib(sys_ctx, &drc_attr_v12_lite);
388
389 return ret;
390 }
rk_aiq_get_adrc_v12_lite_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mdrcAttr_v12_lite_t * manual)391 XCamReturn rk_aiq_get_adrc_v12_lite_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
392 mdrcAttr_v12_lite_t* manual) {
393 XCamReturn ret = XCAM_RETURN_NO_ERROR;
394
395 drcAttrV12Lite_t drc_attr_v12_lite;
396 ret = rk_aiq_user_api2_adrc_v12_lite_GetAttrib(sys_ctx, &drc_attr_v12_lite);
397 *manual = drc_attr_v12_lite.stManual;
398
399 return ret;
400 }
401 #endif
402
403 #if RKAIQ_HAVE_GAMMA_V10
rk_aiq_set_agamma_v10_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,AgammaApiManualV10_t * manual)404 XCamReturn rk_aiq_set_agamma_v10_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
405 AgammaApiManualV10_t* manual) {
406 XCamReturn ret = XCAM_RETURN_NO_ERROR;
407
408 rk_aiq_gamma_v10_attr_t gamma_attr_v10;
409 ret = rk_aiq_user_api2_agamma_v10_GetAttrib(sys_ctx, &gamma_attr_v10);
410 gamma_attr_v10.stManual = *manual;
411 ret = rk_aiq_user_api2_agamma_v10_SetAttrib(sys_ctx, &gamma_attr_v10);
412
413 return ret;
414 }
rk_aiq_get_agamma_v10_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,AgammaApiManualV10_t * manual)415 XCamReturn rk_aiq_get_agamma_v10_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
416 AgammaApiManualV10_t* manual) {
417 XCamReturn ret = XCAM_RETURN_NO_ERROR;
418
419 rk_aiq_gamma_v10_attr_t gamma_attr_v10;
420 ret = rk_aiq_user_api2_agamma_v10_GetAttrib(sys_ctx, &gamma_attr_v10);
421 *manual = gamma_attr_v10.stManual;
422
423 return ret;
424 }
425 #endif
426 #if RKAIQ_HAVE_GAMMA_V11
rk_aiq_set_agamma_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,AgammaApiManualV11_t * manual)427 XCamReturn rk_aiq_set_agamma_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
428 AgammaApiManualV11_t* manual) {
429 XCamReturn ret = XCAM_RETURN_NO_ERROR;
430
431 rk_aiq_gamma_v11_attr_t gamma_attr_v11;
432 ret = rk_aiq_user_api2_agamma_v11_GetAttrib(sys_ctx, &gamma_attr_v11);
433 gamma_attr_v11.stManual = *manual;
434 ret = rk_aiq_user_api2_agamma_v11_SetAttrib(sys_ctx, &gamma_attr_v11);
435
436 return ret;
437 }
rk_aiq_get_agamma_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,AgammaApiManualV11_t * manual)438 XCamReturn rk_aiq_get_agamma_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
439 AgammaApiManualV11_t* manual) {
440 XCamReturn ret = XCAM_RETURN_NO_ERROR;
441
442 rk_aiq_gamma_v11_attr_t gamma_attr_v11;
443 ret = rk_aiq_user_api2_agamma_v11_GetAttrib(sys_ctx, &gamma_attr_v11);
444 *manual = gamma_attr_v11.stManual;
445
446 return ret;
447 }
448 #endif
449
450 #if RKAIQ_HAVE_DEHAZE_V11
rk_aiq_user_api2_adehaze_v11_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,mDehazeAttrInfoV11_t * dehaze_info)451 XCamReturn rk_aiq_user_api2_adehaze_v11_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
452 mDehazeAttrInfoV11_t* dehaze_info) {
453 XCamReturn ret = XCAM_RETURN_NO_ERROR;
454
455 adehaze_sw_v11_t dehaze_attr_v11;
456 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(sys_ctx, &dehaze_attr_v11);
457 *dehaze_info = dehaze_attr_v11.Info;
458
459 return ret;
460 }
461
rk_aiq_set_adehaze_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mDehazeAttrV11_t * manual)462 XCamReturn rk_aiq_set_adehaze_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
463 mDehazeAttrV11_t* manual) {
464 XCamReturn ret = XCAM_RETURN_NO_ERROR;
465
466 adehaze_sw_v11_t dehaze_attr_v11;
467 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(sys_ctx, &dehaze_attr_v11);
468 dehaze_attr_v11.stManual = *manual;
469 ret = rk_aiq_user_api2_adehaze_v11_setSwAttrib(sys_ctx, &dehaze_attr_v11);
470
471 return ret;
472 }
rk_aiq_get_adehaze_v11_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mDehazeAttrV11_t * manual)473 XCamReturn rk_aiq_get_adehaze_v11_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
474 mDehazeAttrV11_t* manual) {
475 XCamReturn ret = XCAM_RETURN_NO_ERROR;
476
477 adehaze_sw_v11_t dehaze_attr_v11;
478 ret = rk_aiq_user_api2_adehaze_v11_getSwAttrib(sys_ctx, &dehaze_attr_v11);
479 *manual = dehaze_attr_v11.stManual;
480
481 return ret;
482 }
483 #endif
484 #if RKAIQ_HAVE_DEHAZE_V12
rk_aiq_user_api2_adehaze_v12_queryinfo(const rk_aiq_sys_ctx_t * sys_ctx,mDehazeAttrInfoV11_t * dehaze_info)485 XCamReturn rk_aiq_user_api2_adehaze_v12_queryinfo(const rk_aiq_sys_ctx_t* sys_ctx,
486 mDehazeAttrInfoV11_t* dehaze_info) {
487 XCamReturn ret = XCAM_RETURN_NO_ERROR;
488
489 adehaze_sw_v12_t dehaze_attr_v12;
490 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(sys_ctx, &dehaze_attr_v12);
491 *dehaze_info = dehaze_attr_v12.Info;
492
493 return ret;
494 }
495
rk_aiq_set_adehaze_v12_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mDehazeAttrV12_t * manual)496 XCamReturn rk_aiq_set_adehaze_v12_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
497 mDehazeAttrV12_t* manual) {
498 XCamReturn ret = XCAM_RETURN_NO_ERROR;
499
500 adehaze_sw_v12_t dehaze_attr_v12;
501 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(sys_ctx, &dehaze_attr_v12);
502 dehaze_attr_v12.stManual = *manual;
503 ret = rk_aiq_user_api2_adehaze_v12_setSwAttrib(sys_ctx, &dehaze_attr_v12);
504
505 return ret;
506 }
rk_aiq_get_adehaze_v12_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,mDehazeAttrV12_t * manual)507 XCamReturn rk_aiq_get_adehaze_v12_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
508 mDehazeAttrV12_t* manual) {
509 XCamReturn ret = XCAM_RETURN_NO_ERROR;
510
511 adehaze_sw_v12_t dehaze_attr_v12;
512 ret = rk_aiq_user_api2_adehaze_v12_getSwAttrib(sys_ctx, &dehaze_attr_v12);
513 *manual = dehaze_attr_v12.stManual;
514
515 return ret;
516 }
517 #endif
518
rk_aiq_set_tool_accm_mode(rk_aiq_sys_ctx_t * ctx,uapi_wb_mode_t * mode)519 XCamReturn rk_aiq_set_tool_accm_mode(rk_aiq_sys_ctx_t *ctx, uapi_wb_mode_t *mode) {
520 return rk_aiq_uapi2_setCCMMode(ctx, mode->mode);
521 }
522
rk_aiq_get_accm_mode(rk_aiq_sys_ctx_t * ctx,uapi_wb_mode_t * mode)523 XCamReturn rk_aiq_get_accm_mode(rk_aiq_sys_ctx_t *ctx, uapi_wb_mode_t *mode) {
524 return rk_aiq_uapi2_getCCMMode(ctx, &mode->mode);
525 }
526
rk_aiq_set_accm_v1_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_mccm_attrib_t * manual)527 XCamReturn rk_aiq_set_accm_v1_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
528 rk_aiq_ccm_mccm_attrib_t* manual) {
529 XCamReturn ret = XCAM_RETURN_NO_ERROR;
530
531 rk_aiq_ccm_attrib_t ccm_attr_v1;
532 ret = rk_aiq_user_api2_accm_GetAttrib(sys_ctx, &ccm_attr_v1);
533 ccm_attr_v1.stManual = *manual;
534 ret = rk_aiq_user_api2_accm_SetAttrib(sys_ctx, &ccm_attr_v1);
535
536 return ret;
537 }
rk_aiq_get_accm_v1_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_mccm_attrib_t * manual)538 XCamReturn rk_aiq_get_accm_v1_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
539 rk_aiq_ccm_mccm_attrib_t* manual) {
540 XCamReturn ret = XCAM_RETURN_NO_ERROR;
541
542 rk_aiq_ccm_attrib_t ccm_attr_v1;
543 ret = rk_aiq_user_api2_accm_GetAttrib(sys_ctx, &ccm_attr_v1);
544 *manual = ccm_attr_v1.stManual;
545
546 return ret;
547 }
548
rk_aiq_set_accm_v2_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_mccm_attrib_v2_t * manual)549 XCamReturn rk_aiq_set_accm_v2_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
550 rk_aiq_ccm_mccm_attrib_v2_t* manual) {
551 XCamReturn ret = XCAM_RETURN_NO_ERROR;
552
553 rk_aiq_ccm_v2_attrib_t ccm_attr_v2;
554 ret = rk_aiq_user_api2_accm_v2_GetAttrib(sys_ctx, &ccm_attr_v2);
555 ccm_attr_v2.stManual = *manual;
556 ret = rk_aiq_user_api2_accm_v2_SetAttrib(sys_ctx, &ccm_attr_v2);
557
558 return ret;
559 }
rk_aiq_get_accm_v2_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_ccm_mccm_attrib_v2_t * manual)560 XCamReturn rk_aiq_get_accm_v2_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
561 rk_aiq_ccm_mccm_attrib_v2_t* manual) {
562 XCamReturn ret = XCAM_RETURN_NO_ERROR;
563
564 rk_aiq_ccm_v2_attrib_t ccm_attr_v2;
565 ret = rk_aiq_user_api2_accm_v2_GetAttrib(sys_ctx, &ccm_attr_v2);
566 *manual = ccm_attr_v2.stManual;
567
568 return ret;
569 }
570
rk_aiq_set_tool_3dlut_mode(rk_aiq_sys_ctx_t * ctx,uapi_wb_mode_t * mode)571 XCamReturn rk_aiq_set_tool_3dlut_mode(rk_aiq_sys_ctx_t *ctx, uapi_wb_mode_t *mode) {
572 return rk_aiq_uapi2_setLut3dMode(ctx, mode->mode);
573 }
574
rk_aiq_get_a3dlut_mode(rk_aiq_sys_ctx_t * ctx,uapi_wb_mode_t * mode)575 XCamReturn rk_aiq_get_a3dlut_mode(rk_aiq_sys_ctx_t *ctx, uapi_wb_mode_t *mode) {
576 return rk_aiq_uapi2_getLut3dMode(ctx, &mode->mode);
577 }
578
rk_aiq_set_a3dlut_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_lut3d_mlut3d_attrib_t * manual)579 XCamReturn rk_aiq_set_a3dlut_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
580 rk_aiq_lut3d_mlut3d_attrib_t *manual) {
581 rk_aiq_lut3d_attrib_t a3dlut_attr;
582
583 memset(&a3dlut_attr, 0, sizeof(rk_aiq_lut3d_attrib_t));
584 rk_aiq_user_api2_a3dlut_GetAttrib(sys_ctx, &a3dlut_attr);
585 memcpy(&a3dlut_attr.stManual, manual, sizeof(rk_aiq_lut3d_mlut3d_attrib_t));
586
587 return rk_aiq_user_api2_a3dlut_SetAttrib(sys_ctx, &a3dlut_attr);
588 }
589
rk_aiq_get_a3dlut_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_lut3d_mlut3d_attrib_t * manual)590 XCamReturn rk_aiq_get_a3dlut_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
591 rk_aiq_lut3d_mlut3d_attrib_t *manual) {
592 rk_aiq_lut3d_attrib_t a3dlut_attr;
593
594 memset(&a3dlut_attr, 0, sizeof(rk_aiq_lut3d_attrib_t));
595 rk_aiq_user_api2_a3dlut_GetAttrib(sys_ctx, &a3dlut_attr);
596 memcpy(manual, &a3dlut_attr.stManual, sizeof(rk_aiq_lut3d_mlut3d_attrib_t));
597
598 return XCAM_RETURN_NO_ERROR;
599 }
600
rk_aiq_set_acgc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,Cgc_Param_t * manual)601 XCamReturn rk_aiq_set_acgc_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
602 Cgc_Param_t* manual) {
603 XCamReturn ret = XCAM_RETURN_NO_ERROR;
604 LOGE_ACGC("READY TO SET ATTR\n");
605
606 rk_aiq_uapi_acgc_attrib_t cgc_attr;
607 ret = rk_aiq_user_api2_acgc_GetAttrib(sys_ctx, &cgc_attr);
608 cgc_attr.param = *manual;
609 ret = rk_aiq_user_api2_acgc_SetAttrib(sys_ctx, &cgc_attr);
610
611 return ret;
612 }
rk_aiq_get_acgc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,Cgc_Param_t * manual)613 XCamReturn rk_aiq_get_acgc_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
614 Cgc_Param_t* manual) {
615 XCamReturn ret = XCAM_RETURN_NO_ERROR;
616
617 rk_aiq_uapi_acgc_attrib_t cgc_attr;
618 ret = rk_aiq_user_api2_acgc_GetAttrib(sys_ctx, &cgc_attr);
619 *manual = cgc_attr.param;
620
621 return ret;
622 }
623
rk_aiq_set_acsm_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,Csm_Param_t * manual)624 XCamReturn rk_aiq_set_acsm_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
625 Csm_Param_t* manual) {
626 XCamReturn ret = XCAM_RETURN_NO_ERROR;
627
628 rk_aiq_uapi_acsm_attrib_t csm_attr;
629 ret = rk_aiq_user_api2_acsm_GetAttrib(sys_ctx, &csm_attr);
630 csm_attr.param = *manual;
631 ret = rk_aiq_user_api2_acsm_SetAttrib(sys_ctx, &csm_attr);
632
633 return ret;
634 }
rk_aiq_get_acsm_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,Csm_Param_t * manual)635 XCamReturn rk_aiq_get_acsm_manual_attr(const rk_aiq_sys_ctx_t* sys_ctx,
636 Csm_Param_t* manual) {
637 XCamReturn ret = XCAM_RETURN_NO_ERROR;
638
639 rk_aiq_uapi_acsm_attrib_t csm_attr;
640 ret = rk_aiq_user_api2_acsm_GetAttrib(sys_ctx, &csm_attr);
641 *manual = csm_attr.param;
642
643 return ret;
644 }
rk_aiq_set_adebayer_attr(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_attrib_t * adebayer_attr)645 XCamReturn rk_aiq_set_adebayer_attr(const rk_aiq_sys_ctx_t *sys_ctx,
646 adebayer_attrib_t *adebayer_attr) {
647 adebayer_attrib_t attr;
648
649 memset(&attr, 0, sizeof(attr));
650 rk_aiq_user_api2_adebayer_GetAttrib(sys_ctx, &attr);
651 memcpy(&attr, adebayer_attr, sizeof(attr));
652
653 return rk_aiq_user_api2_adebayer_SetAttrib(sys_ctx, attr);
654 }
655
rk_aiq_get_adebayer_attr(const rk_aiq_sys_ctx_t * sys_ctx,adebayer_attrib_t * adebayer_attr)656 XCamReturn rk_aiq_get_adebayer_attr(const rk_aiq_sys_ctx_t *sys_ctx,
657 adebayer_attrib_t *adebayer_attr) {
658 adebayer_attrib_t attr;
659
660 memset(&attr, 0, sizeof(attr));
661 rk_aiq_user_api2_adebayer_GetAttrib(sys_ctx, &attr);
662 memcpy(adebayer_attr, &attr, sizeof(attr));
663
664 return XCAM_RETURN_NO_ERROR;
665 }
666
667
rk_aiq_set_alsc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_lsc_table_t * manual)668 XCamReturn rk_aiq_set_alsc_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
669 rk_aiq_lsc_table_t *manual) {
670 rk_aiq_lsc_attrib_t alsc_attr;
671
672 memset(&alsc_attr, 0, sizeof(rk_aiq_lsc_attrib_t));
673 rk_aiq_user_api2_alsc_GetAttrib(sys_ctx, &alsc_attr);
674 memcpy(&alsc_attr.stManual, manual, sizeof(rk_aiq_lsc_table_t));
675
676 return rk_aiq_user_api2_alsc_SetAttrib(sys_ctx, alsc_attr);
677 }
678
rk_aiq_get_alsc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,rk_aiq_lsc_table_t * manual)679 XCamReturn rk_aiq_get_alsc_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
680 rk_aiq_lsc_table_t *manual) {
681 rk_aiq_lsc_attrib_t alsc_attr;
682
683 memset(&alsc_attr, 0, sizeof(rk_aiq_lsc_attrib_t));
684 rk_aiq_user_api2_alsc_GetAttrib(sys_ctx, &alsc_attr);
685 memcpy(manual, &alsc_attr.stManual, sizeof(rk_aiq_lsc_table_t));
686
687 return XCAM_RETURN_NO_ERROR;
688 }
689
rk_aiq_set_current_camindex(const rk_aiq_sys_ctx_t * sys_ctx,camgroup_uapi_t * arg)690 XCamReturn rk_aiq_set_current_camindex(const rk_aiq_sys_ctx_t *sys_ctx,
691 camgroup_uapi_t *arg) {
692 (void)(sys_ctx);
693 last_camindex = *arg;
694
695 return XCAM_RETURN_NO_ERROR;
696 }
697
rk_aiq_get_current_camindex(const rk_aiq_sys_ctx_t * sys_ctx,camgroup_uapi_t * arg)698 XCamReturn rk_aiq_get_current_camindex(const rk_aiq_sys_ctx_t *sys_ctx,
699 camgroup_uapi_t *arg) {
700 (void)(sys_ctx);
701
702 *arg = last_camindex;
703
704 return XCAM_RETURN_NO_ERROR;
705 }
706
rk_aiq_set_ablc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,ablc_uapi_manual_t * manual)707 XCamReturn rk_aiq_set_ablc_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx, ablc_uapi_manual_t *manual) {
708 XCamReturn ret = XCAM_RETURN_NO_ERROR;
709
710 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
711 rk_aiq_blc_attrib_V32_t blc_attr_v32;
712 memset(&blc_attr_v32, 0, sizeof(rk_aiq_blc_attrib_V32_t));
713 if (manual->AblcOPMode == RK_AIQ_OP_MODE_AUTO)
714 blc_attr_v32.eMode = ABLC_V32_OP_MODE_AUTO;
715 else if (manual->AblcOPMode == RK_AIQ_OP_MODE_INVALID)
716 blc_attr_v32.eMode = ABLC_V32_OP_MODE_OFF;
717 else if (manual->AblcOPMode == RK_AIQ_OP_MODE_MANUAL)
718 blc_attr_v32.eMode = ABLC_V32_OP_MODE_MANUAL;
719 else if (manual->AblcOPMode == RK_AIQ_OP_MODE_MAX)
720 blc_attr_v32.eMode = ABLC_V32_OP_MODE_MAX;
721 else
722 blc_attr_v32.eMode = ABLC_V32_OP_MODE_AUTO;
723
724 memcpy(&blc_attr_v32.stBlc0Manual, &manual->blc0_para, sizeof(blc_attr_v32.stBlc0Manual));
725 memcpy(&blc_attr_v32.stBlc1Manual, &manual->blc1_para, sizeof(blc_attr_v32.stBlc1Manual));
726 memcpy(&blc_attr_v32.stBlcOBManual, &manual->blc_ob_para, sizeof(blc_attr_v32.stBlcOBManual));
727
728 ret = rk_aiq_user_api2_ablcV32_SetAttrib(sys_ctx, &blc_attr_v32);
729 #elif defined(ISP_HW_V30)
730 rk_aiq_blc_attrib_t ablc_attr;
731 memset(&ablc_attr, 0, sizeof(ablc_attr));
732 rk_aiq_user_api2_ablc_GetAttrib(sys_ctx, &ablc_attr);
733 memcpy(&ablc_attr.stBlc0Manual, &manual->bls0, sizeof(manual->bls0));
734 memcpy(&ablc_attr.stBlc1Manual, &manual->bls1, sizeof(manual->bls1));
735
736 if (manual->AblcOPMode == RK_AIQ_OP_MODE_AUTO)
737 ablc_attr.eMode = ABLC_OP_MODE_AUTO;
738 else if(manual->AblcOPMode == RK_AIQ_OP_MODE_MANUAL)
739 ablc_attr.eMode = ABLC_OP_MODE_MANUAL;
740 else if(manual->AblcOPMode == RK_AIQ_OP_MODE_INVALID)
741 ablc_attr.eMode = ABLC_OP_MODE_OFF;
742 else if(manual->AblcOPMode == RK_AIQ_OP_MODE_MAX)
743 ablc_attr.eMode = ABLC_OP_MODE_MAX;
744 else
745 ablc_attr.eMode = ABLC_OP_MODE_AUTO;
746
747 ret = rk_aiq_user_api2_ablc_SetAttrib(sys_ctx, &ablc_attr);
748 #endif
749
750 return ret;
751 }
752
rk_aiq_get_ablc_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,ablc_uapi_manual_t * manual)753 XCamReturn rk_aiq_get_ablc_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx, ablc_uapi_manual_t* manual) {
754 XCamReturn ret = XCAM_RETURN_NO_ERROR;
755 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
756 rk_aiq_blc_attrib_V32_t blc_attr_v32;
757 memset(&blc_attr_v32, 0, sizeof(rk_aiq_blc_attrib_V32_t));
758 ret = rk_aiq_user_api2_ablcV32_GetAttrib(sys_ctx, &blc_attr_v32);
759
760 if (blc_attr_v32.eMode == ABLC_V32_OP_MODE_AUTO)
761 manual->AblcOPMode = RK_AIQ_OP_MODE_AUTO;
762 else if (blc_attr_v32.eMode == ABLC_V32_OP_MODE_OFF)
763 manual->AblcOPMode = RK_AIQ_OP_MODE_MANUAL;
764 else if (blc_attr_v32.eMode ==ABLC_V32_OP_MODE_MANUAL)
765 manual->AblcOPMode = RK_AIQ_OP_MODE_MANUAL;
766 else if (blc_attr_v32.eMode == ABLC_V32_OP_MODE_MAX)
767 manual->AblcOPMode = RK_AIQ_OP_MODE_MAX;
768 else
769 manual->AblcOPMode = RK_AIQ_OP_MODE_AUTO;
770
771 memcpy(&manual->blc0_para, &blc_attr_v32.stBlc0Manual, sizeof(manual->blc0_para));
772 memcpy(&manual->blc1_para, &blc_attr_v32.stBlc1Manual, sizeof(manual->blc1_para));
773 memcpy(&manual->blc_ob_para, &blc_attr_v32.stBlcOBManual, sizeof(manual->blc_ob_para));
774 #elif defined(ISP_HW_V30)
775 rk_aiq_blc_attrib_t ablc_attr;
776
777 memset(&ablc_attr, 0, sizeof(ablc_attr));
778 rk_aiq_user_api2_ablc_GetAttrib(sys_ctx, &ablc_attr);
779 memcpy(&manual->bls0, &ablc_attr.stBlc0Manual, sizeof(manual->bls0));
780 memcpy(&manual->bls1, &ablc_attr.stBlc1Manual, sizeof(manual->bls1));
781
782 if (ablc_attr.eMode == ABLC_OP_MODE_AUTO)
783 manual->AblcOPMode = RK_AIQ_OP_MODE_AUTO;
784 else if(ablc_attr.eMode == ABLC_OP_MODE_MANUAL)
785 manual->AblcOPMode = RK_AIQ_OP_MODE_MANUAL;
786 else if(ablc_attr.eMode == ABLC_OP_MODE_OFF )
787 manual->AblcOPMode = RK_AIQ_OP_MODE_INVALID;
788 else if(ablc_attr.eMode == ABLC_OP_MODE_MAX)
789 manual->AblcOPMode = RK_AIQ_OP_MODE_MAX;
790 else
791 manual->AblcOPMode = RK_AIQ_OP_MODE_AUTO;
792 #endif
793
794 return ret;
795 }
796
rk_aiq_set_asharp_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,asharp_uapi_manual_t * manual)797 XCamReturn rk_aiq_set_asharp_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
798 asharp_uapi_manual_t *manual) {
799 XCamReturn res = XCAM_RETURN_NO_ERROR;
800
801 #if defined(ISP_HW_V32)
802 rk_aiq_sharp_attrib_v33_t sharp_attr_v33;
803 memset(&sharp_attr_v33, 0, sizeof(rk_aiq_sharp_attrib_v33_t));
804 rk_aiq_user_api2_asharpV33_GetAttrib(sys_ctx, &sharp_attr_v33);
805 memcpy(&sharp_attr_v33.stManual.stSelect, &manual->manual_v33, sizeof(RK_SHARP_Params_V33_Select_t));
806
807 if (manual->AsharpOpMode == RK_AIQ_OP_MODE_AUTO)
808 sharp_attr_v33.eMode = ASHARP_V33_OP_MODE_AUTO;
809 else if(manual->AsharpOpMode == RK_AIQ_OP_MODE_MANUAL)
810 sharp_attr_v33.eMode = ASHARP_V33_OP_MODE_MANUAL;
811 else if(manual->AsharpOpMode == RK_AIQ_OP_MODE_INVALID)
812 sharp_attr_v33.eMode = ASHARP_V33_OP_MODE_INVALID;
813 else if(manual->AsharpOpMode == RK_AIQ_OP_MODE_MAX)
814 sharp_attr_v33.eMode = ASHARP_V33_OP_MODE_MAX;
815 else
816 sharp_attr_v33.eMode = ASHARP_V33_OP_MODE_AUTO;
817
818 res = rk_aiq_user_api2_asharpV33_SetAttrib(sys_ctx, &sharp_attr_v33);
819 #elif defined(ISP_HW_V32_LITE)
820 rk_aiq_sharp_attrib_v33LT_t sharp_attr_v33_lt;
821 memset(&sharp_attr_v33_lt, 0, sizeof(rk_aiq_sharp_attrib_v33LT_t));
822 rk_aiq_user_api2_asharpV33Lite_GetAttrib(sys_ctx, &sharp_attr_v33_lt);
823 memcpy(&sharp_attr_v33_lt.stManual.stSelect, &manual->manual_v33Lite,
824 sizeof(RK_SHARP_Params_V33LT_Select_t));
825
826 if (manual->AsharpOpMode == RK_AIQ_OP_MODE_AUTO)
827 sharp_attr_v33_lt.eMode = ASHARP_V33_OP_MODE_AUTO;
828 else if (manual->AsharpOpMode == RK_AIQ_OP_MODE_MANUAL)
829 sharp_attr_v33_lt.eMode = ASHARP_V33_OP_MODE_MANUAL;
830 else if (manual->AsharpOpMode == RK_AIQ_OP_MODE_INVALID)
831 sharp_attr_v33_lt.eMode = ASHARP_V33_OP_MODE_INVALID;
832 else if (manual->AsharpOpMode == RK_AIQ_OP_MODE_MAX)
833 sharp_attr_v33_lt.eMode = ASHARP_V33_OP_MODE_MAX;
834 else
835 sharp_attr_v33_lt.eMode = ASHARP_V33_OP_MODE_AUTO;
836
837 res = rk_aiq_user_api2_asharpV33Lite_SetAttrib(sys_ctx, &sharp_attr_v33_lt);
838 #elif defined(ISP_HW_V30)
839 rk_aiq_sharp_attrib_v4_t sharp_attr_v4;
840 memset(&sharp_attr_v4, 0, sizeof(rk_aiq_sharp_attrib_v4_t));
841 rk_aiq_user_api2_asharpV4_GetAttrib(sys_ctx, &sharp_attr_v4);
842 memcpy(&sharp_attr_v4.stManual.stSelect, &manual->manual_v4, sizeof(RK_SHARP_Params_V4_Select_t));
843
844 if (manual->AsharpOpMode == RK_AIQ_OP_MODE_AUTO)
845 sharp_attr_v4.eMode = ASHARP4_OP_MODE_AUTO;
846 else if(manual->AsharpOpMode == RK_AIQ_OP_MODE_MANUAL)
847 sharp_attr_v4.eMode = ASHARP4_OP_MODE_MANUAL;
848 else if(manual->AsharpOpMode == RK_AIQ_OP_MODE_INVALID)
849 sharp_attr_v4.eMode = ASHARP4_OP_MODE_INVALID;
850 else if(manual->AsharpOpMode == RK_AIQ_OP_MODE_MAX)
851 sharp_attr_v4.eMode = ASHARP4_OP_MODE_MAX;
852 else
853 sharp_attr_v4.eMode = ASHARP4_OP_MODE_AUTO;
854
855 res = rk_aiq_user_api2_asharpV4_SetAttrib(sys_ctx, &sharp_attr_v4);
856 #endif
857
858 return res;
859 }
860
rk_aiq_get_asharp_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,asharp_uapi_manual_t * manual)861 XCamReturn rk_aiq_get_asharp_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
862 asharp_uapi_manual_t *manual) {
863 #if defined(ISP_HW_V32)
864 rk_aiq_sharp_attrib_v33_t sharp_attr_v33;
865 memset(&sharp_attr_v33, 0, sizeof(rk_aiq_sharp_attrib_v33_t));
866 rk_aiq_user_api2_asharpV33_GetAttrib(sys_ctx, &sharp_attr_v33);
867 memcpy(&manual->manual_v33, &sharp_attr_v33.stManual.stSelect, sizeof(RK_SHARP_Params_V33_Select_t));
868
869 if (sharp_attr_v33.eMode == ASHARP_V33_OP_MODE_AUTO)
870 manual->AsharpOpMode = RK_AIQ_OP_MODE_AUTO;
871 else if(sharp_attr_v33.eMode == ASHARP_V33_OP_MODE_MANUAL)
872 manual->AsharpOpMode = RK_AIQ_OP_MODE_MANUAL;
873 else if(sharp_attr_v33.eMode == ASHARP_V33_OP_MODE_INVALID )
874 manual->AsharpOpMode = RK_AIQ_OP_MODE_INVALID;
875 else if(sharp_attr_v33.eMode == ASHARP_V33_OP_MODE_MAX)
876 manual->AsharpOpMode = RK_AIQ_OP_MODE_MAX;
877 else
878 manual->AsharpOpMode = RK_AIQ_OP_MODE_AUTO;
879 #elif defined(ISP_HW_V32_LITE)
880 rk_aiq_sharp_attrib_v33LT_t sharp_attr_v33LT;
881 memset(&sharp_attr_v33LT, 0, sizeof(rk_aiq_sharp_attrib_v33LT_t));
882 rk_aiq_user_api2_asharpV33Lite_GetAttrib(sys_ctx, &sharp_attr_v33LT);
883 memcpy(&manual->manual_v33Lite, &sharp_attr_v33LT.stManual.stSelect,
884 sizeof(RK_SHARP_Params_V33LT_Select_t));
885
886 if (sharp_attr_v33LT.eMode == ASHARP_V33_OP_MODE_AUTO)
887 manual->AsharpOpMode = RK_AIQ_OP_MODE_AUTO;
888 else if (sharp_attr_v33LT.eMode == ASHARP_V33_OP_MODE_MANUAL)
889 manual->AsharpOpMode = RK_AIQ_OP_MODE_MANUAL;
890 else if (sharp_attr_v33LT.eMode == ASHARP_V33_OP_MODE_INVALID)
891 manual->AsharpOpMode = RK_AIQ_OP_MODE_INVALID;
892 else if (sharp_attr_v33LT.eMode == ASHARP_V33_OP_MODE_MAX)
893 manual->AsharpOpMode = RK_AIQ_OP_MODE_MAX;
894 else
895 manual->AsharpOpMode = RK_AIQ_OP_MODE_AUTO;
896 #elif defined(ISP_HW_V30)
897 rk_aiq_sharp_attrib_v4_t sharp_attr_v4;
898 memset(&sharp_attr_v4, 0, sizeof(rk_aiq_sharp_attrib_v4_t));
899 rk_aiq_user_api2_asharpV4_GetAttrib(sys_ctx, &sharp_attr_v4);
900 memcpy(&manual->manual_v4, &sharp_attr_v4.stManual.stSelect, sizeof(RK_SHARP_Params_V4_Select_t));
901
902 if (sharp_attr_v4.eMode == ASHARP4_OP_MODE_AUTO)
903 manual->AsharpOpMode = RK_AIQ_OP_MODE_AUTO;
904 else if(sharp_attr_v4.eMode == ASHARP4_OP_MODE_MANUAL)
905 manual->AsharpOpMode = RK_AIQ_OP_MODE_MANUAL;
906 else if(sharp_attr_v4.eMode == ASHARP4_OP_MODE_INVALID )
907 manual->AsharpOpMode = RK_AIQ_OP_MODE_INVALID;
908 else if(sharp_attr_v4.eMode == ASHARP4_OP_MODE_MAX)
909 manual->AsharpOpMode = RK_AIQ_OP_MODE_MAX;
910 else
911 manual->AsharpOpMode = RK_AIQ_OP_MODE_AUTO;
912
913 #endif
914 return XCAM_RETURN_NO_ERROR;
915 }
916
917 XCamReturn
rk_aiq_set_abayer2dnr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,abayer2dnr_uapi_manual_t * manual)918 rk_aiq_set_abayer2dnr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
919 abayer2dnr_uapi_manual_t *manual) {
920 XCamReturn res = XCAM_RETURN_NO_ERROR;
921
922 #if defined(ISP_HW_V32)
923 rk_aiq_bayer2dnr_attrib_v23_t abayer2dnr_attr_v23;
924
925 memset(&abayer2dnr_attr_v23, 0, sizeof(rk_aiq_bayer2dnr_attrib_v23_t));
926 rk_aiq_user_api2_abayer2dnrV23_GetAttrib(sys_ctx, &abayer2dnr_attr_v23);
927 memcpy(&abayer2dnr_attr_v23.stManual.st2DSelect, &manual->manual_v23,
928 sizeof(RK_Bayer2dnrV23_Params_Select_t));
929
930 if (manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_AUTO)
931 abayer2dnr_attr_v23.eMode = ABAYER2DNR_V23_OP_MODE_AUTO;
932 else if(manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_MANUAL)
933 abayer2dnr_attr_v23.eMode = ABAYER2DNR_V23_OP_MODE_MANUAL;
934 else if(manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_INVALID)
935 abayer2dnr_attr_v23.eMode = ABAYER2DNR_V23_OP_MODE_INVALID;
936 else if(manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_MAX)
937 abayer2dnr_attr_v23.eMode = ABAYER2DNR_V23_OP_MODE_MAX;
938 else
939 abayer2dnr_attr_v23.eMode = ABAYER2DNR_V23_OP_MODE_AUTO;
940
941
942 res = rk_aiq_user_api2_abayer2dnrV23_SetAttrib(sys_ctx, &abayer2dnr_attr_v23);
943 #elif defined(ISP_HW_V30)
944 rk_aiq_bayer2dnr_attrib_v2_t abayer2dnr_attr_v2;
945
946 memset(&abayer2dnr_attr_v2, 0, sizeof(rk_aiq_bayer2dnr_attrib_v2_t));
947 rk_aiq_user_api2_abayer2dnrV2_GetAttrib(sys_ctx, &abayer2dnr_attr_v2);
948 memcpy(&abayer2dnr_attr_v2.stManual.st2DSelect, &manual->manual_v2,
949 sizeof(RK_Bayer2dnr_Params_V2_Select_t));
950
951 if (manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_AUTO)
952 abayer2dnr_attr_v2.eMode = ABAYER2DNR_OP_MODE_AUTO;
953 else if(manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_MANUAL)
954 abayer2dnr_attr_v2.eMode = ABAYER2DNR_OP_MODE_MANUAL;
955 else if(manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_INVALID)
956 abayer2dnr_attr_v2.eMode = ABAYER2DNR_OP_MODE_INVALID;
957 else if(manual->Abayer2dnrOpMode == RK_AIQ_OP_MODE_MAX)
958 abayer2dnr_attr_v2.eMode = ABAYER2DNR_OP_MODE_MAX;
959 else
960 abayer2dnr_attr_v2.eMode = ABAYER2DNR_OP_MODE_AUTO;
961
962
963 res = rk_aiq_user_api2_abayer2dnrV2_SetAttrib(sys_ctx, &abayer2dnr_attr_v2);
964 #endif
965
966 return res;
967 }
968
969 XCamReturn
rk_aiq_get_abayer2dnr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,abayer2dnr_uapi_manual_t * manual)970 rk_aiq_get_abayer2dnr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
971 abayer2dnr_uapi_manual_t *manual) {
972 #if defined(ISP_HW_V32)
973 rk_aiq_bayer2dnr_attrib_v23_t abayer2dnr_attr_v23;
974 memset(&abayer2dnr_attr_v23, 0, sizeof(rk_aiq_bayer2dnr_attrib_v23_t));
975 rk_aiq_user_api2_abayer2dnrV23_GetAttrib(sys_ctx, &abayer2dnr_attr_v23);
976 memcpy(&manual->manual_v23, &abayer2dnr_attr_v23.stManual.st2DSelect,
977 sizeof(RK_Bayer2dnrV23_Params_Select_t));
978
979 if (abayer2dnr_attr_v23.eMode == ABAYER2DNR_V23_OP_MODE_AUTO)
980 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_AUTO;
981 else if(abayer2dnr_attr_v23.eMode == ABAYER2DNR_V23_OP_MODE_MANUAL)
982 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_MANUAL;
983 else if(abayer2dnr_attr_v23.eMode == ABAYER2DNR_V23_OP_MODE_INVALID )
984 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_INVALID;
985 else if(abayer2dnr_attr_v23.eMode == ABAYER2DNR_V23_OP_MODE_MAX)
986 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_MAX;
987 else
988 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_AUTO;
989 #elif defined(ISP_HW_V30)
990 rk_aiq_bayer2dnr_attrib_v2_t abayer2dnr_attr_v2;
991 memset(&abayer2dnr_attr_v2, 0, sizeof(rk_aiq_bayer2dnr_attrib_v2_t));
992 rk_aiq_user_api2_abayer2dnrV2_GetAttrib(sys_ctx, &abayer2dnr_attr_v2);
993 memcpy(&manual->manual_v2, &abayer2dnr_attr_v2.stManual.st2DSelect,
994 sizeof(RK_Bayer2dnr_Params_V2_Select_t));
995
996 if (abayer2dnr_attr_v2.eMode == ABAYER2DNR_OP_MODE_AUTO)
997 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_AUTO;
998 else if(abayer2dnr_attr_v2.eMode == ABAYER2DNR_OP_MODE_MANUAL)
999 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_MANUAL;
1000 else if(abayer2dnr_attr_v2.eMode == ABAYER2DNR_OP_MODE_INVALID )
1001 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_INVALID;
1002 else if(abayer2dnr_attr_v2.eMode == ABAYER2DNR_OP_MODE_MAX)
1003 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_MAX;
1004 else
1005 manual->Abayer2dnrOpMode = RK_AIQ_OP_MODE_AUTO;
1006 #endif
1007 return XCAM_RETURN_NO_ERROR;
1008 }
1009
1010 XCamReturn
rk_aiq_set_abayertnr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,abayertnr_uapi_manual_t * manual)1011 rk_aiq_set_abayertnr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1012 abayertnr_uapi_manual_t *manual) {
1013 XCamReturn res = XCAM_RETURN_NO_ERROR;
1014
1015 #if defined(ISP_HW_V32)
1016 rk_aiq_bayertnr_attrib_v23_t abayertnr_attr_v23;
1017 memset(&abayertnr_attr_v23, 0, sizeof(rk_aiq_bayertnr_attrib_v23_t));
1018 rk_aiq_user_api2_abayertnrV23_GetAttrib(sys_ctx, &abayertnr_attr_v23);
1019 memcpy(&abayertnr_attr_v23.stManual.st3DSelect, &manual->manual_v23,
1020 sizeof(RK_Bayertnr_Params_V23_Select_t));
1021
1022 if (manual->AbayertnrOpMode == RK_AIQ_OP_MODE_AUTO)
1023 abayertnr_attr_v23.eMode = ABAYERTNRV23_OP_MODE_AUTO;
1024 else if(manual->AbayertnrOpMode == RK_AIQ_OP_MODE_MANUAL)
1025 abayertnr_attr_v23.eMode = ABAYERTNRV23_OP_MODE_MANUAL;
1026 else if(manual->AbayertnrOpMode == RK_AIQ_OP_MODE_INVALID)
1027 abayertnr_attr_v23.eMode = ABAYERTNRV23_OP_MODE_INVALID;
1028 else if(manual->AbayertnrOpMode == RK_AIQ_OP_MODE_MAX)
1029 abayertnr_attr_v23.eMode = ABAYERTNRV23_OP_MODE_MAX;
1030 else
1031 abayertnr_attr_v23.eMode = ABAYERTNRV23_OP_MODE_AUTO;
1032
1033 res = rk_aiq_user_api2_abayertnrV23_SetAttrib(sys_ctx, &abayertnr_attr_v23);
1034 #endif
1035
1036 #if defined(ISP_HW_V32_LITE)
1037 rk_aiq_bayertnr_attrib_v23L_t abayertnr_attr_v23L;
1038 memset(&abayertnr_attr_v23L, 0, sizeof(rk_aiq_bayertnr_attrib_v23L_t));
1039 rk_aiq_user_api2_abayertnrV23Lite_GetAttrib(sys_ctx, &abayertnr_attr_v23L);
1040 memcpy(&abayertnr_attr_v23L.stManual.st3DSelect, &manual->manual_v23L,
1041 sizeof(RK_Bayertnr_Param_V23L_Select_t));
1042
1043 if (manual->AbayertnrOpMode == RK_AIQ_OP_MODE_AUTO)
1044 abayertnr_attr_v23L.eMode = ABAYERTNRV23_OP_MODE_AUTO;
1045 else if (manual->AbayertnrOpMode == RK_AIQ_OP_MODE_MANUAL)
1046 abayertnr_attr_v23L.eMode = ABAYERTNRV23_OP_MODE_MANUAL;
1047 else if (manual->AbayertnrOpMode == RK_AIQ_OP_MODE_INVALID)
1048 abayertnr_attr_v23L.eMode = ABAYERTNRV23_OP_MODE_INVALID;
1049 else if (manual->AbayertnrOpMode == RK_AIQ_OP_MODE_MAX)
1050 abayertnr_attr_v23L.eMode = ABAYERTNRV23_OP_MODE_MAX;
1051 else
1052 abayertnr_attr_v23L.eMode = ABAYERTNRV23_OP_MODE_AUTO;
1053
1054 res = rk_aiq_user_api2_abayertnrV23Lite_SetAttrib(sys_ctx, &abayertnr_attr_v23L);
1055
1056 #endif
1057
1058 #if defined(ISP_HW_V30)
1059 rk_aiq_bayertnr_attrib_v2_t abayertnr_attr_v2;
1060 memset(&abayertnr_attr_v2, 0, sizeof(abayertnr_attr_v2));
1061 rk_aiq_user_api2_abayertnrV2_GetAttrib(sys_ctx, &abayertnr_attr_v2);
1062 memcpy(&abayertnr_attr_v2.stManual.st3DSelect, &manual->manual_v2,
1063 sizeof(manual->manual_v2));
1064
1065 if (manual->AbayertnrOpMode == RK_AIQ_OP_MODE_AUTO)
1066 abayertnr_attr_v2.eMode = ABAYERTNRV2_OP_MODE_AUTO;
1067 else if(manual->AbayertnrOpMode == RK_AIQ_OP_MODE_MANUAL)
1068 abayertnr_attr_v2.eMode = ABAYERTNRV2_OP_MODE_MANUAL;
1069 else if(manual->AbayertnrOpMode == RK_AIQ_OP_MODE_INVALID)
1070 abayertnr_attr_v2.eMode = ABAYERTNRV2_OP_MODE_INVALID;
1071 else if(manual->AbayertnrOpMode == RK_AIQ_OP_MODE_MAX)
1072 abayertnr_attr_v2.eMode = ABAYERTNRV2_OP_MODE_MAX;
1073 else
1074 abayertnr_attr_v2.eMode = ABAYERTNRV2_OP_MODE_AUTO;
1075
1076 res = rk_aiq_user_api2_abayertnrV2_SetAttrib(sys_ctx, &abayertnr_attr_v2);
1077 #endif
1078
1079 return res;
1080 }
1081
1082 XCamReturn
rk_aiq_get_abayertnr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,abayertnr_uapi_manual_t * manual)1083 rk_aiq_get_abayertnr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1084 abayertnr_uapi_manual_t *manual) {
1085
1086 #if defined(ISP_HW_V32)
1087 rk_aiq_bayertnr_attrib_v23_t abayertnr_attr;
1088 memset(&abayertnr_attr, 0, sizeof(rk_aiq_bayertnr_attrib_v23_t));
1089 rk_aiq_user_api2_abayertnrV23_GetAttrib(sys_ctx, &abayertnr_attr);
1090 memcpy(&manual->manual_v23, &abayertnr_attr.stManual.st3DSelect,
1091 sizeof(RK_Bayertnr_Params_V23_Select_t));
1092
1093 if (abayertnr_attr.eMode == ABAYERTNRV23_OP_MODE_AUTO)
1094 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_AUTO;
1095 else if(abayertnr_attr.eMode == ABAYERTNRV23_OP_MODE_MANUAL)
1096 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_MANUAL;
1097 else if(abayertnr_attr.eMode == ABAYERTNRV23_OP_MODE_INVALID )
1098 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_INVALID;
1099 else if(abayertnr_attr.eMode == ABAYERTNRV23_OP_MODE_MAX)
1100 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_MAX;
1101 else
1102 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_AUTO;
1103
1104 #elif defined(ISP_HW_V32_LITE)
1105 rk_aiq_bayertnr_attrib_v23L_t abayertnr_attr_v23L;
1106 memset(&abayertnr_attr_v23L, 0, sizeof(rk_aiq_bayertnr_attrib_v23L_t));
1107 rk_aiq_user_api2_abayertnrV23Lite_GetAttrib(sys_ctx, &abayertnr_attr_v23L);
1108 memcpy(&manual->manual_v23L, &abayertnr_attr_v23L.stManual.st3DSelect,
1109 sizeof(RK_Bayertnr_Param_V23L_Select_t));
1110
1111 if (abayertnr_attr_v23L.eMode == ABAYERTNRV23_OP_MODE_AUTO)
1112 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_AUTO;
1113 else if (abayertnr_attr_v23L.eMode == ABAYERTNRV23_OP_MODE_MANUAL)
1114 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_MANUAL;
1115 else if (abayertnr_attr_v23L.eMode == ABAYERTNRV23_OP_MODE_INVALID)
1116 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_INVALID;
1117 else if (abayertnr_attr_v23L.eMode == ABAYERTNRV23_OP_MODE_MAX)
1118 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_MAX;
1119 else
1120 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_AUTO;
1121
1122 #elif defined(ISP_HW_V30)
1123 rk_aiq_bayertnr_attrib_v2_t abayertnr_attr_v2;
1124 memset(&abayertnr_attr_v2, 0, sizeof(abayertnr_attr_v2));
1125 rk_aiq_user_api2_abayertnrV2_GetAttrib(sys_ctx, &abayertnr_attr_v2);
1126 memcpy(&manual->manual_v2, &abayertnr_attr_v2.stManual.st3DSelect,
1127 sizeof(manual->manual_v2));
1128
1129 if (abayertnr_attr_v2.eMode == ABAYERTNRV2_OP_MODE_AUTO)
1130 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_AUTO;
1131 else if(abayertnr_attr_v2.eMode == ABAYERTNRV2_OP_MODE_MANUAL)
1132 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_MANUAL;
1133 else if(abayertnr_attr_v2.eMode == ABAYERTNRV2_OP_MODE_INVALID )
1134 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_INVALID;
1135 else if(abayertnr_attr_v2.eMode == ABAYERTNRV2_OP_MODE_MAX)
1136 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_MAX;
1137 else
1138 manual->AbayertnrOpMode = RK_AIQ_OP_MODE_AUTO;
1139 #endif
1140 return XCAM_RETURN_NO_ERROR;
1141 }
1142
rk_aiq_set_aynr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,aynr_uapi_manual_t * manual)1143 XCamReturn rk_aiq_set_aynr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1144 aynr_uapi_manual_t *manual) {
1145 XCamReturn res = XCAM_RETURN_NO_ERROR;
1146
1147 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1148 rk_aiq_ynr_attrib_v22_t aynr_attr_v22;
1149 memset(&aynr_attr_v22, 0, sizeof(rk_aiq_ynr_attrib_v22_t));
1150 rk_aiq_user_api2_aynrV22_GetAttrib(sys_ctx, &aynr_attr_v22);
1151 memcpy(&aynr_attr_v22.stManual.stSelect, &manual->manual_v22, sizeof(RK_YNR_Params_V22_Select_t));
1152
1153 if (manual->AynrOpMode == RK_AIQ_OP_MODE_AUTO)
1154 aynr_attr_v22.eMode = AYNRV22_OP_MODE_AUTO;
1155 else if(manual->AynrOpMode == RK_AIQ_OP_MODE_MANUAL)
1156 aynr_attr_v22.eMode = AYNRV22_OP_MODE_MANUAL;
1157 else if(manual->AynrOpMode == RK_AIQ_OP_MODE_INVALID)
1158 aynr_attr_v22.eMode = AYNRV22_OP_MODE_INVALID;
1159 else if(manual->AynrOpMode == RK_AIQ_OP_MODE_MAX)
1160 aynr_attr_v22.eMode = AYNRV22_OP_MODE_MAX;
1161
1162 res = rk_aiq_user_api2_aynrV22_SetAttrib(sys_ctx, &aynr_attr_v22);
1163 #elif defined(ISP_HW_V30)
1164 rk_aiq_ynr_attrib_v3_t aynr_attr_v3;
1165 memset(&aynr_attr_v3, 0, sizeof(aynr_attr_v3));
1166 rk_aiq_user_api2_aynrV3_GetAttrib(sys_ctx, &aynr_attr_v3);
1167 memcpy(&aynr_attr_v3.stManual.stSelect, &manual->manual_v3, sizeof(manual->manual_v3));
1168
1169 if (manual->AynrOpMode == RK_AIQ_OP_MODE_AUTO)
1170 aynr_attr_v3.eMode = AYNRV3_OP_MODE_AUTO;
1171 else if(manual->AynrOpMode == RK_AIQ_OP_MODE_MANUAL)
1172 aynr_attr_v3.eMode = AYNRV3_OP_MODE_MANUAL;
1173 else if(manual->AynrOpMode == RK_AIQ_OP_MODE_INVALID)
1174 aynr_attr_v3.eMode = AYNRV3_OP_MODE_INVALID;
1175 else if(manual->AynrOpMode == RK_AIQ_OP_MODE_MAX)
1176 aynr_attr_v3.eMode = AYNRV3_OP_MODE_MAX;
1177
1178 res = rk_aiq_user_api2_aynrV3_SetAttrib(sys_ctx, &aynr_attr_v3);
1179 #endif
1180
1181 return res;
1182 }
1183
rk_aiq_get_aynr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,aynr_uapi_manual_t * manual)1184 XCamReturn rk_aiq_get_aynr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1185 aynr_uapi_manual_t *manual) {
1186 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1187 rk_aiq_ynr_attrib_v22_t aynr_attr_v22;
1188
1189 memset(&aynr_attr_v22, 0, sizeof(rk_aiq_ynr_attrib_v22_t));
1190 rk_aiq_user_api2_aynrV22_GetAttrib(sys_ctx, &aynr_attr_v22);
1191 memcpy(&manual->manual_v22, &aynr_attr_v22.stManual.stSelect, sizeof(RK_YNR_Params_V22_Select_t));
1192
1193 if (aynr_attr_v22.eMode == AYNRV22_OP_MODE_AUTO)
1194 manual->AynrOpMode = RK_AIQ_OP_MODE_AUTO;
1195 else if(aynr_attr_v22.eMode == AYNRV22_OP_MODE_MANUAL)
1196 manual->AynrOpMode = RK_AIQ_OP_MODE_MANUAL;
1197 else if(aynr_attr_v22.eMode == AYNRV22_OP_MODE_INVALID )
1198 manual->AynrOpMode = RK_AIQ_OP_MODE_INVALID;
1199 else if(aynr_attr_v22.eMode == AYNRV22_OP_MODE_MAX)
1200 manual->AynrOpMode = RK_AIQ_OP_MODE_MAX;
1201 else
1202 manual->AynrOpMode = RK_AIQ_OP_MODE_AUTO;
1203 #elif defined(ISP_HW_V30)
1204 rk_aiq_ynr_attrib_v3_t aynr_attr_v3;
1205
1206 memset(&aynr_attr_v3, 0, sizeof(aynr_attr_v3));
1207 rk_aiq_user_api2_aynrV3_GetAttrib(sys_ctx, &aynr_attr_v3);
1208 memcpy(&manual->manual_v3, &aynr_attr_v3.stManual.stSelect, sizeof(manual->manual_v3));
1209
1210 if (aynr_attr_v3.eMode == AYNRV3_OP_MODE_AUTO)
1211 manual->AynrOpMode = RK_AIQ_OP_MODE_AUTO;
1212 else if(aynr_attr_v3.eMode == AYNRV3_OP_MODE_MANUAL)
1213 manual->AynrOpMode = RK_AIQ_OP_MODE_MANUAL;
1214 else if(aynr_attr_v3.eMode == AYNRV3_OP_MODE_INVALID )
1215 manual->AynrOpMode = RK_AIQ_OP_MODE_INVALID;
1216 else if(aynr_attr_v3.eMode == AYNRV3_OP_MODE_MAX)
1217 manual->AynrOpMode = RK_AIQ_OP_MODE_MAX;
1218 else
1219 manual->AynrOpMode = RK_AIQ_OP_MODE_AUTO;
1220 #endif
1221
1222 return XCAM_RETURN_NO_ERROR;
1223 }
1224
rk_aiq_set_acnr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,acnr_uapi_manual_t * manual)1225 XCamReturn rk_aiq_set_acnr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1226 acnr_uapi_manual_t *manual) {
1227 XCamReturn res = XCAM_RETURN_NO_ERROR;
1228
1229 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1230 rk_aiq_cnr_attrib_v30_t acnr_attr_v30;
1231
1232 memset(&acnr_attr_v30, 0, sizeof(rk_aiq_cnr_attrib_v30_t));
1233 rk_aiq_user_api2_acnrV30_GetAttrib(sys_ctx, &acnr_attr_v30);
1234 memcpy(&acnr_attr_v30.stManual.stSelect, &manual->manual_v30, sizeof(RK_CNR_Params_V30_Select_t));
1235
1236 if (manual->AcnrOpMode == RK_AIQ_OP_MODE_AUTO)
1237 acnr_attr_v30.eMode = ACNRV30_OP_MODE_AUTO;
1238 else if(manual->AcnrOpMode == RK_AIQ_OP_MODE_MANUAL)
1239 acnr_attr_v30.eMode = ACNRV30_OP_MODE_MANUAL;
1240 else if(manual->AcnrOpMode == RK_AIQ_OP_MODE_INVALID)
1241 acnr_attr_v30.eMode = ACNRV30_OP_MODE_INVALID;
1242 else if(manual->AcnrOpMode == RK_AIQ_OP_MODE_MAX)
1243 acnr_attr_v30.eMode = ACNRV30_OP_MODE_MAX;
1244 else
1245 acnr_attr_v30.eMode = ACNRV30_OP_MODE_AUTO;
1246
1247 res = rk_aiq_user_api2_acnrV30_SetAttrib(sys_ctx, &acnr_attr_v30);
1248 #elif defined(ISP_HW_V30)
1249 rk_aiq_cnr_attrib_v2_t acnr_attr_v2;
1250
1251 memset(&acnr_attr_v2, 0, sizeof(acnr_attr_v2));
1252 rk_aiq_user_api2_acnrV2_GetAttrib(sys_ctx, &acnr_attr_v2);
1253 memcpy(&acnr_attr_v2.stManual.stSelect, &manual->manual_v2, sizeof(manual->manual_v2));
1254
1255 if (manual->AcnrOpMode == RK_AIQ_OP_MODE_AUTO)
1256 acnr_attr_v2.eMode = ACNRV2_OP_MODE_AUTO;
1257 else if(manual->AcnrOpMode == RK_AIQ_OP_MODE_MANUAL)
1258 acnr_attr_v2.eMode = ACNRV2_OP_MODE_MANUAL;
1259 else if(manual->AcnrOpMode == RK_AIQ_OP_MODE_INVALID)
1260 acnr_attr_v2.eMode = ACNRV2_OP_MODE_INVALID;
1261 else if(manual->AcnrOpMode == RK_AIQ_OP_MODE_MAX)
1262 acnr_attr_v2.eMode = ACNRV2_OP_MODE_MAX;
1263 else
1264 acnr_attr_v2.eMode = ACNRV2_OP_MODE_AUTO;
1265
1266 res = rk_aiq_user_api2_acnrV2_SetAttrib(sys_ctx, &acnr_attr_v2);
1267 #endif
1268
1269 return res;
1270 }
1271
rk_aiq_get_acnr_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,acnr_uapi_manual_t * manual)1272 XCamReturn rk_aiq_get_acnr_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1273 acnr_uapi_manual_t *manual) {
1274 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1275 rk_aiq_cnr_attrib_v30_t acnr_attr_v30;
1276 memset(&acnr_attr_v30, 0, sizeof(rk_aiq_cnr_attrib_v30_t));
1277 rk_aiq_user_api2_acnrV30_GetAttrib(sys_ctx, &acnr_attr_v30);
1278 memcpy(&manual->manual_v30, &acnr_attr_v30.stManual.stSelect, sizeof(RK_CNR_Params_V30_Select_t));
1279
1280 if (acnr_attr_v30.eMode == ACNRV30_OP_MODE_AUTO)
1281 manual->AcnrOpMode = RK_AIQ_OP_MODE_AUTO;
1282 else if(acnr_attr_v30.eMode == ACNRV30_OP_MODE_MANUAL)
1283 manual->AcnrOpMode = RK_AIQ_OP_MODE_MANUAL;
1284 else if(acnr_attr_v30.eMode == ACNRV30_OP_MODE_INVALID )
1285 manual->AcnrOpMode = RK_AIQ_OP_MODE_INVALID;
1286 else if(acnr_attr_v30.eMode == ACNRV30_OP_MODE_MAX)
1287 manual->AcnrOpMode = RK_AIQ_OP_MODE_MAX;
1288 else
1289 manual->AcnrOpMode = RK_AIQ_OP_MODE_AUTO;
1290 #elif defined(ISP_HW_V30)
1291 rk_aiq_cnr_attrib_v2_t acnr_attr_v2;
1292 memset(&acnr_attr_v2, 0, sizeof(acnr_attr_v2));
1293 rk_aiq_user_api2_acnrV2_GetAttrib(sys_ctx, &acnr_attr_v2);
1294 memcpy(&manual->manual_v2, &acnr_attr_v2.stManual.stSelect, sizeof(manual->manual_v2));
1295
1296 if (acnr_attr_v2.eMode == ACNRV2_OP_MODE_AUTO)
1297 manual->AcnrOpMode = RK_AIQ_OP_MODE_AUTO;
1298 else if(acnr_attr_v2.eMode == ACNRV2_OP_MODE_MANUAL)
1299 manual->AcnrOpMode = RK_AIQ_OP_MODE_MANUAL;
1300 else if(acnr_attr_v2.eMode == ACNRV2_OP_MODE_INVALID )
1301 manual->AcnrOpMode = RK_AIQ_OP_MODE_INVALID;
1302 else if(acnr_attr_v2.eMode == ACNRV2_OP_MODE_MAX)
1303 manual->AcnrOpMode = RK_AIQ_OP_MODE_MAX;
1304 else
1305 manual->AcnrOpMode = RK_AIQ_OP_MODE_AUTO;
1306 #endif
1307
1308 return XCAM_RETURN_NO_ERROR;
1309 }
1310
rk_aiq_set_again_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,again_uapi_manual_t * manual)1311 XCamReturn rk_aiq_set_again_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1312 again_uapi_manual_t *manual) {
1313 XCamReturn res = XCAM_RETURN_NO_ERROR;
1314
1315 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE) || defined(ISP_HW_V30)
1316 rk_aiq_gain_attrib_v2_t again_attr_v2;
1317 memset(&again_attr_v2, 0, sizeof(rk_aiq_gain_attrib_v2_t));
1318 rk_aiq_user_api2_againV2_GetAttrib(sys_ctx, &again_attr_v2);
1319 memcpy(&again_attr_v2.stManual.stSelect, &manual->manual_v2, sizeof(RK_GAIN_Select_V2_t));
1320
1321 if (manual->AgainOpMode == RK_AIQ_OP_MODE_AUTO)
1322 again_attr_v2.eMode = AGAINV2_OP_MODE_AUTO;
1323 else if(manual->AgainOpMode == RK_AIQ_OP_MODE_MANUAL)
1324 again_attr_v2.eMode = AGAINV2_OP_MODE_MANUAL;
1325 else if(manual->AgainOpMode == RK_AIQ_OP_MODE_INVALID)
1326 again_attr_v2.eMode = AGAINV2_OP_MODE_INVALID;
1327 else if(manual->AgainOpMode == RK_AIQ_OP_MODE_MAX)
1328 again_attr_v2.eMode = AGAINV2_OP_MODE_MAX;
1329 else
1330 again_attr_v2.eMode = AGAINV2_OP_MODE_AUTO;
1331
1332 res = rk_aiq_user_api2_againV2_SetAttrib(sys_ctx, &again_attr_v2);
1333 #endif
1334
1335 return res;
1336 }
1337
rk_aiq_get_again_manual_attr(const rk_aiq_sys_ctx_t * sys_ctx,again_uapi_manual_t * manual)1338 XCamReturn rk_aiq_get_again_manual_attr(const rk_aiq_sys_ctx_t *sys_ctx,
1339 again_uapi_manual_t *manual) {
1340 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE) || defined(ISP_HW_V30)
1341 rk_aiq_gain_attrib_v2_t again_attr_v2;
1342
1343 memset(&again_attr_v2, 0, sizeof(rk_aiq_gain_attrib_v2_t));
1344 rk_aiq_user_api2_againV2_GetAttrib(sys_ctx, &again_attr_v2);
1345 memcpy(&manual->manual_v2, &again_attr_v2.stManual.stSelect, sizeof(RK_GAIN_Select_V2_t));
1346
1347 if (again_attr_v2.eMode == AGAINV2_OP_MODE_AUTO)
1348 manual->AgainOpMode = RK_AIQ_OP_MODE_AUTO;
1349 else if(again_attr_v2.eMode == AGAINV2_OP_MODE_MANUAL)
1350 manual->AgainOpMode = RK_AIQ_OP_MODE_MANUAL;
1351 else if(again_attr_v2.eMode == AGAINV2_OP_MODE_INVALID )
1352 manual->AgainOpMode = RK_AIQ_OP_MODE_INVALID;
1353 else if(again_attr_v2.eMode == AGAINV2_OP_MODE_MAX)
1354 manual->AgainOpMode = RK_AIQ_OP_MODE_MAX;
1355 else
1356 manual->AgainOpMode = RK_AIQ_OP_MODE_AUTO;
1357 #endif
1358 return XCAM_RETURN_NO_ERROR;
1359 }
1360
1361 XCamReturn
rk_aiq_get_ablc_info(const rk_aiq_sys_ctx_t * sys_ctx,ablc_uapi_info_t * pInfo)1362 rk_aiq_get_ablc_info(const rk_aiq_sys_ctx_t *sys_ctx,
1363 ablc_uapi_info_t* pInfo) {
1364
1365 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1366 rk_aiq_blc_info_v32_t ablc_info_v23;
1367 rk_aiq_user_api2_ablcV32_GetInfo(sys_ctx, &ablc_info_v23);
1368 pInfo->iso = ablc_info_v23.iso;
1369 pInfo->expo_info = ablc_info_v23.expo_info;
1370 #elif defined(ISP_HW_V30)
1371 rk_aiq_ablc_info_t ablc_info;
1372 rk_aiq_user_api2_ablc_GetInfo(sys_ctx, &ablc_info);
1373 pInfo->iso = ablc_info.iso;
1374 pInfo->expo_info = ablc_info.expo_info;
1375 #endif
1376 return XCAM_RETURN_NO_ERROR;
1377 }
1378
1379 XCamReturn
rk_aiq_get_abayertnr_info(const rk_aiq_sys_ctx_t * sys_ctx,abayertnr_uapi_info_t * info)1380 rk_aiq_get_abayertnr_info(const rk_aiq_sys_ctx_t *sys_ctx,
1381 abayertnr_uapi_info_t *info) {
1382
1383 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1384 rk_aiq_bayertnr_info_v23_t abayertnr_info_v23;
1385 rk_aiq_user_api2_abayertnrV23_GetInfo(sys_ctx, &abayertnr_info_v23);
1386 info->iso = abayertnr_info_v23.iso;
1387 info->expo_info = abayertnr_info_v23.expo_info;
1388 #elif defined(ISP_HW_V30)
1389 rk_aiq_bayertnr_info_v2_t abayertnr_info_v2;
1390 rk_aiq_user_api2_abayertnrV2_GetInfo(sys_ctx, &abayertnr_info_v2);
1391 info->iso = abayertnr_info_v2.iso;
1392 info->expo_info = abayertnr_info_v2.expo_info;
1393 #endif
1394 return XCAM_RETURN_NO_ERROR;
1395 }
1396
1397 XCamReturn
rk_aiq_get_abayer2dnr_info(const rk_aiq_sys_ctx_t * sys_ctx,abayer2dnr_uapi_info_t * info)1398 rk_aiq_get_abayer2dnr_info(const rk_aiq_sys_ctx_t *sys_ctx,
1399 abayer2dnr_uapi_info_t *info) {
1400 #if defined(ISP_HW_V32)
1401 rk_aiq_bayer2dnr_info_v23_t bayer2dnr_info_v23;
1402 rk_aiq_user_api2_abayer2dnrV23_GetInfo(sys_ctx, &bayer2dnr_info_v23);
1403 info->iso = bayer2dnr_info_v23.iso;
1404 info->expo_info = bayer2dnr_info_v23.expo_info;
1405 #elif defined(ISP_HW_V30)
1406 rk_aiq_bayer2dnr_info_v2_t bayer2dnr_info_v2;
1407 rk_aiq_user_api2_abayer2dnrV2_GetInfo(sys_ctx, &bayer2dnr_info_v2);
1408 info->iso = bayer2dnr_info_v2.iso;
1409 info->expo_info = bayer2dnr_info_v2.expo_info;
1410 #endif
1411 return XCAM_RETURN_NO_ERROR;
1412 }
1413
1414 XCamReturn
rk_aiq_get_aynr_info(const rk_aiq_sys_ctx_t * sys_ctx,aynr_uapi_info_t * info)1415 rk_aiq_get_aynr_info(const rk_aiq_sys_ctx_t *sys_ctx,
1416 aynr_uapi_info_t *info) {
1417 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1418 rk_aiq_ynr_info_v22_t ynr_info_v22;
1419 rk_aiq_user_api2_aynrV22_GetInfo(sys_ctx, &ynr_info_v22);
1420 info->iso = ynr_info_v22.iso;
1421 info->expo_info = ynr_info_v22.expo_info;
1422 #elif defined(ISP_HW_V30)
1423 rk_aiq_ynr_info_v3_t ynr_info_v3;
1424 rk_aiq_user_api2_aynrV3_GetInfo(sys_ctx, &ynr_info_v3);
1425 info->iso = ynr_info_v3.iso;
1426 info->expo_info = ynr_info_v3.expo_info;
1427 #endif
1428 return XCAM_RETURN_NO_ERROR;
1429 }
1430
1431 XCamReturn
rk_aiq_get_acnr_info(const rk_aiq_sys_ctx_t * sys_ctx,acnr_uapi_info_t * info)1432 rk_aiq_get_acnr_info(const rk_aiq_sys_ctx_t *sys_ctx,
1433 acnr_uapi_info_t *info) {
1434 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1435 rk_aiq_cnr_info_v30_t cnr_info_v30;
1436 rk_aiq_user_api2_acnrV30_GetInfo(sys_ctx, &cnr_info_v30);
1437 info->iso = cnr_info_v30.iso;
1438 info->expo_info = cnr_info_v30.expo_info;
1439 #elif defined(ISP_HW_V30)
1440 rk_aiq_cnr_info_v2_t cnr_info_v2;
1441 rk_aiq_user_api2_acnrV2_GetInfo(sys_ctx, &cnr_info_v2);
1442 info->iso = cnr_info_v2.iso;
1443 info->expo_info = cnr_info_v2.expo_info;
1444 #endif
1445
1446 return XCAM_RETURN_NO_ERROR;
1447 }
1448
1449 XCamReturn
rk_aiq_get_asharp_info(const rk_aiq_sys_ctx_t * sys_ctx,asharp_uapi_info_t * info)1450 rk_aiq_get_asharp_info(const rk_aiq_sys_ctx_t *sys_ctx,
1451 asharp_uapi_info_t *info) {
1452
1453 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
1454 rk_aiq_sharp_info_v33_t sharp_info_v33;
1455 rk_aiq_user_api2_asharpV33_GetInfo(sys_ctx, &sharp_info_v33);
1456 info->iso = sharp_info_v33.iso;
1457 info->expo_info = sharp_info_v33.expo_info;
1458 #elif defined(ISP_HW_V30)
1459 rk_aiq_sharp_info_v4_t sharp_info_v4;
1460 rk_aiq_user_api2_asharpV4_GetInfo(sys_ctx, &sharp_info_v4);
1461 info->iso = sharp_info_v4.iso;
1462 info->expo_info = sharp_info_v4.expo_info;
1463 #endif
1464
1465 return XCAM_RETURN_NO_ERROR;
1466
1467 }
1468
1469
1470 XCamReturn
rk_aiq_get_again_info(const rk_aiq_sys_ctx_t * sys_ctx,again_uapi_info_t * info)1471 rk_aiq_get_again_info(const rk_aiq_sys_ctx_t *sys_ctx,
1472 again_uapi_info_t *info) {
1473
1474 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE) || defined(ISP_HW_V30)
1475 rk_aiq_gain_info_v2_t gain_info_v2;
1476 rk_aiq_user_api2_againV2_GetInfo(sys_ctx, &gain_info_v2);
1477 info->iso = gain_info_v2.iso;
1478 info->expo_info = gain_info_v2.expo_info;
1479 #endif
1480
1481 return XCAM_RETURN_NO_ERROR;
1482 }
1483
rk_aiq_get_last_sysctx(rk_aiq_sys_ctx_t * sys_ctx)1484 rk_aiq_sys_ctx_t* rk_aiq_get_last_sysctx(rk_aiq_sys_ctx_t *sys_ctx) {
1485 #if RKAIQ_ENABLE_CAMGROUP
1486 camgroup_uapi_t last_arg;
1487 rk_aiq_camgroup_ctx_t* grp_ctx = NULL;
1488
1489 // Single camera instance
1490 grp_ctx = get_binded_group_ctx(sys_ctx);
1491 if (!grp_ctx) {
1492 return sys_ctx->next_ctx ? sys_ctx->next_ctx : sys_ctx;
1493 }
1494
1495 // Group camera instance
1496 // Check if an special index of camera required
1497 memset(&last_arg, 0, sizeof(camgroup_uapi_t));
1498 rk_aiq_get_current_camindex(sys_ctx, &last_arg);
1499 if (last_arg.current_index == 0) {
1500 return (rk_aiq_sys_ctx_t*)grp_ctx;
1501 }
1502
1503 for (auto cam_ctx : grp_ctx->cam_ctxs_array) {
1504 if (!cam_ctx || cam_ctx->_camPhyId != (last_arg.current_index - 1))
1505 continue;
1506 return cam_ctx;
1507 }
1508
1509 #endif
1510 return NULL;
1511 }
1512