1 /*
2 * rk_aiq_algo_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 "adrc/rk_aiq_algo_adrc_itf.h"
21 #include "xcam_log.h"
22 #if RKAIQ_HAVE_DRC_V10
23 #include "adrc/rk_aiq_adrc_algo_v10.h"
24 #endif
25 #if RKAIQ_HAVE_DRC_V11
26 #include "adrc/rk_aiq_adrc_algo_v11.h"
27 #endif
28 #if RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE
29 #include "adrc/rk_aiq_adrc_algo_v12.h"
30 #endif
31 #include "adrc/rk_aiq_types_adrc_algo_prvt.h"
32
33 RKAIQ_BEGIN_DECLARE
34
35
36 static XCamReturn
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)37 create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
38 {
39 LOG1_ATMO(" %s:Enter!\n", __FUNCTION__);
40 XCamReturn result = XCAM_RETURN_NO_ERROR;
41 AdrcContext_t* pAdrcCtx = NULL;
42
43 result = AdrcInit(&pAdrcCtx, (CamCalibDbV2Context_t*)(cfg->calibv2));
44
45 if (result != XCAM_RETURN_NO_ERROR) {
46 LOGE_ATMO("%s Adrc Init failed: %d", __FUNCTION__, result);
47 return(XCAM_RETURN_ERROR_FAILED);
48 }
49 *context = (RkAiqAlgoContext *)(pAdrcCtx);
50
51 LOG1_ATMO(" %s:Exit!\n", __FUNCTION__);
52 return result;
53 }
54
55 static XCamReturn
destroy_context(RkAiqAlgoContext * context)56 destroy_context(RkAiqAlgoContext *context)
57 {
58 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
59 XCamReturn result = XCAM_RETURN_NO_ERROR;
60
61 if(context != NULL) {
62
63 AdrcContext_t* pAdrcCtx = (AdrcContext_t*)context;
64 result = AdrcRelease(pAdrcCtx);
65 if (result != XCAM_RETURN_NO_ERROR) {
66 LOGE_ATMO("%s Adrc Release failed: %d", __FUNCTION__, result);
67 return(XCAM_RETURN_ERROR_FAILED);
68 }
69 context = NULL;
70 }
71
72 LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
73 return result;
74 }
75
76 static XCamReturn
prepare(RkAiqAlgoCom * params)77 prepare(RkAiqAlgoCom* params)
78 {
79 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
80 XCamReturn result = XCAM_RETURN_NO_ERROR;
81
82 AdrcContext_t* pAdrcCtx = (AdrcContext_t*)params->ctx;
83 RkAiqAlgoConfigAdrc* AdrcCfgParam = (RkAiqAlgoConfigAdrc*)params; //come from params in html
84 const CamCalibDbV2Context_t* pCalibDb = AdrcCfgParam->com.u.prepare.calibv2;
85
86 if (AdrcCfgParam->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR2)
87 pAdrcCtx->FrameNumber = LINEAR_NUM;
88 else if (AdrcCfgParam->working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3 &&
89 AdrcCfgParam->working_mode >= RK_AIQ_WORKING_MODE_ISP_HDR2)
90 pAdrcCtx->FrameNumber = HDR_2X_NUM;
91 else
92 pAdrcCtx->FrameNumber = HDR_3X_NUM;
93
94 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
95 LOGI_ATMO("%s: Adrc Reload Para!\n", __FUNCTION__);
96 #if RKAIQ_HAVE_DRC_V10
97 CalibDbV2_drc_V10_t* calibv2_adrc_calib =
98 (CalibDbV2_drc_V10_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
99 memcpy(&pAdrcCtx->drcAttrV10.stAuto, calibv2_adrc_calib, sizeof(CalibDbV2_drc_V10_t));
100 #endif
101 #if RKAIQ_HAVE_DRC_V11
102 CalibDbV2_drc_V11_t* calibv2_adrc_calib =
103 (CalibDbV2_drc_V11_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
104 memcpy(&pAdrcCtx->drcAttrV11.stAuto, calibv2_adrc_calib, sizeof(CalibDbV2_drc_V11_t));
105 #endif
106 #if RKAIQ_HAVE_DRC_V12
107 CalibDbV2_drc_V12_t* calibv2_adrc_calib =
108 (CalibDbV2_drc_V12_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
109 memcpy(&pAdrcCtx->drcAttrV12.stAuto, calibv2_adrc_calib, sizeof(CalibDbV2_drc_V12_t));
110 AdrcV12ClipStAutoParams(pAdrcCtx);
111 #endif
112 #if RKAIQ_HAVE_DRC_V12_LITE
113 CalibDbV2_drc_v12_lite_t* calibv2_adrc_calib =
114 (CalibDbV2_drc_v12_lite_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, adrc_calib));
115 memcpy(&pAdrcCtx->drcAttrV12.stAuto, calibv2_adrc_calib, sizeof(CalibDbV2_drc_v12_lite_t));
116 AdrcV12ClipStAutoParams(pAdrcCtx);
117 #endif
118 pAdrcCtx->ifReCalcStAuto = true;
119 } else if (params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_CHANGERES) {
120 pAdrcCtx->isCapture = true;
121 }
122
123 if(/* !params->u.prepare.reconfig*/true) {
124 AdrcStop(pAdrcCtx); // stop firstly for re-preapre
125 result = AdrcStart(pAdrcCtx);
126 if (result != XCAM_RETURN_NO_ERROR) {
127 LOGE_ATMO("%s Adrc Start failed: %d", __FUNCTION__, result);
128 return(XCAM_RETURN_ERROR_FAILED);
129 }
130 }
131
132 LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
133 return result;
134 }
135
136 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)137 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
138 {
139 LOG1_ATMO("%s:Enter!\n", __FUNCTION__);
140 XCamReturn result = XCAM_RETURN_NO_ERROR;
141 bool bypass_tuning_params = true;
142 bool bypass_expo_params = true;
143 AdrcContext_t* pAdrcCtx = (AdrcContext_t*)inparams->ctx;
144 RkAiqAlgoProcAdrc* pAdrcParams = (RkAiqAlgoProcAdrc*)inparams;
145 RkAiqAlgoProcResAdrc* pAdrcProcRes = (RkAiqAlgoProcResAdrc*)outparams;
146 pAdrcCtx->FrameID = inparams->frame_id;
147
148 LOGD_ATMO(
149 "%s:////////////////////////////////////////////ADRC "
150 "Start//////////////////////////////////////////// \n",
151 __func__);
152
153 if (pAdrcCtx->isCapture) {
154 LOGD_ATMO("%s: It's capturing, using pre frame params\n", __func__);
155 pAdrcCtx->isCapture = false;
156 } else {
157 #if RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE
158 pAdrcCtx->ablcV32_proc_res = pAdrcParams->ablcV32_proc_res;
159 #endif
160 if (DrcEnableSetting(pAdrcCtx, pAdrcProcRes->AdrcProcRes)) {
161 // get Sensor Info
162 pAdrcCtx->NextData.AEData.LongFrmMode = pAdrcParams->LongFrmMode;
163
164 // get eff expo data
165 if(pAdrcCtx->FrameNumber == LINEAR_NUM) {
166 pAdrcCtx->NextData.AEData.SExpo =
167 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.analog_gain *
168 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.digital_gain *
169 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.isp_dgain *
170 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.integration_time;
171 pAdrcCtx->NextData.AEData.ISO =
172 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.analog_gain *
173 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.digital_gain *
174 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.isp_dgain * ISOMIN;
175 if (pAdrcCtx->NextData.AEData.SExpo < FLT_EPSILON) {
176 pAdrcCtx->NextData.AEData.SExpo =
177 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.analog_gain *
178 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.digital_gain *
179 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.isp_dgain *
180 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.integration_time;
181 pAdrcCtx->NextData.AEData.ISO =
182 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.analog_gain *
183 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.digital_gain *
184 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.isp_dgain * ISOMIN;
185 }
186 pAdrcCtx->NextData.AEData.MExpo = pAdrcCtx->NextData.AEData.SExpo;
187 pAdrcCtx->NextData.AEData.LExpo = pAdrcCtx->NextData.AEData.SExpo;
188 #if RKAIQ_HAVE_DRC_V12 || RKAIQ_HAVE_DRC_V12_LITE
189 if (pAdrcCtx->ablcV32_proc_res.blc_ob_enable) {
190 if (pAdrcCtx->ablcV32_proc_res.isp_ob_predgain < ISP_PREDGAIN_DEFAULT) {
191 LOGE_ATMO("%s: ob_enable ON, and ob_predgain[%f] < 1.0f, clip to 1.0!!!\n",
192 __FUNCTION__, pAdrcCtx->ablcV32_proc_res.isp_ob_predgain);
193 pAdrcCtx->ablcV32_proc_res.isp_ob_predgain = ISP_PREDGAIN_DEFAULT;
194 }
195 pAdrcCtx->NextData.AEData.ISO *= pAdrcCtx->ablcV32_proc_res.isp_ob_predgain;
196 }
197 #endif
198 }
199 else if(pAdrcCtx->FrameNumber == HDR_2X_NUM) {
200 pAdrcCtx->NextData.AEData.SExpo =
201 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.analog_gain *
202 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.digital_gain *
203 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.isp_dgain *
204 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.integration_time;
205 pAdrcCtx->NextData.AEData.MExpo =
206 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.analog_gain *
207 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.digital_gain *
208 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.isp_dgain *
209 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.integration_time;
210 pAdrcCtx->NextData.AEData.ISO =
211 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.analog_gain *
212 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.digital_gain *
213 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.isp_dgain * ISOMIN;
214 if (pAdrcCtx->NextData.AEData.SExpo < FLT_EPSILON) {
215 pAdrcCtx->NextData.AEData.SExpo =
216 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.analog_gain *
217 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.digital_gain *
218 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.isp_dgain *
219 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.integration_time;
220 pAdrcCtx->NextData.AEData.MExpo =
221 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.analog_gain *
222 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.digital_gain *
223 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.isp_dgain *
224 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.integration_time;
225 pAdrcCtx->NextData.AEData.ISO =
226 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.analog_gain *
227 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.digital_gain *
228 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.isp_dgain * ISOMIN;
229 }
230 pAdrcCtx->NextData.AEData.LExpo = pAdrcCtx->NextData.AEData.MExpo;
231 }
232 else if(pAdrcCtx->FrameNumber == HDR_3X_NUM) {
233 pAdrcCtx->NextData.AEData.SExpo =
234 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.analog_gain *
235 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.digital_gain *
236 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.isp_dgain *
237 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.integration_time;
238 pAdrcCtx->NextData.AEData.MExpo =
239 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.analog_gain *
240 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.digital_gain *
241 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.isp_dgain *
242 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.integration_time;
243 pAdrcCtx->NextData.AEData.LExpo =
244 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.analog_gain *
245 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.digital_gain *
246 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.isp_dgain *
247 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.integration_time;
248 pAdrcCtx->NextData.AEData.ISO =
249 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.analog_gain *
250 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.digital_gain *
251 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.isp_dgain * ISOMIN;
252 if (pAdrcCtx->NextData.AEData.SExpo < FLT_EPSILON) {
253 pAdrcCtx->NextData.AEData.SExpo =
254 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.analog_gain *
255 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.digital_gain *
256 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.isp_dgain *
257 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.integration_time;
258 pAdrcCtx->NextData.AEData.MExpo =
259 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.analog_gain *
260 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.digital_gain *
261 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.isp_dgain *
262 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.integration_time;
263 pAdrcCtx->NextData.AEData.LExpo =
264 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.analog_gain *
265 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.digital_gain *
266 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.isp_dgain *
267 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.integration_time;
268 pAdrcCtx->NextData.AEData.ISO =
269 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.analog_gain *
270 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.digital_gain *
271 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.isp_dgain * ISOMIN;
272 }
273 }
274 pAdrcCtx->NextData.AEData.ISO = LIMIT_VALUE(pAdrcCtx->NextData.AEData.ISO, ISOMAX, ISOMIN);
275 if (pAdrcCtx->FrameNumber == HDR_2X_NUM || pAdrcCtx->FrameNumber == HDR_2X_NUM) {
276 LOGV_ATMO("%s: nextFrame: sexp: %f-%f, mexp: %f-%f, lexp: %f-%f\n", __FUNCTION__,
277 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.analog_gain *
278 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.digital_gain *
279 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.isp_dgain,
280 pAdrcParams->com.u.proc.nxtExp->HdrExp[0].exp_real_params.integration_time,
281 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.analog_gain *
282 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.digital_gain *
283 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.isp_dgain,
284 pAdrcParams->com.u.proc.nxtExp->HdrExp[1].exp_real_params.integration_time,
285 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.analog_gain *
286 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.digital_gain *
287 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.isp_dgain,
288 pAdrcParams->com.u.proc.nxtExp->HdrExp[2].exp_real_params.integration_time);
289 LOGV_ATMO("%s: CurrFrame: sexp: %f-%f, mexp: %f-%f, lexp: %f-%f\n", __FUNCTION__,
290 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.analog_gain *
291 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.digital_gain *
292 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.isp_dgain,
293 pAdrcParams->com.u.proc.curExp->HdrExp[0].exp_real_params.integration_time,
294 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.analog_gain *
295 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.digital_gain *
296 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.isp_dgain,
297 pAdrcParams->com.u.proc.curExp->HdrExp[1].exp_real_params.integration_time,
298 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.analog_gain *
299 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.digital_gain *
300 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.isp_dgain,
301 pAdrcParams->com.u.proc.curExp->HdrExp[2].exp_real_params.integration_time);
302 } else if (pAdrcCtx->FrameNumber == LINEAR_NUM) {
303 LOGV_ATMO("%s: nextFrame: exp: %f-%f CurrFrame: exp: %f-%f\n", __FUNCTION__,
304 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.analog_gain *
305 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.digital_gain *
306 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.isp_dgain,
307 pAdrcParams->com.u.proc.nxtExp->LinearExp.exp_real_params.integration_time,
308 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.analog_gain *
309 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.digital_gain *
310 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.isp_dgain,
311 pAdrcParams->com.u.proc.curExp->LinearExp.exp_real_params.integration_time);
312 }
313 if (pAdrcCtx->NextData.AEData.SExpo > FLT_EPSILON) {
314 pAdrcCtx->NextData.AEData.L2S_Ratio =
315 pAdrcCtx->NextData.AEData.LExpo / pAdrcCtx->NextData.AEData.SExpo;
316 pAdrcCtx->NextData.AEData.M2S_Ratio =
317 pAdrcCtx->NextData.AEData.MExpo / pAdrcCtx->NextData.AEData.SExpo;
318 } else
319 LOGE_ATMO("%s: Next Short frame for drc expo sync is %f!!!\n", __FUNCTION__,
320 pAdrcCtx->NextData.AEData.SExpo);
321 if (pAdrcCtx->NextData.AEData.MExpo > FLT_EPSILON)
322 pAdrcCtx->NextData.AEData.L2M_Ratio =
323 pAdrcCtx->NextData.AEData.LExpo / pAdrcCtx->NextData.AEData.MExpo;
324 else
325 LOGE_ATMO("%s: Next Midlle frame for drc expo sync is %f!!!\n", __FUNCTION__,
326 pAdrcCtx->NextData.AEData.MExpo);
327 //clip for long frame mode
328 if (pAdrcCtx->NextData.AEData.LongFrmMode) {
329 pAdrcCtx->NextData.AEData.L2S_Ratio = LONG_FRAME_MODE_RATIO;
330 pAdrcCtx->NextData.AEData.M2S_Ratio = LONG_FRAME_MODE_RATIO;
331 pAdrcCtx->NextData.AEData.L2M_Ratio = LONG_FRAME_MODE_RATIO;
332 }
333
334 // get ae pre res
335 XCamVideoBuffer* xCamAePreRes = pAdrcParams->com.u.proc.res_comb->ae_pre_res;
336 RkAiqAlgoPreResAe* pAEPreRes = NULL;
337 if (xCamAePreRes) {
338 pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
339 if (pAdrcCtx->FrameNumber == LINEAR_NUM)
340 pAdrcCtx->NextData.AEData.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[0];
341 else if (pAdrcCtx->FrameNumber == HDR_2X_NUM || pAdrcCtx->FrameNumber == HDR_3X_NUM)
342 pAdrcCtx->NextData.AEData.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[1];
343 else
344 pAdrcCtx->NextData.AEData.EnvLv = ENVLVMIN;
345 // Normalize the current envLv for AEC
346 pAdrcCtx->NextData.AEData.EnvLv =
347 (pAdrcCtx->NextData.AEData.EnvLv - MIN_ENV_LV) / (MAX_ENV_LV - MIN_ENV_LV);
348 pAdrcCtx->NextData.AEData.EnvLv =
349 LIMIT_VALUE(pAdrcCtx->NextData.AEData.EnvLv, ENVLVMAX, ENVLVMIN);
350 } else {
351 pAdrcCtx->NextData.AEData.EnvLv = ENVLVMIN;
352 LOGW_ATMO("%s: ae Pre result is null!!!\n", __FUNCTION__);
353 }
354
355 // get motion coef
356 pAdrcCtx->NextData.MotionCoef = MOVE_COEF_DEFAULT;
357
358 // get bypass_tuning_params
359 bypass_tuning_params = AdrcByPassTuningProcessing(pAdrcCtx);
360
361 // get bypass_expo_params
362 if (pAdrcCtx->NextData.AEData.L2S_Ratio >= RATIO_DEFAULT &&
363 pAdrcCtx->NextData.AEData.L2M_Ratio >= RATIO_DEFAULT) {
364 if (pAdrcCtx->FrameID <= INIT_CALC_PARAMS_NUM)
365 bypass_expo_params = false;
366 else if (pAdrcCtx->ifReCalcStAuto || pAdrcCtx->ifReCalcStManual)
367 bypass_expo_params = false;
368 else if (!pAdrcCtx->CurrData.AEData.LongFrmMode !=
369 !pAdrcCtx->NextData.AEData.LongFrmMode)
370 bypass_expo_params = false;
371 else if ((pAdrcCtx->CurrData.AEData.L2M_Ratio - pAdrcCtx->NextData.AEData.L2M_Ratio) >
372 FLT_EPSILON ||
373 (pAdrcCtx->CurrData.AEData.L2M_Ratio - pAdrcCtx->NextData.AEData.L2M_Ratio) <
374 -FLT_EPSILON ||
375 (pAdrcCtx->CurrData.AEData.M2S_Ratio - pAdrcCtx->NextData.AEData.M2S_Ratio) >
376 FLT_EPSILON ||
377 (pAdrcCtx->CurrData.AEData.M2S_Ratio - pAdrcCtx->NextData.AEData.M2S_Ratio) <
378 -FLT_EPSILON ||
379 (pAdrcCtx->CurrData.AEData.L2S_Ratio - pAdrcCtx->NextData.AEData.L2S_Ratio) >
380 FLT_EPSILON ||
381 (pAdrcCtx->CurrData.AEData.L2S_Ratio - pAdrcCtx->NextData.AEData.L2S_Ratio) <
382 -FLT_EPSILON)
383 bypass_expo_params = false;
384 else
385 bypass_expo_params = true;
386 } else {
387 LOGE_ATMO("%s: AE L2S_Ratio:%f L2M_Ratio:%f for drc expo sync is under one!!!\n",
388 __FUNCTION__, __LINE__, pAdrcCtx->NextData.AEData.L2S_Ratio,
389 pAdrcCtx->NextData.AEData.L2M_Ratio);
390 bypass_expo_params = true;
391 }
392
393 // get tuning paras
394 if (!bypass_tuning_params || !pAdrcCtx->isDampStable)
395 AdrcTuningParaProcessing(pAdrcCtx, pAdrcProcRes->AdrcProcRes);
396
397 // get expo related paras
398 if (!bypass_expo_params || !bypass_tuning_params || !pAdrcCtx->isDampStable)
399 AdrcExpoParaProcessing(pAdrcCtx, pAdrcProcRes->AdrcProcRes);
400 } else {
401 LOGD_ATMO("%s: Drc Enable is OFF, Bypass Drc !!! \n", __func__);
402 }
403 }
404 LOGD_ATMO(
405 "%s:////////////////////////////////////////////ADRC "
406 "Over//////////////////////////////////////////// \n",
407 __func__);
408
409 // output ProcRes
410 outparams->cfg_update = !bypass_tuning_params || !bypass_expo_params ||
411 pAdrcCtx->ifReCalcStAuto || pAdrcCtx->ifReCalcStManual ||
412 !pAdrcCtx->isDampStable || inparams->u.proc.init;
413 if (pAdrcCtx->ifReCalcStAuto) pAdrcCtx->ifReCalcStAuto = false;
414 if (pAdrcCtx->ifReCalcStManual) pAdrcCtx->ifReCalcStManual = false;
415 // store expo data
416 pAdrcCtx->CurrData.AEData.LongFrmMode = pAdrcCtx->NextData.AEData.LongFrmMode;
417 pAdrcCtx->CurrData.AEData.L2M_Ratio = pAdrcCtx->NextData.AEData.L2M_Ratio;
418 pAdrcCtx->CurrData.AEData.M2S_Ratio = pAdrcCtx->NextData.AEData.M2S_Ratio;
419 pAdrcCtx->CurrData.AEData.L2S_Ratio = pAdrcCtx->NextData.AEData.L2S_Ratio;
420
421 LOG1_ATMO("%s:Exit!\n", __FUNCTION__);
422 return XCAM_RETURN_NO_ERROR;
423 }
424
425 RkAiqAlgoDescription g_RkIspAlgoDescAdrc = {
426 .common = {
427 .version = RKISP_ALGO_ADRC_VERSION,
428 .vendor = RKISP_ALGO_ADRC_VENDOR,
429 .description = RKISP_ALGO_ADRC_DESCRIPTION,
430 .type = RK_AIQ_ALGO_TYPE_ADRC,
431 .id = 0,
432 .create_context = create_context,
433 .destroy_context = destroy_context,
434 },
435 .prepare = prepare,
436 .pre_process = NULL,
437 .processing = processing,
438 .post_process = NULL,
439 };
440
441 RKAIQ_END_DECLARE
442