1 /*
2 * rk_aiq_algo_anr_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 "aynrV22/rk_aiq_aynr_algo_itf_v22.h"
21 #include "aynrV22/rk_aiq_aynr_algo_v22.h"
22 #include "rk_aiq_algo_types.h"
23
24 RKAIQ_BEGIN_DECLARE
25
26 typedef struct _RkAiqAlgoContext {
27 Aynr_Context_V22_t AynrCtx;
28 } RkAiqAlgoContext;
29
30
31 static XCamReturn
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)32 create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
33 {
34
35 XCamReturn result = XCAM_RETURN_NO_ERROR;
36 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
37
38 #if 1
39 Aynr_Context_V22_t* pAynrCtx = NULL;
40 #if (AYNR_USE_JSON_FILE_V22)
41 Aynr_result_V22_t ret = Aynr_Init_V22(&pAynrCtx, cfg->calibv2);
42 #endif
43 if(ret != AYNRV22_RET_SUCCESS) {
44 result = XCAM_RETURN_ERROR_FAILED;
45 LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
46 } else {
47 *context = (RkAiqAlgoContext *)(pAynrCtx);
48 }
49 #endif
50
51 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
52 return result;
53 }
54
55 static XCamReturn
destroy_context(RkAiqAlgoContext * context)56 destroy_context(RkAiqAlgoContext *context)
57 {
58 XCamReturn result = XCAM_RETURN_NO_ERROR;
59
60 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
61
62 #if 1
63 Aynr_Context_V22_t* pAynrCtx = (Aynr_Context_V22_t*)context;
64 Aynr_result_V22_t ret = Aynr_Release_V22(pAynrCtx);
65 if(ret != AYNRV22_RET_SUCCESS) {
66 result = XCAM_RETURN_ERROR_FAILED;
67 LOGE_ANR("%s: release ANR failed (%d)\n", __FUNCTION__, ret);
68 }
69 #endif
70
71 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
72 return result;
73 }
74
75 static XCamReturn
prepare(RkAiqAlgoCom * params)76 prepare(RkAiqAlgoCom* params)
77 {
78 XCamReturn result = XCAM_RETURN_NO_ERROR;
79
80 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
81
82 Aynr_Context_V22_t* pAynrCtx = (Aynr_Context_V22_t *)params->ctx;
83 RkAiqAlgoConfigAynrV22* pCfgParam = (RkAiqAlgoConfigAynrV22*)params;
84 pAynrCtx->prepare_type = params->u.prepare.conf_type;
85
86 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
87 #if AYNR_USE_JSON_FILE_V22
88 void *pCalibdbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
89 CalibDbV2_YnrV22_t *ynr_v22 = (CalibDbV2_YnrV22_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, ynr_v22));
90 pAynrCtx->ynr_v22 = *ynr_v22;
91 #endif
92 pAynrCtx->isIQParaUpdate = true;
93 pAynrCtx->isReCalculate |= 1;
94 }
95
96 Aynr_result_V22_t ret = Aynr_Prepare_V22(pAynrCtx, &pCfgParam->stAynrConfig);
97 if(ret != AYNRV22_RET_SUCCESS) {
98 result = XCAM_RETURN_ERROR_FAILED;
99 LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
100 }
101
102 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
103 return result;
104 }
105 #if 0
106 static XCamReturn
107 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
108 {
109 XCamReturn result = XCAM_RETURN_NO_ERROR;
110 bool oldGrayMode = false;
111
112 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
113 Aynr_Context_V22_t* pAynrCtx = (Aynr_Context_V22_t *)inparams->ctx;
114
115 RkAiqAlgoPreAynrV22* pAnrPreParams = (RkAiqAlgoPreAynrV22*)inparams;
116
117 oldGrayMode = pAynrCtx->isGrayMode;
118 if (pAnrPreParams->com.u.proc.gray_mode) {
119 pAynrCtx->isGrayMode = true;
120 } else {
121 pAynrCtx->isGrayMode = false;
122 }
123
124 if(oldGrayMode != pAynrCtx->isGrayMode) {
125 pAynrCtx->isReCalculate |= 1;
126 }
127
128 Aynr_result_V22_t ret = Aynr_PreProcess_V22(pAynrCtx);
129 if(ret != AYNRV22_RET_SUCCESS) {
130 result = XCAM_RETURN_ERROR_FAILED;
131 LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
132 }
133
134 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
135 return result;
136 }
137 #endif
138 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)139 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
140 {
141 XCamReturn result = XCAM_RETURN_NO_ERROR;
142 int deltaIso = 0;
143 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
144
145 #if 1
146 RkAiqAlgoProcAynrV22* pAynrProcParams = (RkAiqAlgoProcAynrV22*)inparams;
147 RkAiqAlgoProcResAynrV22* pAynrProcResParams = (RkAiqAlgoProcResAynrV22*)outparams;
148 Aynr_Context_V22_t* pAynrCtx = (Aynr_Context_V22_t *)inparams->ctx;
149 Aynr_ExpInfo_V22_t stExpInfo;
150 memset(&stExpInfo, 0x00, sizeof(Aynr_ExpInfo_V22_t));
151
152 LOGD_ANR("%s:%d init:%d hdr mode:%d \n",
153 __FUNCTION__, __LINE__,
154 inparams->u.proc.init,
155 pAynrProcParams->hdr_mode);
156
157 bool oldGrayMode = false;
158 oldGrayMode = pAynrCtx->isGrayMode;
159 if (inparams->u.proc.gray_mode) {
160 pAynrCtx->isGrayMode = true;
161 } else {
162 pAynrCtx->isGrayMode = false;
163 }
164
165 if(oldGrayMode != pAynrCtx->isGrayMode) {
166 pAynrCtx->isReCalculate |= 1;
167 }
168
169 Aynr_result_V22_t ret = Aynr_PreProcess_V22(pAynrCtx);
170 if(ret != AYNRV22_RET_SUCCESS) {
171 result = XCAM_RETURN_ERROR_FAILED;
172 LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
173 }
174
175 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
176 for(int i = 0; i < 3; i++) {
177 stExpInfo.arIso[i] = 50;
178 stExpInfo.arAGain[i] = 1.0;
179 stExpInfo.arDGain[i] = 1.0;
180 stExpInfo.arTime[i] = 0.01;
181 }
182
183 if(pAynrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
184 stExpInfo.hdr_mode = 0;
185 } else if(pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
186 || pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
187 stExpInfo.hdr_mode = 1;
188 } else if(pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
189 || pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
190 stExpInfo.hdr_mode = 2;
191 }
192 stExpInfo.snr_mode = 0;
193
194 stExpInfo.blc_ob_predgain = 1.0;
195 if(pAynrProcParams != NULL) {
196 stExpInfo.blc_ob_predgain = pAynrProcParams->stAblcV32_proc_res->isp_ob_predgain;
197 if(stExpInfo.blc_ob_predgain != pAynrCtx->stExpInfo.blc_ob_predgain) {
198 pAynrCtx->isReCalculate |= 1;
199 }
200 }
201 #if 0// TODO Merge:
202 XCamVideoBuffer* xCamAePreRes = pAynrProcParams->com.u.proc.res_comb->ae_pre_res;
203 RkAiqAlgoPreResAe* pAEPreRes = nullptr;
204 if (xCamAePreRes) {
205 // xCamAePreRes->ref(xCamAePreRes);
206 pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
207 if (!pAEPreRes) {
208 LOGE_ANR("ae pre result is null");
209 } else {
210 LOGD_ANR("ae_pre_result: meanluma:%f time:%f gain:%f env_luma:%f \n",
211 pAEPreRes->ae_pre_res_rk.MeanLuma[0],
212 pAEPreRes->ae_pre_res_rk.LinearExp.exp_real_params.integration_time,
213 pAEPreRes->ae_pre_res_rk.LinearExp.exp_real_params.analog_gain,
214 pAEPreRes->ae_pre_res_rk.GlobalEnvLux);
215 }
216 // xCamAePreRes->unref(xCamAePreRes);
217 }
218 #endif
219
220 RKAiqAecExpInfo_t *curExp = pAynrProcParams->com.u.proc.curExp;
221 if(curExp != NULL) {
222 stExpInfo.snr_mode = curExp->CISFeature.SNR;
223 if(pAynrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
224 stExpInfo.hdr_mode = 0;
225 if(curExp->LinearExp.exp_real_params.analog_gain < 1.0) {
226 stExpInfo.arAGain[0] = 1.0;
227 LOGW_ANR("leanr mode again is wrong, use 1.0 instead\n");
228 } else {
229 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
230 }
231 if(curExp->LinearExp.exp_real_params.digital_gain < 1.0) {
232 stExpInfo.arDGain[0] = 1.0;
233 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
234 } else {
235 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
236 }
237 if(curExp->LinearExp.exp_real_params.isp_dgain < 1.0) {
238 stExpInfo.isp_dgain[0] = 1.0;
239 LOGW_ANR("leanr mode isp_dgain is wrong, use 1.0 instead\n");
240 } else {
241 stExpInfo.isp_dgain[0] = curExp->LinearExp.exp_real_params.isp_dgain;
242 }
243 if(stExpInfo.blc_ob_predgain < 1.0) {
244 stExpInfo.blc_ob_predgain = 1.0;
245 }
246 // stExpInfo.arAGain[0] = 64.0;
247 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
248 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * stExpInfo.blc_ob_predgain * 50 * stExpInfo.isp_dgain[0];
249 } else {
250 for(int i = 0; i < 3; i++) {
251 if(curExp->HdrExp[i].exp_real_params.analog_gain < 1.0) {
252 stExpInfo.arAGain[i] = 1.0;
253 LOGW_ANR("hdr mode again is wrong, use 1.0 instead\n");
254 } else {
255 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
256 }
257 if(curExp->HdrExp[i].exp_real_params.digital_gain < 1.0) {
258 stExpInfo.arDGain[i] = 1.0;
259 LOGW_ANR("hdr mode dgain is wrong, use 1.0 instead\n");
260 } else {
261 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
262 }
263 if(curExp->HdrExp[i].exp_real_params.isp_dgain < 1.0) {
264 stExpInfo.isp_dgain[i] = 1.0;
265 LOGW_ANR("hdr mode isp_dgain is wrong, use 1.0 instead\n");
266 } else {
267 stExpInfo.isp_dgain[i] = curExp->HdrExp[i].exp_real_params.isp_dgain;
268 }
269 stExpInfo.blc_ob_predgain = 1.0;
270 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
271 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50 * stExpInfo.isp_dgain[i];
272
273 LOGD_ANR("%s:%d index:%d again:%f dgain:%f isp_dgain:%f time:%f iso:%d hdr_mode:%d\n",
274 __FUNCTION__, __LINE__,
275 i,
276 stExpInfo.arAGain[i],
277 stExpInfo.arDGain[i],
278 stExpInfo.isp_dgain[i],
279 stExpInfo.arTime[i],
280 stExpInfo.arIso[i],
281 stExpInfo.hdr_mode);
282 }
283 }
284 } else {
285 LOGE_ANR("%s:%d curExp is NULL, so use default instead \n", __FUNCTION__, __LINE__);
286 }
287
288 #if 0
289 static int anr_cnt = 0;
290 anr_cnt++;
291
292 if(anr_cnt % 50 == 0) {
293 for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
294 printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d snr_mode:%d\n",
295 __FUNCTION__, __LINE__,
296 i,
297 stExpInfo.arAGain[i],
298 stExpInfo.arDGain[i],
299 stExpInfo.arTime[i],
300 stExpInfo.arIso[i],
301 stExpInfo.hdr_mode,
302 stExpInfo.snr_mode);
303 }
304 }
305 #endif
306
307 deltaIso = abs(stExpInfo.arIso[stExpInfo.hdr_mode] - pAynrCtx->stExpInfo.arIso[stExpInfo.hdr_mode]);
308 if(deltaIso > AYNRV22_RECALCULATE_DELTA_ISO) {
309 pAynrCtx->isReCalculate |= 1;
310 }
311
312 if(pAynrCtx->isReCalculate) {
313 Aynr_result_V22_t ret = Aynr_Process_V22(pAynrCtx, &stExpInfo);
314 if(ret != AYNRV22_RET_SUCCESS) {
315 result = XCAM_RETURN_ERROR_FAILED;
316 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
317 }
318
319 Aynr_GetProcResult_V22(pAynrCtx, &pAynrProcResParams->stAynrProcResult);
320 outparams->cfg_update = true;
321 LOGD_ANR("recalculate: %d delta_iso:%d \n ", pAynrCtx->isReCalculate, deltaIso);
322 } else {
323 outparams->cfg_update = false;
324 }
325 #endif
326
327 pAynrCtx->isReCalculate = 0;
328
329 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
330 return XCAM_RETURN_NO_ERROR;
331 }
332
333 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)334 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
335 {
336 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
337
338 //nothing todo now
339
340 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
341 return XCAM_RETURN_NO_ERROR;
342 }
343
344 RkAiqAlgoDescription g_RkIspAlgoDescAynrV22 = {
345 .common = {
346 .version = RKISP_ALGO_AYNR_VERSION_V22,
347 .vendor = RKISP_ALGO_AYNR_VENDOR_V22,
348 .description = RKISP_ALGO_AYNR_DESCRIPTION_V22,
349 .type = RK_AIQ_ALGO_TYPE_AYNR,
350 .id = 0,
351 .create_context = create_context,
352 .destroy_context = destroy_context,
353 },
354 .prepare = prepare,
355 .pre_process = NULL,
356 .processing = processing,
357 .post_process = NULL,
358 };
359
360 RKAIQ_END_DECLARE
361