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 "again2/rk_aiq_again_algo_itf_v2.h"
21 #include "again2/rk_aiq_again_algo_v2.h"
22 #include "rk_aiq_algo_types.h"
23
24 RKAIQ_BEGIN_DECLARE
25
26 typedef struct _RkAiqAlgoContext {
27 Again_Context_V2_t pAgainCtx;
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 Again_Context_V2_t* pAgainCtx = NULL;
40
41 #if(AGAIN_USE_JSON_FILE_V2)
42 Again_result_V2_t ret = Again_Init_V2(&pAgainCtx, cfg->calibv2);
43 #endif
44
45 if(ret != AGAINV2_RET_SUCCESS) {
46 result = XCAM_RETURN_ERROR_FAILED;
47 LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
48 } else {
49 *context = (RkAiqAlgoContext *)(pAgainCtx);
50 }
51 #endif
52
53 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
54 return result;
55 }
56
57 static XCamReturn
destroy_context(RkAiqAlgoContext * context)58 destroy_context(RkAiqAlgoContext *context)
59 {
60 XCamReturn result = XCAM_RETURN_NO_ERROR;
61
62 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
63
64 #if 1
65 Again_Context_V2_t* pAgainCtx = (Again_Context_V2_t*)context;
66 Again_result_V2_t ret = Again_Release_V2(pAgainCtx);
67 if(ret != AGAINV2_RET_SUCCESS) {
68 result = XCAM_RETURN_ERROR_FAILED;
69 LOGE_ANR("%s: release ANR failed (%d)\n", __FUNCTION__, ret);
70 }
71 #endif
72
73 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
74 return result;
75 }
76
77 static XCamReturn
prepare(RkAiqAlgoCom * params)78 prepare(RkAiqAlgoCom* params)
79 {
80 XCamReturn result = XCAM_RETURN_NO_ERROR;
81
82 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
83
84 Again_Context_V2_t* pAgainCtx = (Again_Context_V2_t *)params->ctx;
85 RkAiqAlgoConfigAgainV2* pCfgParam = (RkAiqAlgoConfigAgainV2*)params;
86 pAgainCtx->prepare_type = params->u.prepare.conf_type;
87
88 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
89 #if AGAIN_USE_JSON_FILE_V2
90 #if 1
91 void *pCalibDbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
92 CalibDbV2_GainV2_t * pcalibdbV2_gain_v2 =
93 (CalibDbV2_GainV2_t *)(CALIBDBV2_GET_MODULE_PTR((CamCalibDbV2Context_t*)pCalibDbV2, gain_v2));
94
95 pAgainCtx->gain_v2 = *pcalibdbV2_gain_v2;
96 pAgainCtx->isIQParaUpdate = true;
97 pAgainCtx->isReCalculate |= 1;
98 LOGE_ANR("enter!!\n");
99 #endif
100 #endif
101 }
102
103 Again_result_V2_t ret = Again_Prepare_V2(pAgainCtx, &pCfgParam->stAgainConfig);
104 if(ret != AGAINV2_RET_SUCCESS) {
105 result = XCAM_RETURN_ERROR_FAILED;
106 LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
107 }
108
109 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
110 return result;
111 }
112 #if 0
113 static XCamReturn
114 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
115 {
116 XCamReturn result = XCAM_RETURN_NO_ERROR;
117
118 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
119 Again_Context_V2_t* pAgainCtx = (Again_Context_V2_t *)inparams->ctx;
120
121 RkAiqAlgoPreAgainV2* pAnrPreParams = (RkAiqAlgoPreAgainV2*)inparams;
122
123 if (pAnrPreParams->com.u.proc.gray_mode) {
124 pAgainCtx->isGrayMode = true;
125 } else {
126 pAgainCtx->isGrayMode = false;
127 }
128
129 Again_result_V2_t ret = Again_PreProcess_V2(pAgainCtx);
130 if(ret != AGAINV2_RET_SUCCESS) {
131 result = XCAM_RETURN_ERROR_FAILED;
132 LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
133 }
134
135 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
136 return result;
137 }
138 #endif
139 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)140 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
141 {
142 XCamReturn result = XCAM_RETURN_NO_ERROR;
143
144 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
145
146 #if 1
147 int deltaIso = 0;
148 RkAiqAlgoProcAgainV2* pAgainProcParams = (RkAiqAlgoProcAgainV2*)inparams;
149 RkAiqAlgoProcResAgainV2* pAgainProcResParams = (RkAiqAlgoProcResAgainV2*)outparams;
150 Again_Context_V2_t* pAgainCtx = (Again_Context_V2_t *)inparams->ctx;
151 Again_ExpInfo_V2_t stExpInfo;
152 memset(&stExpInfo, 0x00, sizeof(Again_ExpInfo_V2_t));
153
154 LOGD_ANR("%s:%d init:%d hdr mode:%d \n",
155 __FUNCTION__, __LINE__,
156 inparams->u.proc.init,
157 pAgainProcParams->hdr_mode);
158
159 if (inparams->u.proc.gray_mode) {
160 pAgainCtx->isGrayMode = true;
161 } else {
162 pAgainCtx->isGrayMode = false;
163 }
164
165 Again_result_V2_t ret = Again_PreProcess_V2(pAgainCtx);
166 if(ret != AGAINV2_RET_SUCCESS) {
167 result = XCAM_RETURN_ERROR_FAILED;
168 LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
169 }
170
171 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
172 for(int i = 0; i < 3; i++) {
173 stExpInfo.arIso[i] = 50;
174 stExpInfo.arAGain[i] = 1.0;
175 stExpInfo.arDGain[i] = 1.0;
176 stExpInfo.arTime[i] = 0.01;
177 }
178
179 if(pAgainProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
180 stExpInfo.hdr_mode = 0;
181 } else if(pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
182 || pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
183 stExpInfo.hdr_mode = 1;
184 } else if(pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
185 || pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
186 stExpInfo.hdr_mode = 2;
187 }
188 stExpInfo.snr_mode = 0;
189
190 #if 1// TODO Merge
191 RKAiqAecExpInfo_t *curExp = pAgainProcParams->com.u.proc.curExp;
192
193 if(curExp != NULL) {
194 stExpInfo.snr_mode = curExp->CISFeature.SNR;
195 if(pAgainProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
196 stExpInfo.hdr_mode = 0;
197 if(curExp->LinearExp.exp_real_params.analog_gain < 1.0) {
198 stExpInfo.arAGain[0] = 1.0;
199 LOGW_ANR("leanr mode again is wrong, use 1.0 instead\n");
200 } else {
201 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
202 }
203 if(curExp->LinearExp.exp_real_params.digital_gain < 1.0) {
204 stExpInfo.arDGain[0] = 1.0;
205 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
206 } else {
207 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
208 }
209 if(curExp->LinearExp.exp_real_params.isp_dgain < 1.0) {
210 stExpInfo.isp_dgain[0] = 1.0;
211 LOGW_ANR("leanr mode isp_dgain is wrong, use 1.0 instead\n");
212 } else {
213 stExpInfo.isp_dgain[0] = curExp->LinearExp.exp_real_params.isp_dgain;
214 }
215 // stExpInfo.arAGain[0] = 64.0;
216 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
217 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * 50 * stExpInfo.isp_dgain[0];
218 LOGD_ANR("anr: %s-%d curExp(%f, %f, %f, %f %d, %d)\n",
219 __FUNCTION__, __LINE__,
220 curExp->LinearExp.exp_real_params.analog_gain,
221 curExp->LinearExp.exp_real_params.integration_time,
222 curExp->LinearExp.exp_real_params.digital_gain,
223 curExp->LinearExp.exp_real_params.isp_dgain,
224 curExp->LinearExp.exp_real_params.dcg_mode,
225 curExp->CISFeature.SNR);
226 } else {
227 for(int i = 0; i < 3; i++) {
228 if(curExp->HdrExp[i].exp_real_params.analog_gain < 1.0) {
229 stExpInfo.arAGain[i] = 1.0;
230 LOGW_ANR("hdr mode again is wrong, use 1.0 instead\n");
231 } else {
232 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
233 }
234 if(curExp->HdrExp[i].exp_real_params.digital_gain < 1.0) {
235 stExpInfo.arDGain[i] = 1.0;
236 LOGW_ANR("hdr mode dgain is wrong, use 1.0 instead\n");
237 } else {
238 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
239 }
240 if(curExp->HdrExp[i].exp_real_params.isp_dgain < 1.0) {
241 stExpInfo.isp_dgain[i] = 1.0;
242 LOGW_ANR("hdr mode isp_dgain is wrong, use 1.0 instead\n");
243 } else {
244 stExpInfo.isp_dgain[i] = curExp->HdrExp[i].exp_real_params.isp_dgain;
245 }
246 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
247 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50 * stExpInfo.isp_dgain[i];
248
249 LOGD_ANR("%s:%d index:%d again:%f dgain:%f isp_dgain:%f time:%f iso:%d hdr_mode:%d \n",
250 __FUNCTION__, __LINE__,
251 i,
252 stExpInfo.arAGain[i],
253 stExpInfo.arDGain[i],
254 stExpInfo.isp_dgain[i],
255 stExpInfo.arTime[i],
256 stExpInfo.arIso[i],
257 stExpInfo.hdr_mode);
258 }
259 }
260 } else {
261 LOGE_ANR("%s:%d curExp(%p) is NULL, so use default instead \n",
262 __FUNCTION__, __LINE__, curExp);
263 }
264
265
266 #if 0
267 static int anr_cnt = 0;
268 anr_cnt++;
269
270 if(anr_cnt % 1 == 0) {
271 for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
272 printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d\n",
273 __FUNCTION__, __LINE__,
274 i,
275 stExpInfo.arAGain[i],
276 stExpInfo.arDGain[i],
277 stExpInfo.arTime[i],
278 stExpInfo.arIso[i],
279 stExpInfo.hdr_mode);
280 }
281 }
282 #endif
283
284
285
286 #endif
287
288 deltaIso = abs(stExpInfo.arIso[stExpInfo.hdr_mode] - pAgainCtx->stExpInfo.arIso[stExpInfo.hdr_mode]);
289 if(deltaIso > AGAINV2_RECALCULATE_DELTA_ISO) {
290 pAgainCtx->isReCalculate |= 1;
291 }
292
293 if(pAgainCtx->isReCalculate) {
294 Again_result_V2_t ret = Again_Process_V2(pAgainCtx, &stExpInfo);
295 if(ret != AGAINV2_RET_SUCCESS) {
296 result = XCAM_RETURN_ERROR_FAILED;
297 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
298 }
299
300 outparams->cfg_update = true;
301 } else {
302 outparams->cfg_update = false;
303 }
304 Again_GetProcResult_V2(pAgainCtx, &pAgainProcResParams->stAgainProcResult);
305 pAgainCtx->isReCalculate = 0;
306 #endif
307
308 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
309 return XCAM_RETURN_NO_ERROR;
310 }
311
312 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)313 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
314 {
315 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
316
317 //nothing todo now
318
319 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
320 return XCAM_RETURN_NO_ERROR;
321 }
322
323 RkAiqAlgoDescription g_RkIspAlgoDescAgainV2 = {
324 .common = {
325 .version = RKISP_ALGO_AGAIN_VERSION_V2,
326 .vendor = RKISP_ALGO_AGAIN_VENDOR_V2,
327 .description = RKISP_ALGO_AGAIN_DESCRIPTION_V2,
328 .type = RK_AIQ_ALGO_TYPE_AGAIN,
329 .id = 0,
330 .create_context = create_context,
331 .destroy_context = destroy_context,
332 },
333 .prepare = prepare,
334 .pre_process = NULL,
335 .processing = processing,
336 .post_process = NULL,
337 };
338
339 RKAIQ_END_DECLARE
340