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_adrc.h"
17 #include "RkAiqCamGroupHandleInt.h"
18 #include "algo_handlers/RkAiqAdrcHandle.h"
19
20 RKAIQ_BEGIN_DECLARE
21
22 #ifdef RK_SIMULATOR_HW
23 #define CHECK_USER_API_ENABLE
24 #endif
25
rk_aiq_user_api2_adrc_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drc_attrib_t attr)26 XCamReturn rk_aiq_user_api2_adrc_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, drc_attrib_t attr) {
27 XCamReturn ret = XCAM_RETURN_NO_ERROR;
28 #if RKAIQ_HAVE_DRC_V10
29 drcAttrV10_t attr_v10;
30 memset(&attr_v10, 0x0, sizeof(drcAttrV10_t));
31
32 // set sync
33 attr_v10.sync.sync_mode = attr.sync.sync_mode;
34 attr_v10.sync.done = attr.sync.done;
35 attr_v10.opMode = attr.opMode;
36 memcpy(&attr_v10.stAuto, &attr.stAutoV21, sizeof(adrcAttr_V21_t));
37 memcpy(&attr_v10.stManual, &attr.stManualV21, sizeof(mdrcAttr_V21_t));
38 ret = rk_aiq_user_api2_adrc_v10_SetAttrib(sys_ctx, &attr_v10);
39 #endif
40 #if RKAIQ_HAVE_DRC_V11
41 drcAttrV11_t attr_v11;
42 memset(&attr_v11, 0x0, sizeof(drcAttrV11_t));
43
44 // set sync
45 attr_v11.sync.sync_mode = attr.sync.sync_mode;
46 attr_v11.sync.done = attr.sync.done;
47 attr_v11.opMode = attr.opMode;
48 memcpy(&attr_v11.stAuto, &attr.stAutoV30, sizeof(adrcAttr_V30_t));
49 memcpy(&attr_v11.stManual, &attr.stManualV30, sizeof(mdrcAttr_V30_t));
50 ret = rk_aiq_user_api2_adrc_v11_SetAttrib(sys_ctx, &attr_v11);
51 #endif
52 return ret;
53 }
rk_aiq_user_api2_adrc_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drc_attrib_t * attr)54 XCamReturn rk_aiq_user_api2_adrc_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx, drc_attrib_t* attr) {
55 XCamReturn ret = XCAM_RETURN_NO_ERROR;
56 #if RKAIQ_HAVE_DRC_V10
57 drcAttrV10_t attr_v10;
58 memset(&attr_v10, 0x0, sizeof(drcAttrV10_t));
59 ret = rk_aiq_user_api2_adrc_v10_GetAttrib(sys_ctx, &attr_v10);
60 attr->sync.sync_mode = attr_v10.sync.sync_mode;
61 attr->sync.done = attr_v10.sync.done;
62 attr->Version = ADRC_VERSION_356X;
63 memcpy(&attr->stAutoV21, &attr_v10.stAuto, sizeof(adrcAttr_V21_t));
64 memcpy(&attr->stManualV21, &attr_v10.stManual, sizeof(mdrcAttr_V21_t));
65 attr->Info.CtrlInfo.ISO = attr_v10.Info.CtrlInfo.ISO;
66 attr->Info.CtrlInfo.EnvLv = attr_v10.Info.CtrlInfo.EnvLv;
67 memcpy(&attr->Info.ValidParamsV21, &attr_v10.Info.ValidParams, sizeof(mdrcAttr_V21_t));
68 #endif
69 #if RKAIQ_HAVE_DRC_V11
70 drcAttrV11_t attr_v11;
71 memset(&attr_v11, 0x0, sizeof(drcAttrV11_t));
72 ret = rk_aiq_user_api2_adrc_v11_GetAttrib(sys_ctx, &attr_v11);
73 attr->sync.sync_mode = attr_v11.sync.sync_mode;
74 attr->sync.done = attr_v11.sync.done;
75 attr->Version = ADRC_VERSION_3588;
76 memcpy(&attr->stAutoV30, &attr_v11.stAuto, sizeof(adrcAttr_V30_t));
77 memcpy(&attr->stManualV30, &attr_v11.stManual, sizeof(mdrcAttr_V30_t));
78 attr->Info.CtrlInfo.ISO = attr_v11.Info.CtrlInfo.ISO;
79 attr->Info.CtrlInfo.EnvLv = attr_v11.Info.CtrlInfo.EnvLv;
80 memcpy(&attr->Info.ValidParamsV30, &attr_v11.Info.ValidParams, sizeof(mdrcAttr_V30_t));
81 #endif
82 return ret;
83 }
84
85 #if RKAIQ_HAVE_DRC_V10
rk_aiq_user_api2_adrc_v10_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV10_t * attr)86 XCamReturn rk_aiq_user_api2_adrc_v10_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
87 const drcAttrV10_t* attr) {
88 CHECK_USER_API_ENABLE2(sys_ctx);
89 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ADRC);
90
91 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
92 #ifdef RKAIQ_ENABLE_CAMGROUP
93 RkAiqCamGroupAdrcHandleInt* algo_handle =
94 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
95
96 if (algo_handle) {
97 return algo_handle->setAttribV10(attr);
98 } else {
99 XCamReturn ret = XCAM_RETURN_NO_ERROR;
100 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
101 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
102 if (!camCtx)
103 continue;
104
105 RkAiqAdrcHandleInt* singleCam_algo_handle =
106 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
107 if (singleCam_algo_handle) {
108 ret = singleCam_algo_handle->setAttribV10(attr);
109 if (ret != XCAM_RETURN_NO_ERROR) LOGE("%s returned: %d", __FUNCTION__, ret);
110 }
111 }
112 return ret;
113 }
114 #else
115 return XCAM_RETURN_ERROR_FAILED;
116 #endif
117 } else {
118 RkAiqAdrcHandleInt* algo_handle =
119 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
120
121 if (algo_handle) {
122 return algo_handle->setAttribV10(attr);
123 }
124 }
125
126 return XCAM_RETURN_NO_ERROR;
127 }
128
rk_aiq_user_api2_adrc_v10_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV10_t * attr)129 XCamReturn rk_aiq_user_api2_adrc_v10_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
130 drcAttrV10_t* attr) {
131 RKAIQ_API_SMART_LOCK(sys_ctx);
132
133 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
134 #ifdef RKAIQ_ENABLE_CAMGROUP
135 RkAiqCamGroupAdrcHandleInt* algo_handle =
136 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
137
138 if (algo_handle) {
139 return algo_handle->getAttribV10(attr);
140 } else {
141 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
142 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
143 if (!camCtx) continue;
144
145 RkAiqAdrcHandleInt* singleCam_algo_handle =
146 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
147 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV10(attr);
148 }
149 }
150 #else
151 return XCAM_RETURN_ERROR_FAILED;
152 #endif
153 } else {
154 RkAiqAdrcHandleInt* algo_handle =
155 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
156
157 if (algo_handle) {
158 return algo_handle->getAttribV10(attr);
159 }
160 }
161
162 return XCAM_RETURN_NO_ERROR;
163 }
164 #else
rk_aiq_user_api2_adrc_v10_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV10_t * attr)165 XCamReturn rk_aiq_user_api2_adrc_v10_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
166 const drcAttrV10_t* attr) {
167 return XCAM_RETURN_ERROR_UNKNOWN;
168 }
169
rk_aiq_user_api2_adrc_v10_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV10_t * attr)170 XCamReturn rk_aiq_user_api2_adrc_v10_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
171 drcAttrV10_t* attr) {
172 return XCAM_RETURN_ERROR_UNKNOWN;
173 }
174 #endif
175
176 #if RKAIQ_HAVE_DRC_V11
rk_aiq_user_api2_adrc_v11_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV11_t * attr)177 XCamReturn rk_aiq_user_api2_adrc_v11_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
178 const drcAttrV11_t* attr) {
179 CHECK_USER_API_ENABLE2(sys_ctx);
180 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ADRC);
181 XCamReturn ret = XCAM_RETURN_NO_ERROR;
182
183 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
184 #ifdef RKAIQ_ENABLE_CAMGROUP
185 RkAiqCamGroupAdrcHandleInt* algo_handle =
186 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
187
188 if (algo_handle) {
189 return algo_handle->setAttribV11(attr);
190 } else {
191 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
192 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
193 if (!camCtx) continue;
194
195 RkAiqAdrcHandleInt* singleCam_algo_handle =
196 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
197 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttribV11(attr);
198 }
199 }
200 #else
201 return XCAM_RETURN_ERROR_FAILED;
202 #endif
203 } else {
204 RkAiqAdrcHandleInt* algo_handle =
205 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
206
207 if (algo_handle) {
208 return algo_handle->setAttribV11(attr);
209 }
210 }
211
212 return ret;
213 }
214
rk_aiq_user_api2_adrc_v11_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV11_t * attr)215 XCamReturn rk_aiq_user_api2_adrc_v11_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
216 drcAttrV11_t* attr) {
217 RKAIQ_API_SMART_LOCK(sys_ctx);
218
219 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
220 #ifdef RKAIQ_ENABLE_CAMGROUP
221 RkAiqCamGroupAdrcHandleInt* algo_handle =
222 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
223
224 if (algo_handle) {
225 return algo_handle->getAttribV11(attr);
226 } else {
227 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
228 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
229 if (!camCtx) continue;
230
231 RkAiqAdrcHandleInt* singleCam_algo_handle =
232 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
233 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV11(attr);
234 }
235 }
236 #else
237 return XCAM_RETURN_ERROR_FAILED;
238 #endif
239 } else {
240 RkAiqAdrcHandleInt* algo_handle =
241 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
242
243 if (algo_handle) {
244 return algo_handle->getAttribV11(attr);
245 }
246 }
247
248 return XCAM_RETURN_NO_ERROR;
249 }
250 #else
rk_aiq_user_api2_adrc_v11_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV11_t * attr)251 XCamReturn rk_aiq_user_api2_adrc_v11_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
252 const drcAttrV11_t* attr) {
253 return XCAM_RETURN_ERROR_UNKNOWN;
254 }
255
rk_aiq_user_api2_adrc_v11_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV11_t * attr)256 XCamReturn rk_aiq_user_api2_adrc_v11_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
257 drcAttrV11_t* attr) {
258 return XCAM_RETURN_ERROR_UNKNOWN;
259 }
260 #endif
261
262 #if RKAIQ_HAVE_DRC_V12
rk_aiq_user_api2_adrc_v12_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV12_t * attr)263 XCamReturn rk_aiq_user_api2_adrc_v12_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
264 const drcAttrV12_t* attr) {
265 CHECK_USER_API_ENABLE2(sys_ctx);
266 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ADRC);
267 XCamReturn ret = XCAM_RETURN_NO_ERROR;
268
269 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
270 #ifdef RKAIQ_ENABLE_CAMGROUP
271 RkAiqCamGroupAdrcHandleInt* algo_handle =
272 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
273
274 if (algo_handle) {
275 return algo_handle->setAttribV12(attr);
276 } else {
277 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t *)sys_ctx;
278 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
279 if (!camCtx)
280 continue;
281
282 RkAiqAdrcHandleInt* singleCam_algo_handle =
283 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
284 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttribV12(attr);
285 }
286 }
287 #else
288 return XCAM_RETURN_ERROR_FAILED;
289 #endif
290 } else {
291 RkAiqAdrcHandleInt* algo_handle =
292 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
293
294 if (algo_handle) {
295 return algo_handle->setAttribV12(attr);
296 }
297 }
298
299 return ret;
300 }
301
rk_aiq_user_api2_adrc_v12_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV12_t * attr)302 XCamReturn rk_aiq_user_api2_adrc_v12_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
303 drcAttrV12_t* attr) {
304 RKAIQ_API_SMART_LOCK(sys_ctx);
305
306 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
307 #ifdef RKAIQ_ENABLE_CAMGROUP
308 RkAiqCamGroupAdrcHandleInt* algo_handle =
309 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
310
311 if (algo_handle) {
312 return algo_handle->getAttribV12(attr);
313 } else {
314 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
315 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
316 if (!camCtx) continue;
317
318 RkAiqAdrcHandleInt* singleCam_algo_handle =
319 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
320 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV12(attr);
321 }
322 }
323 #else
324 return XCAM_RETURN_ERROR_FAILED;
325 #endif
326 } else {
327 RkAiqAdrcHandleInt* algo_handle =
328 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
329
330 if (algo_handle) {
331 return algo_handle->getAttribV12(attr);
332 }
333 }
334
335 return XCAM_RETURN_NO_ERROR;
336 }
337 #else
rk_aiq_user_api2_adrc_v12_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV12_t * attr)338 XCamReturn rk_aiq_user_api2_adrc_v12_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
339 const drcAttrV12_t* attr) {
340 return XCAM_RETURN_ERROR_UNKNOWN;
341 }
342
rk_aiq_user_api2_adrc_v12_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV12_t * attr)343 XCamReturn rk_aiq_user_api2_adrc_v12_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
344 drcAttrV12_t* attr) {
345 return XCAM_RETURN_ERROR_UNKNOWN;
346 }
347 #endif
348 #if RKAIQ_HAVE_DRC_V12_LITE
rk_aiq_user_api2_adrc_v12_lite_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV12Lite_t * attr)349 XCamReturn rk_aiq_user_api2_adrc_v12_lite_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
350 const drcAttrV12Lite_t* attr) {
351 CHECK_USER_API_ENABLE2(sys_ctx);
352 CHECK_USER_API_ENABLE(RK_AIQ_ALGO_TYPE_ADRC);
353 XCamReturn ret = XCAM_RETURN_NO_ERROR;
354
355 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
356 #ifdef RKAIQ_ENABLE_CAMGROUP
357 RkAiqCamGroupAdrcHandleInt* algo_handle =
358 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
359
360 if (algo_handle) {
361 return algo_handle->setAttribV12Lite(attr);
362 } else {
363 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
364 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
365 if (!camCtx) continue;
366
367 RkAiqAdrcHandleInt* singleCam_algo_handle =
368 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
369 if (singleCam_algo_handle) ret = singleCam_algo_handle->setAttribV12Lite(attr);
370 }
371 }
372 #else
373 return XCAM_RETURN_ERROR_FAILED;
374 #endif
375 } else {
376 RkAiqAdrcHandleInt* algo_handle =
377 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
378
379 if (algo_handle) {
380 return algo_handle->setAttribV12Lite(attr);
381 }
382 }
383
384 return ret;
385 }
386
rk_aiq_user_api2_adrc_v12_lite_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV12Lite_t * attr)387 XCamReturn rk_aiq_user_api2_adrc_v12_lite_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
388 drcAttrV12Lite_t* attr) {
389 RKAIQ_API_SMART_LOCK(sys_ctx);
390
391 if (sys_ctx->cam_type == RK_AIQ_CAM_TYPE_GROUP) {
392 #ifdef RKAIQ_ENABLE_CAMGROUP
393 RkAiqCamGroupAdrcHandleInt* algo_handle =
394 camgroupAlgoHandle<RkAiqCamGroupAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
395
396 if (algo_handle) {
397 return algo_handle->getAttribV12Lite(attr);
398 } else {
399 const rk_aiq_camgroup_ctx_t* camgroup_ctx = (rk_aiq_camgroup_ctx_t*)sys_ctx;
400 for (auto camCtx : camgroup_ctx->cam_ctxs_array) {
401 if (!camCtx) continue;
402
403 RkAiqAdrcHandleInt* singleCam_algo_handle =
404 algoHandle<RkAiqAdrcHandleInt>(camCtx, RK_AIQ_ALGO_TYPE_ADRC);
405 if (singleCam_algo_handle) return singleCam_algo_handle->getAttribV12Lite(attr);
406 }
407 }
408 #else
409 return XCAM_RETURN_ERROR_FAILED;
410 #endif
411 } else {
412 RkAiqAdrcHandleInt* algo_handle =
413 algoHandle<RkAiqAdrcHandleInt>(sys_ctx, RK_AIQ_ALGO_TYPE_ADRC);
414
415 if (algo_handle) {
416 return algo_handle->getAttribV12Lite(attr);
417 }
418 }
419
420 return XCAM_RETURN_NO_ERROR;
421 }
422 #else
rk_aiq_user_api2_adrc_v12_lite_SetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,const drcAttrV12Lite_t * attr)423 XCamReturn rk_aiq_user_api2_adrc_v12_lite_SetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
424 const drcAttrV12Lite_t* attr) {
425 return XCAM_RETURN_ERROR_UNKNOWN;
426 }
427
rk_aiq_user_api2_adrc_v12_lite_GetAttrib(const rk_aiq_sys_ctx_t * sys_ctx,drcAttrV12Lite_t * attr)428 XCamReturn rk_aiq_user_api2_adrc_v12_lite_GetAttrib(const rk_aiq_sys_ctx_t* sys_ctx,
429 drcAttrV12Lite_t* attr) {
430 return XCAM_RETURN_ERROR_UNKNOWN;
431 }
432 #endif
433
434 RKAIQ_END_DECLARE
435