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 "aynr3/rk_aiq_aynr_algo_itf_v3.h"
21 #include "aynr3/rk_aiq_aynr_algo_v3.h"
22 #include "rk_aiq_algo_types.h"
23
24 RKAIQ_BEGIN_DECLARE
25
26 typedef struct _RkAiqAlgoContext {
27 Aynr_Context_V3_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_V3_t* pAynrCtx = NULL;
40 #if (AYNR_USE_JSON_FILE_V3)
41 Aynr_result_V3_t ret = Aynr_Init_V3(&pAynrCtx, cfg->calibv2);
42 #endif
43 if(ret != AYNRV3_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_V3_t* pAynrCtx = (Aynr_Context_V3_t*)context;
64 Aynr_result_V3_t ret = Aynr_Release_V3(pAynrCtx);
65 if(ret != AYNRV3_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_V3_t* pAynrCtx = (Aynr_Context_V3_t *)params->ctx;
83 RkAiqAlgoConfigAynrV3* pCfgParam = (RkAiqAlgoConfigAynrV3*)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_V3
88 void *pCalibdbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
89 CalibDbV2_YnrV3_t *ynr_v3 = (CalibDbV2_YnrV3_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, ynr_v3));
90 pAynrCtx->ynr_v3 = *ynr_v3;
91 #endif
92 pAynrCtx->isIQParaUpdate = true;
93 pAynrCtx->isReCalculate |= 1;
94 }
95
96 Aynr_result_V3_t ret = Aynr_Prepare_V3(pAynrCtx, &pCfgParam->stAynrConfig);
97 if(ret != AYNRV3_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
106 static XCamReturn
pre_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)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_V3_t* pAynrCtx = (Aynr_Context_V3_t *)inparams->ctx;
114
115 RkAiqAlgoPreAynrV3* pAnrPreParams = (RkAiqAlgoPreAynrV3*)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_V3_t ret = Aynr_PreProcess_V3(pAynrCtx);
129 if(ret != AYNRV3_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
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 RkAiqAlgoProcAynrV3* pAynrProcParams = (RkAiqAlgoProcAynrV3*)inparams;
147 RkAiqAlgoProcResAynrV3* pAynrProcResParams = (RkAiqAlgoProcResAynrV3*)outparams;
148 Aynr_Context_V3_t* pAynrCtx = (Aynr_Context_V3_t *)inparams->ctx;
149 Aynr_ExpInfo_V3_t stExpInfo;
150 memset(&stExpInfo, 0x00, sizeof(Aynr_ExpInfo_V3_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 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
158 for(int i = 0; i < 3; i++) {
159 stExpInfo.arIso[i] = 50;
160 stExpInfo.arAGain[i] = 1.0;
161 stExpInfo.arDGain[i] = 1.0;
162 stExpInfo.arTime[i] = 0.01;
163 }
164
165 if(pAynrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
166 stExpInfo.hdr_mode = 0;
167 } else if(pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
168 || pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
169 stExpInfo.hdr_mode = 1;
170 } else if(pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
171 || pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
172 stExpInfo.hdr_mode = 2;
173 }
174 stExpInfo.snr_mode = 0;
175
176 #if 0// TODO Merge:
177 XCamVideoBuffer* xCamAePreRes = pAynrProcParams->com.u.proc.res_comb->ae_pre_res;
178 RkAiqAlgoPreResAe* pAEPreRes = nullptr;
179 if (xCamAePreRes) {
180 // xCamAePreRes->ref(xCamAePreRes);
181 pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
182 if (!pAEPreRes) {
183 LOGE_ANR("ae pre result is null");
184 } else {
185 LOGD_ANR("ae_pre_result: meanluma:%f time:%f gain:%f env_luma:%f \n",
186 pAEPreRes->ae_pre_res_rk.MeanLuma[0],
187 pAEPreRes->ae_pre_res_rk.LinearExp.exp_real_params.integration_time,
188 pAEPreRes->ae_pre_res_rk.LinearExp.exp_real_params.analog_gain,
189 pAEPreRes->ae_pre_res_rk.GlobalEnvLux);
190 }
191 // xCamAePreRes->unref(xCamAePreRes);
192 }
193 #endif
194
195 RKAiqAecExpInfo_t *curExp = pAynrProcParams->com.u.proc.curExp;
196 if(curExp != NULL) {
197 stExpInfo.snr_mode = curExp->CISFeature.SNR;
198 if(pAynrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
199 stExpInfo.hdr_mode = 0;
200 if(curExp->LinearExp.exp_real_params.analog_gain < 1.0) {
201 stExpInfo.arAGain[0] = 1.0;
202 LOGW_ANR("leanr mode again is wrong, use 1.0 instead\n");
203 } else {
204 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
205 }
206 if(curExp->LinearExp.exp_real_params.digital_gain < 1.0) {
207 stExpInfo.arDGain[0] = 1.0;
208 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
209 } else {
210 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
211 }
212 if(curExp->LinearExp.exp_real_params.isp_dgain < 1.0) {
213 stExpInfo.arDGain[0] *= 1.0;
214 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
215 } else {
216 stExpInfo.arDGain[0] *= curExp->LinearExp.exp_real_params.isp_dgain;
217 }
218 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
219 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * 50;
220 } else {
221 for(int i = 0; i < 3; i++) {
222 if(curExp->HdrExp[i].exp_real_params.analog_gain < 1.0) {
223 stExpInfo.arAGain[i] = 1.0;
224 LOGW_ANR("hdr mode again is wrong, use 1.0 instead\n");
225 } else {
226 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
227 }
228 if(curExp->HdrExp[i].exp_real_params.digital_gain < 1.0) {
229 stExpInfo.arDGain[i] = 1.0;
230 } else {
231 LOGW_ANR("hdr mode dgain is wrong, use 1.0 instead\n");
232 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
233 }
234 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
235 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50;
236
237 LOGD_ANR("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d\n",
238 __FUNCTION__, __LINE__,
239 i,
240 stExpInfo.arAGain[i],
241 stExpInfo.arDGain[i],
242 stExpInfo.arTime[i],
243 stExpInfo.arIso[i],
244 stExpInfo.hdr_mode);
245 }
246 }
247 } else {
248 LOGE_ANR("%s:%d curExp is NULL, so use default instead \n", __FUNCTION__, __LINE__);
249 }
250
251 #if 0
252 static int anr_cnt = 0;
253 anr_cnt++;
254
255 if(anr_cnt % 50 == 0) {
256 for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
257 printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d snr_mode:%d\n",
258 __FUNCTION__, __LINE__,
259 i,
260 stExpInfo.arAGain[i],
261 stExpInfo.arDGain[i],
262 stExpInfo.arTime[i],
263 stExpInfo.arIso[i],
264 stExpInfo.hdr_mode,
265 stExpInfo.snr_mode);
266 }
267 }
268 #endif
269
270 deltaIso = abs(stExpInfo.arIso[stExpInfo.hdr_mode] - pAynrCtx->stExpInfo.arIso[stExpInfo.hdr_mode]);
271 if(deltaIso > AYNRV3_RECALCULATE_DELTA_ISO) {
272 pAynrCtx->isReCalculate |= 1;
273 }
274
275 if(pAynrCtx->isReCalculate) {
276 Aynr_result_V3_t ret = Aynr_Process_V3(pAynrCtx, &stExpInfo);
277 if(ret != AYNRV3_RET_SUCCESS) {
278 result = XCAM_RETURN_ERROR_FAILED;
279 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
280 }
281
282 Aynr_GetProcResult_V3(pAynrCtx, &pAynrProcResParams->stAynrProcResult);
283 outparams->cfg_update = true;
284 LOGD_ANR("recalculate: %d delta_iso:%d \n ", pAynrCtx->isReCalculate, deltaIso);
285 } else {
286 outparams->cfg_update = false;
287 }
288 #endif
289
290 pAynrCtx->isReCalculate = 0;
291
292 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
293 return XCAM_RETURN_NO_ERROR;
294 }
295
296 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)297 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
298 {
299 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
300
301 //nothing todo now
302
303 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
304 return XCAM_RETURN_NO_ERROR;
305 }
306
307 RkAiqAlgoDescription g_RkIspAlgoDescAynrV3 = {
308 .common = {
309 .version = RKISP_ALGO_AYNR_VERSION_V3,
310 .vendor = RKISP_ALGO_AYNR_VENDOR_V3,
311 .description = RKISP_ALGO_AYNR_DESCRIPTION_V3,
312 .type = RK_AIQ_ALGO_TYPE_AYNR,
313 .id = 0,
314 .create_context = create_context,
315 .destroy_context = destroy_context,
316 },
317 .prepare = prepare,
318 .pre_process = pre_process,
319 .processing = processing,
320 .post_process = post_process,
321 };
322
323 RKAIQ_END_DECLARE
324