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 "acnr/rk_aiq_acnr_algo_itf_v1.h"
21 #include "acnr/rk_aiq_acnr_algo_v1.h"
22 #include "rk_aiq_algo_types.h"
23 #include "RkAiqCalibDbV2Helper.h"
24
25 RKAIQ_BEGIN_DECLARE
26
27 typedef struct _RkAiqAlgoContext {
28 Acnr_Context_V1_t AcnrCtx;
29 } RkAiqAlgoContext;
30
31
32 static XCamReturn
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)33 create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
34 {
35
36 XCamReturn result = XCAM_RETURN_NO_ERROR;
37 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
38
39 #if 1
40 Acnr_Context_V1_t* pAcnrCtx = NULL;
41 #if ACNR_USE_JSON_FILE_V1
42 Acnr_result_t ret = Acnr_Init_V1(&pAcnrCtx, cfg->calibv2);
43 #else
44 Acnr_result_t ret = Acnr_Init_V1(&pAcnrCtx, cfg->calib);
45 #endif
46
47 if(ret != ACNR_RET_SUCCESS) {
48 result = XCAM_RETURN_ERROR_FAILED;
49 LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
50 } else {
51 *context = (RkAiqAlgoContext *)(pAcnrCtx);
52 }
53 #endif
54
55 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
56 return result;
57 }
58
59 static XCamReturn
destroy_context(RkAiqAlgoContext * context)60 destroy_context(RkAiqAlgoContext *context)
61 {
62 XCamReturn result = XCAM_RETURN_NO_ERROR;
63
64 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
65
66 #if 1
67 Acnr_Context_V1_t* pAcnrCtx = (Acnr_Context_V1_t*)context;
68 Acnr_result_t ret = Acnr_Release_V1(pAcnrCtx);
69 if(ret != ACNR_RET_SUCCESS) {
70 result = XCAM_RETURN_ERROR_FAILED;
71 LOGE_ANR("%s: release ANR failed (%d)\n", __FUNCTION__, ret);
72 }
73 #endif
74
75 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
76 return result;
77 }
78
79 static XCamReturn
prepare(RkAiqAlgoCom * params)80 prepare(RkAiqAlgoCom* params)
81 {
82 XCamReturn result = XCAM_RETURN_NO_ERROR;
83
84 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
85
86 Acnr_Context_V1_t* pAcnrCtx = (Acnr_Context_V1_t *)params->ctx;
87 RkAiqAlgoConfigAcnrV1* pCfgParam = (RkAiqAlgoConfigAcnrV1*)params;
88 pAcnrCtx->prepare_type = params->u.prepare.conf_type;
89
90 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
91 #if ACNR_USE_JSON_FILE_V1
92 void *pCalibDbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
93 CalibDbV2_CNR_t *cnr_v1 =
94 (CalibDbV2_CNR_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbV2, cnr_v1));
95 pAcnrCtx->cnr_v1 = *cnr_v1;
96 #else
97 void *pCalibDb = (void*)(pCfgParam->com.u.prepare.calib);
98 pAcnrCtx->list_cnr_v1 =
99 (struct list_head*)(CALIBDB_GET_MODULE_PTR((void*)pCalibDb, uvnr));
100
101 #endif
102 pAcnrCtx->isIQParaUpdate = true;
103 pAcnrCtx->isReCalculate |= 1;
104
105 }
106 Acnr_result_t ret = Acnr_Prepare_V1(pAcnrCtx, &pCfgParam->stAcnrConfig);
107 if(ret != ACNR_RET_SUCCESS) {
108 result = XCAM_RETURN_ERROR_FAILED;
109 LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
110 }
111
112 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
113 return result;
114 }
115
116 static XCamReturn
pre_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)117 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
118 {
119 XCamReturn result = XCAM_RETURN_NO_ERROR;
120 bool oldGrayMode = false;
121
122 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
123 Acnr_Context_V1_t* pAcnrCtx = (Acnr_Context_V1_t *)inparams->ctx;
124
125 RkAiqAlgoPreAcnrV1* pAnrPreParams = (RkAiqAlgoPreAcnrV1*)inparams;
126
127 oldGrayMode = pAcnrCtx->isGrayMode;
128 if (pAnrPreParams->com.u.proc.gray_mode) {
129 pAcnrCtx->isGrayMode = true;
130 } else {
131 pAcnrCtx->isGrayMode = false;
132 }
133
134 if(oldGrayMode != pAcnrCtx->isGrayMode) {
135 pAcnrCtx->isReCalculate |= 1;
136 }
137
138 Acnr_result_t ret = Acnr_PreProcess_V1(pAcnrCtx);
139 if(ret != ACNR_RET_SUCCESS) {
140 result = XCAM_RETURN_ERROR_FAILED;
141 LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
142 }
143
144 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
145 return result;
146 }
147
148 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)149 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
150 {
151 XCamReturn result = XCAM_RETURN_NO_ERROR;
152 int DeltaISO = 0;
153 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
154
155 #if 1
156 RkAiqAlgoProcAcnrV1* pAcnrProcParams = (RkAiqAlgoProcAcnrV1*)inparams;
157 RkAiqAlgoProcResAcnrV1* pAcnrProcResParams = (RkAiqAlgoProcResAcnrV1*)outparams;
158 Acnr_Context_V1_t* pAcnrCtx = (Acnr_Context_V1_t *)inparams->ctx;
159 Acnr_ExpInfo_t stExpInfo;
160 memset(&stExpInfo, 0x00, sizeof(Acnr_ExpInfo_t));
161
162 LOGD_ANR("%s:%d init:%d hdr mode:%d \n",
163 __FUNCTION__, __LINE__,
164 inparams->u.proc.init,
165 pAcnrProcParams->hdr_mode);
166
167 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
168 for(int i = 0; i < 3; i++) {
169 stExpInfo.arIso[i] = 50;
170 stExpInfo.arAGain[i] = 1.0;
171 stExpInfo.arDGain[i] = 1.0;
172 stExpInfo.arTime[i] = 0.01;
173 }
174
175 if(pAcnrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
176 stExpInfo.hdr_mode = 0;
177 } else if(pAcnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
178 || pAcnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
179 stExpInfo.hdr_mode = 1;
180 } else if(pAcnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
181 || pAcnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
182 stExpInfo.hdr_mode = 2;
183 }
184 stExpInfo.snr_mode = 0;
185
186 #if 0// TODO Merge:
187 XCamVideoBuffer* xCamAePreRes = pAcnrProcParams->com.u.proc.res_comb->ae_pre_res;
188 RkAiqAlgoPreResAe* pAEPreRes = nullptr;
189 if (xCamAePreRes) {
190 // xCamAePreRes->ref(xCamAePreRes);
191 pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
192 if (!pAEPreRes) {
193 LOGE_ANR("ae pre result is null");
194 } else {
195 }
196 // xCamAePreRes->unref(xCamAePreRes);
197 }
198 #endif
199
200
201 RKAiqAecExpInfo_t *curExp = pAcnrProcParams->com.u.proc.curExp;
202 if(curExp != NULL) {
203 stExpInfo.snr_mode = curExp->CISFeature.SNR;
204 if(pAcnrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
205 stExpInfo.hdr_mode = 0;
206 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
207 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
208 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
209 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * 50;
210 } else {
211 for(int i = 0; i < 3; i++) {
212 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
213 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
214 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
215 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50;
216
217 LOGD_ANR("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d\n",
218 __FUNCTION__, __LINE__,
219 i,
220 stExpInfo.arAGain[i],
221 stExpInfo.arDGain[i],
222 stExpInfo.arTime[i],
223 stExpInfo.arIso[i],
224 stExpInfo.hdr_mode);
225 }
226 }
227 } else {
228 LOGE_ANR("%s:%d curExp is NULL, so use default instead \n", __FUNCTION__, __LINE__);
229 }
230
231 #if 0
232 static int anr_cnt = 0;
233 anr_cnt++;
234
235 if(anr_cnt % 50 == 0) {
236 for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
237 printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d snr_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 stExpInfo.snr_mode);
246 }
247 }
248 #endif
249
250 DeltaISO = abs(stExpInfo.arIso[stExpInfo.hdr_mode] - pAcnrCtx->stExpInfo.arIso[pAcnrCtx->stExpInfo.hdr_mode]);
251 if(DeltaISO > ACNRV1_RECALCULATE_DELTA_ISO) {
252 pAcnrCtx->isReCalculate |= 1;
253 }
254
255 if(pAcnrCtx->isReCalculate) {
256 Acnr_result_t ret = Acnr_Process_V1(pAcnrCtx, &stExpInfo);
257 if(ret != ACNR_RET_SUCCESS) {
258 result = XCAM_RETURN_ERROR_FAILED;
259 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
260 }
261
262 Acnr_GetProcResult_V1(pAcnrCtx, &pAcnrProcResParams->stAcnrProcResult);
263 outparams->cfg_update = true;
264 LOGD_ANR("recalculate: %d delta_iso:%d \n ", pAcnrCtx->isReCalculate, DeltaISO);
265 } else {
266 outparams->cfg_update = false;
267 }
268 #endif
269
270 pAcnrCtx->isReCalculate = 0;
271 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
272 return XCAM_RETURN_NO_ERROR;
273 }
274
275 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)276 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
277 {
278 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
279
280 //nothing todo now
281
282 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
283 return XCAM_RETURN_NO_ERROR;
284 }
285
286 RkAiqAlgoDescription g_RkIspAlgoDescAcnrV1 = {
287 .common = {
288 .version = RKISP_ALGO_ACNR_VERSION_V1,
289 .vendor = RKISP_ALGO_ACNR_VENDOR_V1,
290 .description = RKISP_ALGO_ACNR_DESCRIPTION_V1,
291 .type = RK_AIQ_ALGO_TYPE_ACNR,
292 .id = 0,
293 .create_context = create_context,
294 .destroy_context = destroy_context,
295 },
296 .prepare = prepare,
297 .pre_process = pre_process,
298 .processing = processing,
299 .post_process = post_process,
300 };
301
302 RKAIQ_END_DECLARE
303