1 /*
2 * rk_aiq_algo_camgroup_adrc_itf.c
3 *
4 * Copyright (c) 2019 Rockchip Corporation
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 */
19
20 #include "rk_aiq_algo_camgroup_types.h"
21 #include "algos/adrc/rk_aiq_algo_adrc_itf.h"
22 #include "xcam_log.h"
23 #if RKAIQ_HAVE_DRC_V10
24 #include "adrc/rk_aiq_adrc_algo_v10.h"
25 #endif
26 #if RKAIQ_HAVE_DRC_V11
27 #include "adrc/rk_aiq_adrc_algo_v11.h"
28 #endif
29 #if RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE
30 #include "adrc/rk_aiq_adrc_algo_v12.h"
31 #endif
32
33 RKAIQ_BEGIN_DECLARE
34
35 static XCamReturn
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)36 create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
37 {
38 LOG1_ATMO(" %s:Enter!\n", __FUNCTION__);
39 XCamReturn result = XCAM_RETURN_NO_ERROR;
40
41 AlgoCtxInstanceCfgCamGroup* instanc_int = (AlgoCtxInstanceCfgCamGroup*)cfg;
42 AdrcContext_t* pAdrcGrpCtx = NULL;
43
44 result = AdrcInit(&pAdrcGrpCtx, (CamCalibDbV2Context_t*)(instanc_int->s_calibv2));
45
46 if (result != XCAM_RETURN_NO_ERROR) {
47 LOGE_ATMO("%s Adrc Init failed: %d", __FUNCTION__, result);
48 return(XCAM_RETURN_ERROR_FAILED);
49 }
50 *context = (RkAiqAlgoContext *)(pAdrcGrpCtx);
51
52 LOG1_ATMO(" %s:Exit!\n", __FUNCTION__);
53 return result;
54 }
55
56 static XCamReturn
destroy_context(RkAiqAlgoContext * context)57 destroy_context(RkAiqAlgoContext *context)
58 {
59 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
60 XCamReturn result = XCAM_RETURN_NO_ERROR;
61
62 if(context != NULL) {
63
64 AdrcContext_t* pAdrcGrpCtx = (AdrcContext_t*)context;
65 result = AdrcRelease(pAdrcGrpCtx);
66 if (result != XCAM_RETURN_NO_ERROR) {
67 LOGE_ATMO("%s Adrc Release failed: %d", __FUNCTION__, result);
68 return(XCAM_RETURN_ERROR_FAILED);
69 }
70 context = NULL;
71 }
72
73 LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
74 return result;
75 }
76
77 static XCamReturn
prepare(RkAiqAlgoCom * params)78 prepare(RkAiqAlgoCom* params)
79 {
80 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
81 XCamReturn result = XCAM_RETURN_NO_ERROR;
82
83 AdrcContext_t* pAdrcGrpCtx = (AdrcContext_t*)params->ctx;
84 RkAiqAlgoCamGroupPrepare* AdrcCfgParam = (RkAiqAlgoCamGroupPrepare*)params; //come from params in html
85 const CamCalibDbV2Context_t* pCalibDb = AdrcCfgParam->s_calibv2;
86
87 if (AdrcCfgParam->gcom.com.u.prepare.working_mode < RK_AIQ_WORKING_MODE_ISP_HDR2)
88 pAdrcGrpCtx->FrameNumber = LINEAR_NUM;
89 else if (AdrcCfgParam->gcom.com.u.prepare.working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3 &&
90 AdrcCfgParam->gcom.com.u.prepare.working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2)
91 pAdrcGrpCtx->FrameNumber = HDR_2X_NUM;
92 else
93 pAdrcGrpCtx->FrameNumber = HDR_3X_NUM;
94
95 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
96 LOGI_ATMO("%s: Adrc Reload Para!\n", __FUNCTION__);
97 #if RKAIQ_HAVE_DRC_V10
98 CalibDbV2_drc_V10_t* calibv2_adrc_calib =
99 (CalibDbV2_drc_V10_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
100 memcpy(&pAdrcGrpCtx->drcAttrV10.stAuto, calibv2_adrc_calib,
101 sizeof(CalibDbV2_drc_V10_t)); // reload stAuto
102 #endif
103 #if RKAIQ_HAVE_DRC_V11
104 CalibDbV2_drc_V11_t* calibv2_adrc_calib =
105 (CalibDbV2_drc_V11_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
106 memcpy(&pAdrcGrpCtx->drcAttrV11.stAuto, calibv2_adrc_calib,
107 sizeof(CalibDbV2_drc_V11_t)); // reload stAuto
108 #endif
109 #if RKAIQ_HAVE_DRC_V12
110 CalibDbV2_drc_V12_t* calibv2_adrc_calib =
111 (CalibDbV2_drc_V12_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
112 memcpy(&pAdrcGrpCtx->drcAttrV12.stAuto, calibv2_adrc_calib,
113 sizeof(CalibDbV2_drc_V12_t)); // reload stAuto
114 #endif
115 #if RKAIQ_HAVE_DRC_V12_LITE
116 CalibDbV2_drc_v12_lite_t* calibv2_adrc_calib =
117 (CalibDbV2_drc_v12_lite_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
118 memcpy(&pAdrcGrpCtx->drcAttrV12.stAuto, calibv2_adrc_calib,
119 sizeof(CalibDbV2_drc_v12_lite_t)); // reload stAuto
120 #endif
121 pAdrcGrpCtx->ifReCalcStAuto = true;
122 } else if (params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_CHANGERES) {
123 pAdrcGrpCtx->isCapture = true;
124 }
125
126 if(/* !params->u.prepare.reconfig*/true) {
127 AdrcStop(pAdrcGrpCtx); // stop firstly for re-preapre
128 result = AdrcStart(pAdrcGrpCtx);
129 if (result != XCAM_RETURN_NO_ERROR) {
130 LOGE_ATMO("%s Adrc Start failed: %d", __FUNCTION__, result);
131 return(XCAM_RETURN_ERROR_FAILED);
132 }
133 }
134
135 LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
136 return result;
137 }
138
139 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)140 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
141 {
142 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
143 XCamReturn result = XCAM_RETURN_NO_ERROR;
144 bool bypass_tuning_params = true;
145 bool bypass_expo_params = true;
146 AdrcContext_t* pAdrcGrpCtx = (AdrcContext_t*)inparams->ctx;
147 pAdrcGrpCtx->FrameID = inparams->frame_id;
148 RkAiqAlgoCamGroupProcIn* pAdrcGrpParams = (RkAiqAlgoCamGroupProcIn*)inparams;
149 RkAiqAlgoCamGroupProcOut* pAdrcGrpProcRes = (RkAiqAlgoCamGroupProcOut*)outparams;
150
151 LOGD_ATMO(
152 "%s:////////////////////////////////////////////ADRC Group "
153 "Start//////////////////////////////////////////// \n",
154 __func__);
155
156 if (pAdrcGrpCtx->isCapture) {
157 LOGD_ATMO("%s: It's capturing, using pre frame params\n", __func__);
158 pAdrcGrpCtx->isCapture = false;
159 } else {
160 #if RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE
161 pAdrcGrpCtx->ablcV32_proc_res.blc_ob_enable =
162 pAdrcGrpParams->camgroupParmasArray[0]->ablc._blcConfig_v32->blc_ob_enable;
163 pAdrcGrpCtx->ablcV32_proc_res.isp_ob_predgain =
164 pAdrcGrpParams->camgroupParmasArray[0]->ablc._blcConfig_v32->isp_ob_predgain;
165 #endif
166 if (DrcEnableSetting(pAdrcGrpCtx, pAdrcGrpProcRes->camgroupParmasArray[0]->_adrcConfig)) {
167 // get LongFrmMode
168 RkAiqAlgoProcResAeShared_t* pAEProcRes = &pAdrcGrpParams->camgroupParmasArray[0]->aec._aeProcRes;
169 pAdrcGrpCtx->NextData.AEData.LongFrmMode = pAEProcRes->LongFrmMode;
170
171 // get eff expo
172 if (pAdrcGrpCtx->FrameNumber == LINEAR_NUM) {
173 pAdrcGrpCtx->NextData.AEData.SExpo =
174 pAdrcGrpParams->camgroupParmasArray[0]
175 ->aec._effAecExpInfo.LinearExp.exp_real_params.analog_gain *
176 pAdrcGrpParams->camgroupParmasArray[0]
177 ->aec._effAecExpInfo.LinearExp.exp_real_params.digital_gain *
178 pAdrcGrpParams->camgroupParmasArray[0]
179 ->aec._effAecExpInfo.LinearExp.exp_real_params.isp_dgain *
180 pAdrcGrpParams->camgroupParmasArray[0]
181 ->aec._effAecExpInfo.LinearExp.exp_real_params.integration_time;
182 pAdrcGrpCtx->NextData.AEData.MExpo = pAdrcGrpCtx->NextData.AEData.SExpo;
183 pAdrcGrpCtx->NextData.AEData.LExpo = pAdrcGrpCtx->NextData.AEData.SExpo;
184 pAdrcGrpCtx->NextData.AEData.ISO =
185 pAdrcGrpParams->camgroupParmasArray[0]
186 ->aec._effAecExpInfo.LinearExp.exp_real_params.analog_gain *
187 pAdrcGrpParams->camgroupParmasArray[0]
188 ->aec._effAecExpInfo.LinearExp.exp_real_params.digital_gain *
189 pAdrcGrpParams->camgroupParmasArray[0]
190 ->aec._effAecExpInfo.LinearExp.exp_real_params.isp_dgain *
191 ISOMIN;
192 #if RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE
193 if (pAdrcGrpCtx->ablcV32_proc_res.blc_ob_enable) {
194 if (pAdrcGrpCtx->ablcV32_proc_res.isp_ob_predgain < ISP_PREDGAIN_DEFAULT) {
195 LOGE_ATMO("%s: ob_enable ON, and ob_predgain[%f] < 1.0f, clip to 1.0!!!\n",
196 __FUNCTION__, pAdrcGrpCtx->ablcV32_proc_res.isp_ob_predgain);
197 pAdrcGrpCtx->ablcV32_proc_res.isp_ob_predgain = ISP_PREDGAIN_DEFAULT;
198 }
199 pAdrcGrpCtx->NextData.AEData.ISO *= pAdrcGrpCtx->ablcV32_proc_res.isp_ob_predgain;
200 }
201 #endif
202 pAdrcGrpCtx->NextData.AEData.ISO =
203 LIMIT_VALUE(pAdrcGrpCtx->NextData.AEData.ISO, ISOMAX, ISOMIN);
204 } else if (pAdrcGrpCtx->FrameNumber == HDR_2X_NUM) {
205 pAdrcGrpCtx->NextData.AEData.SExpo = pAdrcGrpParams->camgroupParmasArray[0]
206 ->aec._effAecExpInfo.HdrExp[0]
207 .exp_real_params.analog_gain *
208 pAdrcGrpParams->camgroupParmasArray[0]
209 ->aec._effAecExpInfo.HdrExp[0]
210 .exp_real_params.digital_gain *
211 pAdrcGrpParams->camgroupParmasArray[0]
212 ->aec._effAecExpInfo.HdrExp[0]
213 .exp_real_params.isp_dgain *
214 pAdrcGrpParams->camgroupParmasArray[0]
215 ->aec._effAecExpInfo.HdrExp[0]
216 .exp_real_params.integration_time;
217 pAdrcGrpCtx->NextData.AEData.MExpo = pAdrcGrpParams->camgroupParmasArray[0]
218 ->aec._effAecExpInfo.HdrExp[1]
219 .exp_real_params.analog_gain *
220 pAdrcGrpParams->camgroupParmasArray[0]
221 ->aec._effAecExpInfo.HdrExp[1]
222 .exp_real_params.digital_gain *
223 pAdrcGrpParams->camgroupParmasArray[0]
224 ->aec._effAecExpInfo.HdrExp[1]
225 .exp_real_params.isp_dgain *
226 pAdrcGrpParams->camgroupParmasArray[0]
227 ->aec._effAecExpInfo.HdrExp[1]
228 .exp_real_params.integration_time;
229 pAdrcGrpCtx->NextData.AEData.LExpo = pAdrcGrpCtx->NextData.AEData.MExpo;
230 pAdrcGrpCtx->NextData.AEData.ISO = pAdrcGrpParams->camgroupParmasArray[0]
231 ->aec._effAecExpInfo.HdrExp[1]
232 .exp_real_params.analog_gain *
233 pAdrcGrpParams->camgroupParmasArray[0]
234 ->aec._effAecExpInfo.HdrExp[1]
235 .exp_real_params.digital_gain *
236 pAdrcGrpParams->camgroupParmasArray[0]
237 ->aec._effAecExpInfo.HdrExp[1]
238 .exp_real_params.isp_dgain *
239 ISOMIN;
240 pAdrcGrpCtx->NextData.AEData.ISO =
241 LIMIT_VALUE(pAdrcGrpCtx->NextData.AEData.ISO, ISOMAX, ISOMIN);
242 } else if (pAdrcGrpCtx->FrameNumber == HDR_3X_NUM) {
243 pAdrcGrpCtx->NextData.AEData.SExpo = pAdrcGrpParams->camgroupParmasArray[0]
244 ->aec._effAecExpInfo.HdrExp[0]
245 .exp_real_params.analog_gain *
246 pAdrcGrpParams->camgroupParmasArray[0]
247 ->aec._effAecExpInfo.HdrExp[0]
248 .exp_real_params.digital_gain *
249 pAdrcGrpParams->camgroupParmasArray[0]
250 ->aec._effAecExpInfo.HdrExp[0]
251 .exp_real_params.isp_dgain *
252 pAdrcGrpParams->camgroupParmasArray[0]
253 ->aec._effAecExpInfo.HdrExp[0]
254 .exp_real_params.integration_time;
255 pAdrcGrpCtx->NextData.AEData.MExpo = pAdrcGrpParams->camgroupParmasArray[0]
256 ->aec._effAecExpInfo.HdrExp[1]
257 .exp_real_params.analog_gain *
258 pAdrcGrpParams->camgroupParmasArray[0]
259 ->aec._effAecExpInfo.HdrExp[1]
260 .exp_real_params.digital_gain *
261 pAdrcGrpParams->camgroupParmasArray[0]
262 ->aec._effAecExpInfo.HdrExp[1]
263 .exp_real_params.isp_dgain *
264 pAdrcGrpParams->camgroupParmasArray[0]
265 ->aec._effAecExpInfo.HdrExp[1]
266 .exp_real_params.integration_time;
267 pAdrcGrpCtx->NextData.AEData.LExpo = pAdrcGrpParams->camgroupParmasArray[0]
268 ->aec._effAecExpInfo.HdrExp[2]
269 .exp_real_params.analog_gain *
270 pAdrcGrpParams->camgroupParmasArray[0]
271 ->aec._effAecExpInfo.HdrExp[2]
272 .exp_real_params.digital_gain *
273 pAdrcGrpParams->camgroupParmasArray[0]
274 ->aec._effAecExpInfo.HdrExp[2]
275 .exp_real_params.isp_dgain *
276 pAdrcGrpParams->camgroupParmasArray[0]
277 ->aec._effAecExpInfo.HdrExp[2]
278 .exp_real_params.integration_time;
279 pAdrcGrpCtx->NextData.AEData.ISO = pAdrcGrpParams->camgroupParmasArray[0]
280 ->aec._effAecExpInfo.HdrExp[1]
281 .exp_real_params.analog_gain *
282 pAdrcGrpParams->camgroupParmasArray[0]
283 ->aec._effAecExpInfo.HdrExp[1]
284 .exp_real_params.digital_gain *
285 pAdrcGrpParams->camgroupParmasArray[0]
286 ->aec._effAecExpInfo.HdrExp[1]
287 .exp_real_params.isp_dgain *
288 ISOMIN;
289 pAdrcGrpCtx->NextData.AEData.ISO =
290 LIMIT_VALUE(pAdrcGrpCtx->NextData.AEData.ISO, ISOMAX, ISOMIN);
291 }
292 if (pAdrcGrpCtx->FrameNumber == HDR_2X_NUM || pAdrcGrpCtx->FrameNumber == HDR_2X_NUM) {
293 LOGV_ATMO("%s: nextFrame: sexp: %f-%f, mexp: %f-%f, lexp: %f-%f\n", __FUNCTION__,
294 pAdrcGrpParams->camgroupParmasArray[0]
295 ->aec._effAecExpInfo.HdrExp[0]
296 .exp_real_params.analog_gain *
297 pAdrcGrpParams->camgroupParmasArray[0]
298 ->aec._effAecExpInfo.HdrExp[0]
299 .exp_real_params.digital_gain *
300 pAdrcGrpParams->camgroupParmasArray[0]
301 ->aec._effAecExpInfo.HdrExp[0]
302 .exp_real_params.isp_dgain,
303 pAdrcGrpParams->camgroupParmasArray[0]
304 ->aec._effAecExpInfo.HdrExp[0]
305 .exp_real_params.integration_time,
306 pAdrcGrpParams->camgroupParmasArray[0]
307 ->aec._effAecExpInfo.HdrExp[1]
308 .exp_real_params.analog_gain *
309 pAdrcGrpParams->camgroupParmasArray[0]
310 ->aec._effAecExpInfo.HdrExp[1]
311 .exp_real_params.digital_gain *
312 pAdrcGrpParams->camgroupParmasArray[0]
313 ->aec._effAecExpInfo.HdrExp[1]
314 .exp_real_params.isp_dgain,
315 pAdrcGrpParams->camgroupParmasArray[0]
316 ->aec._effAecExpInfo.HdrExp[1]
317 .exp_real_params.integration_time,
318 pAdrcGrpParams->camgroupParmasArray[0]
319 ->aec._effAecExpInfo.HdrExp[2]
320 .exp_real_params.analog_gain *
321 pAdrcGrpParams->camgroupParmasArray[0]
322 ->aec._effAecExpInfo.HdrExp[2]
323 .exp_real_params.digital_gain *
324 pAdrcGrpParams->camgroupParmasArray[0]
325 ->aec._effAecExpInfo.HdrExp[2]
326 .exp_real_params.isp_dgain,
327 pAdrcGrpParams->camgroupParmasArray[0]
328 ->aec._effAecExpInfo.HdrExp[2]
329 .exp_real_params.integration_time);
330 } else if (pAdrcGrpCtx->FrameNumber == LINEAR_NUM) {
331 LOGV_ATMO("%s: nextFrame: exp: %f-%f\n", __FUNCTION__,
332 pAdrcGrpParams->camgroupParmasArray[0]
333 ->aec._effAecExpInfo.LinearExp.exp_real_params.analog_gain *
334 pAdrcGrpParams->camgroupParmasArray[0]
335 ->aec._effAecExpInfo.LinearExp.exp_real_params.digital_gain *
336 pAdrcGrpParams->camgroupParmasArray[0]
337 ->aec._effAecExpInfo.LinearExp.exp_real_params.isp_dgain,
338 pAdrcGrpParams->camgroupParmasArray[0]
339 ->aec._effAecExpInfo.LinearExp.exp_real_params.integration_time);
340 }
341 if (pAdrcGrpCtx->NextData.AEData.SExpo > FLT_EPSILON) {
342 pAdrcGrpCtx->NextData.AEData.L2S_Ratio =
343 pAdrcGrpCtx->NextData.AEData.LExpo / pAdrcGrpCtx->NextData.AEData.SExpo;
344 pAdrcGrpCtx->NextData.AEData.M2S_Ratio =
345 pAdrcGrpCtx->NextData.AEData.MExpo / pAdrcGrpCtx->NextData.AEData.SExpo;
346 } else
347 LOGE_ATMO("%s: Next frame for drc expo sync is ERROR!!!\n", __FUNCTION__);
348 if (pAdrcGrpCtx->NextData.AEData.MExpo > FLT_EPSILON)
349 pAdrcGrpCtx->NextData.AEData.L2M_Ratio =
350 pAdrcGrpCtx->NextData.AEData.LExpo / pAdrcGrpCtx->NextData.AEData.MExpo;
351 else
352 LOGE_ATMO("%s: Next Midlle frame for drc expo sync is ERROR!!!\n", __FUNCTION__);
353 // clip for long frame mode
354 if (pAdrcGrpCtx->NextData.AEData.LongFrmMode) {
355 pAdrcGrpCtx->NextData.AEData.L2S_Ratio = LONG_FRAME_MODE_RATIO;
356 pAdrcGrpCtx->NextData.AEData.M2S_Ratio = LONG_FRAME_MODE_RATIO;
357 pAdrcGrpCtx->NextData.AEData.L2M_Ratio = LONG_FRAME_MODE_RATIO;
358 }
359
360 // get bypass_expo_params
361 if (pAdrcGrpCtx->NextData.AEData.L2S_Ratio >= RATIO_DEFAULT &&
362 pAdrcGrpCtx->NextData.AEData.L2M_Ratio >= RATIO_DEFAULT) {
363 if (pAdrcGrpCtx->FrameID <= INIT_CALC_PARAMS_NUM)
364 bypass_expo_params = false;
365 else if (pAdrcGrpCtx->ifReCalcStAuto || pAdrcGrpCtx->ifReCalcStManual)
366 bypass_expo_params = false;
367 else if (!pAdrcGrpCtx->CurrData.AEData.LongFrmMode !=
368 !pAdrcGrpCtx->NextData.AEData.LongFrmMode)
369 bypass_expo_params = false;
370 else if ((pAdrcGrpCtx->CurrData.AEData.L2M_Ratio -
371 pAdrcGrpCtx->NextData.AEData.L2M_Ratio) > FLT_EPSILON ||
372 (pAdrcGrpCtx->CurrData.AEData.L2M_Ratio -
373 pAdrcGrpCtx->NextData.AEData.L2M_Ratio) < -FLT_EPSILON ||
374 (pAdrcGrpCtx->CurrData.AEData.M2S_Ratio -
375 pAdrcGrpCtx->NextData.AEData.M2S_Ratio) > FLT_EPSILON ||
376 (pAdrcGrpCtx->CurrData.AEData.M2S_Ratio -
377 pAdrcGrpCtx->NextData.AEData.M2S_Ratio) < -FLT_EPSILON ||
378 (pAdrcGrpCtx->CurrData.AEData.L2S_Ratio -
379 pAdrcGrpCtx->NextData.AEData.L2S_Ratio) > FLT_EPSILON ||
380 (pAdrcGrpCtx->CurrData.AEData.L2S_Ratio -
381 pAdrcGrpCtx->NextData.AEData.L2S_Ratio) < -FLT_EPSILON)
382 bypass_expo_params = false;
383 else
384 bypass_expo_params = true;
385 } else {
386 LOGE_ATMO("%s(%d): AE L2S_Ratio:%f L2M_Ratio:%f for drc expo sync is under one!!!\n",
387 __FUNCTION__, __LINE__, pAdrcGrpCtx->NextData.AEData.L2S_Ratio,
388 pAdrcGrpCtx->NextData.AEData.L2M_Ratio);
389 bypass_expo_params = true;
390 }
391
392 // get ae pre res and bypass_tuning_params
393 XCamVideoBuffer* xCamAePreRes = pAdrcGrpParams->camgroupParmasArray[0]->aec._aePreRes;
394 RkAiqAlgoPreResAe* pAEPreRes = NULL;
395 if (xCamAePreRes) {
396 pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
397 if (pAdrcGrpCtx->FrameNumber == LINEAR_NUM)
398 pAdrcGrpCtx->NextData.AEData.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[0];
399 else if (pAdrcGrpCtx->FrameNumber == HDR_2X_NUM ||
400 pAdrcGrpCtx->FrameNumber == HDR_3X_NUM)
401 pAdrcGrpCtx->NextData.AEData.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[1];
402 else
403 pAdrcGrpCtx->NextData.AEData.EnvLv = ENVLVMIN;
404 // Normalize the current envLv for AEC
405 pAdrcGrpCtx->NextData.AEData.EnvLv =
406 (pAdrcGrpCtx->NextData.AEData.EnvLv - MIN_ENV_LV) / (MAX_ENV_LV - MIN_ENV_LV);
407 pAdrcGrpCtx->NextData.AEData.EnvLv =
408 LIMIT_VALUE(pAdrcGrpCtx->NextData.AEData.EnvLv, ENVLVMAX, ENVLVMIN);
409 } else {
410 pAdrcGrpCtx->NextData.AEData.EnvLv = ENVLVMIN;
411 LOGW_ATMO("%s: ae Pre result is null!!!\n", __FUNCTION__);
412 }
413
414 // get motion coef
415 pAdrcGrpCtx->NextData.MotionCoef = MOVE_COEF_DEFAULT;
416
417 // get bypass_tuning_params
418 bypass_tuning_params = AdrcByPassTuningProcessing(pAdrcGrpCtx);
419
420 // get tuning paras
421 if (!bypass_tuning_params || !pAdrcGrpCtx->isDampStable)
422 AdrcTuningParaProcessing(pAdrcGrpCtx,
423 pAdrcGrpProcRes->camgroupParmasArray[0]->_adrcConfig);
424
425 // expo para process
426 if (!bypass_expo_params || !bypass_tuning_params || !pAdrcGrpCtx->isDampStable)
427 AdrcExpoParaProcessing(pAdrcGrpCtx,
428 pAdrcGrpProcRes->camgroupParmasArray[0]->_adrcConfig);
429 } else {
430 LOGD_ATMO("%s: Group Drc Enable is OFF, Bypass Drc !!! \n", __func__);
431 }
432 }
433 LOGD_ATMO(
434 "%s:////////////////////////////////////////////ADRC Group "
435 "Over//////////////////////////////////////////// \n",
436 __func__);
437
438 // output ProcRes
439 for (int i = 1; i < pAdrcGrpProcRes->arraySize; i++) {
440 outparams->cfg_update = !bypass_tuning_params || !bypass_expo_params ||
441 pAdrcGrpCtx->ifReCalcStAuto || pAdrcGrpCtx->ifReCalcStManual ||
442 !pAdrcGrpCtx->isDampStable || inparams->u.proc.init;
443 pAdrcGrpProcRes->camgroupParmasArray[i]->_adrcConfig->bDrcEn =
444 pAdrcGrpProcRes->camgroupParmasArray[0]->_adrcConfig->bDrcEn;
445 pAdrcGrpProcRes->camgroupParmasArray[i]->_adrcConfig->DrcProcRes =
446 pAdrcGrpProcRes->camgroupParmasArray[0]->_adrcConfig->DrcProcRes;
447 IS_UPDATE_MEM((pAdrcGrpProcRes->camgroupParmasArray[i]->_adrcConfig), pAdrcGrpParams->_offset_is_update) =
448 outparams->cfg_update;
449 }
450 if (pAdrcGrpCtx->ifReCalcStAuto) pAdrcGrpCtx->ifReCalcStAuto = false;
451 if (pAdrcGrpCtx->ifReCalcStManual) pAdrcGrpCtx->ifReCalcStManual = false;
452 // store expo data
453 pAdrcGrpCtx->CurrData.AEData.LongFrmMode = pAdrcGrpCtx->NextData.AEData.LongFrmMode;
454 pAdrcGrpCtx->CurrData.AEData.L2M_Ratio = pAdrcGrpCtx->NextData.AEData.L2M_Ratio;
455 pAdrcGrpCtx->CurrData.AEData.M2S_Ratio = pAdrcGrpCtx->NextData.AEData.M2S_Ratio;
456 pAdrcGrpCtx->CurrData.AEData.L2S_Ratio = pAdrcGrpCtx->NextData.AEData.L2S_Ratio;
457
458 LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
459 return XCAM_RETURN_NO_ERROR;
460 }
461
462 RkAiqAlgoDescription g_RkIspAlgoDescCamgroupAdrc = {
463 .common = {
464 .version = RKISP_ALGO_ADRC_VERSION,
465 .vendor = RKISP_ALGO_ADRC_VENDOR,
466 .description = RKISP_ALGO_ADRC_DESCRIPTION,
467 .type = RK_AIQ_ALGO_TYPE_ADRC,
468 .id = 0,
469 .create_context = create_context,
470 .destroy_context = destroy_context,
471 },
472 .prepare = prepare,
473 .pre_process = NULL,
474 .processing = processing,
475 .post_process = NULL,
476 };
477
478 RKAIQ_END_DECLARE
479