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 "aynr/rk_aiq_aynr_algo_itf_v1.h"
21 #include "aynr/rk_aiq_aynr_algo_v1.h"
22 #include "rk_aiq_algo_types.h"
23
24 RKAIQ_BEGIN_DECLARE
25
26 typedef struct _RkAiqAlgoContext {
27 void* place_holder[0];
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) calibdb:%p \n", __FUNCTION__, cfg->calib);
37
38 Aynr_Context_V1_t* pAynrCtx = NULL;
39
40 #if AYNR_USE_JSON_PARA_V1
41 Aynr_Result_V1_t ret = Aynr_Init_Json_V1(&pAynrCtx, cfg->calibv2);
42 #else
43 Aynr_Result_V1_t ret = Aynr_Init_V1(&pAynrCtx, cfg->calib);
44 #endif
45 if(ret != AYNR_RET_V1_SUCCESS) {
46 result = XCAM_RETURN_ERROR_FAILED;
47 LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
48 } else {
49 *context = (RkAiqAlgoContext *)(pAynrCtx);
50 }
51
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 Aynr_Context_V1_t* pAynrCtx = (Aynr_Context_V1_t*)context;
66 Aynr_Result_V1_t ret = Aynr_Release_V1(pAynrCtx);
67 if(ret != AYNR_RET_V1_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 Aynr_Context_V1_t* pAynrCtx = (Aynr_Context_V1_t *)params->ctx;
85 RkAiqAlgoConfigAynr* pCfgParam = (RkAiqAlgoConfigAynr*)params;
86 pAynrCtx->prepare_type = params->u.prepare.conf_type;
87
88 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )){
89 #if AYNR_USE_JSON_FILE_V1
90 void *pCalibDbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
91 CalibDbV2_YnrV1_t *ynr_v1 = (CalibDbV2_YnrV1_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbV2, ynr_v1));
92 ynr_calibdbV2_assign_v1(&pAynrCtx->ynr_v1, ynr_v1);
93 #else
94 void *pCalibDb = (void*)(pCfgParam->com.u.prepare.calib);
95 pAynrCtx->stYnrCalib=
96 *(CalibDb_YNR_2_t*)(CALIBDB_GET_MODULE_PTR((void*)pCalibDb, ynr));
97 #endif
98 pAynrCtx->isIQParaUpdate = true;
99 }
100
101 Aynr_Result_V1_t ret = Aynr_Prepare_V1(pAynrCtx, &pCfgParam->stAynrConfig);
102 if(ret != AYNR_RET_V1_SUCCESS) {
103 result = XCAM_RETURN_ERROR_FAILED;
104 LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
105 }
106
107 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
108 return result;
109 }
110
111 static XCamReturn
pre_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)112 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
113 {
114 XCamReturn result = XCAM_RETURN_NO_ERROR;
115
116 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
117 Aynr_Context_V1_t* pAynrCtx = (Aynr_Context_V1_t *)inparams->ctx;
118
119 RkAiqAlgoPreAynr* pAnrPreParams = (RkAiqAlgoPreAynr*)inparams;
120
121 if (pAnrPreParams->com.u.proc.gray_mode) {
122 pAynrCtx->isGrayMode = true;
123 }else {
124 pAynrCtx->isGrayMode = false;
125 }
126
127 Aynr_Result_V1_t ret = Aynr_PreProcess_V1(pAynrCtx);
128 if(ret != AYNR_RET_V1_SUCCESS) {
129 result = XCAM_RETURN_ERROR_FAILED;
130 LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
131 }
132
133 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
134 return result;
135 }
136
137 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)138 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
139 {
140 XCamReturn result = XCAM_RETURN_NO_ERROR;
141
142 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
143
144 #if 1
145 RkAiqAlgoProcAynr* pAynrProcParams = (RkAiqAlgoProcAynr*)inparams;
146 RkAiqAlgoProcResAynr* pAynrProcResParams = (RkAiqAlgoProcResAynr*)outparams;
147 Aynr_Context_V1_t* pAynrCtx = (Aynr_Context_V1_t *)inparams->ctx;
148 Aynr_ExpInfo_V1_t stExpInfo;
149 memset(&stExpInfo, 0x00, sizeof(Aynr_ExpInfo_V1_t));
150
151 LOGD_ANR("%s:%d init:%d hdr mode:%d \n",
152 __FUNCTION__, __LINE__,
153 inparams->u.proc.init,
154 pAynrProcParams->hdr_mode);
155
156 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
157 for(int i = 0; i < 3; i++) {
158 stExpInfo.arIso[i] = 50;
159 stExpInfo.arAGain[i] = 1.0;
160 stExpInfo.arDGain[i] = 1.0;
161 stExpInfo.arTime[i] = 0.01;
162 }
163
164 if(pAynrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
165 stExpInfo.hdr_mode = 0;
166 } else if(pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
167 || pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
168 stExpInfo.hdr_mode = 1;
169 } else if(pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
170 || pAynrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
171 stExpInfo.hdr_mode = 2;
172 }
173 stExpInfo.snr_mode = 0;
174
175 #if 1
176 RKAiqAecExpInfo_t *preExp = pAynrProcParams->com.u.proc.preExp;
177 RKAiqAecExpInfo_t *curExp = pAynrProcParams->com.u.proc.curExp;
178
179 if(preExp != NULL && curExp != NULL) {
180 stExpInfo.cur_snr_mode = curExp->CISFeature.SNR;
181 stExpInfo.pre_snr_mode = preExp->CISFeature.SNR;
182 if(pAynrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
183 stExpInfo.hdr_mode = 0;
184 stExpInfo.arAGain[0] = 1;//curExp->LinearExp.exp_real_params.analog_gain;
185 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
186 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
187 stExpInfo.arDcgMode[0] = curExp->LinearExp.exp_real_params.dcg_mode;
188 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * 50;
189
190 stExpInfo.preAGain[0] = 1;//preExp->LinearExp.exp_real_params.analog_gain;
191 stExpInfo.preDGain[0] = preExp->LinearExp.exp_real_params.digital_gain;
192 stExpInfo.preTime[0] = preExp->LinearExp.exp_real_params.integration_time;
193 stExpInfo.preDcgMode[0] = preExp->LinearExp.exp_real_params.dcg_mode;
194 stExpInfo.preIso[0] = stExpInfo.preAGain[0] * stExpInfo.preDGain[0] * 50;
195 LOGD_ANR("anr: %s-%d, preExp(%f, %f, %f, %d, %d), curExp(%f, %f, %f, %d, %d)\n",
196 __FUNCTION__, __LINE__,
197 preExp->LinearExp.exp_real_params.analog_gain,
198 preExp->LinearExp.exp_real_params.integration_time,
199 preExp->LinearExp.exp_real_params.digital_gain,
200 preExp->LinearExp.exp_real_params.dcg_mode,
201 preExp->CISFeature.SNR,
202 curExp->LinearExp.exp_real_params.analog_gain,
203 curExp->LinearExp.exp_real_params.integration_time,
204 curExp->LinearExp.exp_real_params.digital_gain,
205 curExp->LinearExp.exp_real_params.dcg_mode,
206 curExp->CISFeature.SNR);
207 } else {
208 for(int i = 0; i < 3; i++) {
209 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain,
210 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
211 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
212 stExpInfo.arDcgMode[i] = curExp->HdrExp[i].exp_real_params.dcg_mode;
213 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50;
214
215 stExpInfo.preAGain[i] = preExp->HdrExp[i].exp_real_params.analog_gain,
216 stExpInfo.preDGain[i] = preExp->HdrExp[i].exp_real_params.digital_gain;
217 stExpInfo.preTime[i] = preExp->HdrExp[i].exp_real_params.integration_time;
218 stExpInfo.preDcgMode[i] = preExp->HdrExp[i].exp_real_params.dcg_mode;
219 stExpInfo.preIso[i] = stExpInfo.preAGain[i] * stExpInfo.preDGain[i] * 50;
220
221 LOGD_ANR("%s:%d index:%d again:%f %f dgain:%f %f time:%f %f iso:%d %d hdr_mode:%d \n",
222 __FUNCTION__, __LINE__,
223 i,
224 stExpInfo.preAGain[i], stExpInfo.arAGain[i],
225 stExpInfo.preDGain[i], stExpInfo.arDGain[i],
226 stExpInfo.preTime[i], stExpInfo.arTime[i],
227 stExpInfo.preIso[i], stExpInfo.arIso[i],
228 stExpInfo.hdr_mode);
229 }
230 }
231 } else {
232 LOGE_ANR("%s:%d preExp(%p) or curExp(%p) is NULL, so use default instead \n",
233 __FUNCTION__, __LINE__, preExp, curExp);
234 }
235
236 #if 0
237 static int anr_cnt = 0;
238 anr_cnt++;
239
240 if(anr_cnt % 50 == 0) {
241 for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
242 printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d\n",
243 __FUNCTION__, __LINE__,
244 i,
245 stExpInfo.arAGain[i],
246 stExpInfo.arDGain[i],
247 stExpInfo.arTime[i],
248 stExpInfo.arIso[i],
249 stExpInfo.hdr_mode);
250 }
251 }
252 #endif
253
254
255 #endif
256
257 Aynr_Result_V1_t ret = Aynr_Process_V1(pAynrCtx, &stExpInfo);
258 if(ret != AYNR_RET_V1_SUCCESS) {
259 result = XCAM_RETURN_ERROR_FAILED;
260 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
261 }
262
263 Aynr_GetProcResult_V1(pAynrCtx, &pAynrProcResParams->stAynrProcResult);
264 #endif
265
266 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
267 return XCAM_RETURN_NO_ERROR;
268 }
269
270 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)271 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
272 {
273 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
274
275 //nothing todo now
276
277 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
278 return XCAM_RETURN_NO_ERROR;
279 }
280
281 RkAiqAlgoDescription g_RkIspAlgoDescAynr = {
282 .common = {
283 .version = RKISP_ALGO_AYNR_VERSION_V1,
284 .vendor = RKISP_ALGO_AYNR_VENDOR_V1,
285 .description = RKISP_ALGO_AYNR_DESCRIPTION_V1,
286 .type = RK_AIQ_ALGO_TYPE_AYNR,
287 .id = 0,
288 .create_context = create_context,
289 .destroy_context = destroy_context,
290 },
291 .prepare = prepare,
292 .pre_process = pre_process,
293 .processing = processing,
294 .post_process = post_process,
295 };
296
297 RKAIQ_END_DECLARE
298