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 "again/rk_aiq_again_algo_itf.h"
21 #include "again/rk_aiq_again_algo.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)\n", __FUNCTION__ );
37
38 #if 1
39 Again_Context_V1_t* pAgainCtx = NULL;
40
41 #if(AUVNR_USE_JSON_FILE_V1)
42 Again_result_t ret = Again_Init_Json_V1(&pAgainCtx, cfg->calibv2);
43 #else
44 Again_result_t ret = Again_Init_V1(&pAgainCtx, cfg->calib);
45 #endif
46 if(ret != AGAIN_RET_SUCCESS) {
47 result = XCAM_RETURN_ERROR_FAILED;
48 LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
49 } else {
50 *context = (RkAiqAlgoContext *)(pAgainCtx);
51 }
52 #endif
53
54 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
55 return result;
56 }
57
58 static XCamReturn
destroy_context(RkAiqAlgoContext * context)59 destroy_context(RkAiqAlgoContext *context)
60 {
61 XCamReturn result = XCAM_RETURN_NO_ERROR;
62
63 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
64
65 #if 1
66 Again_Context_V1_t* pAgainCtx = (Again_Context_V1_t*)context;
67 Again_result_t ret = Again_Release_V1(pAgainCtx);
68 if(ret != AGAIN_RET_SUCCESS) {
69 result = XCAM_RETURN_ERROR_FAILED;
70 LOGE_ANR("%s: release ANR failed (%d)\n", __FUNCTION__, ret);
71 }
72 #endif
73
74 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
75 return result;
76 }
77
78 static XCamReturn
prepare(RkAiqAlgoCom * params)79 prepare(RkAiqAlgoCom* params)
80 {
81 XCamReturn result = XCAM_RETURN_NO_ERROR;
82
83 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
84
85 Again_Context_V1_t* pAgainCtx = (Again_Context_V1_t *)params->ctx;
86 RkAiqAlgoConfigAgain* pCfgParam = (RkAiqAlgoConfigAgain*)params;
87 pAgainCtx->prepare_type = params->u.prepare.conf_type;
88
89 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )){
90 #if AUVNR_USE_JSON_FILE_V1
91 void *pCalibDbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
92 CalibDbV2_MFNR_t* pCalibv2_mfnr_v1 =
93 (CalibDbV2_MFNR_t*)(CALIBDBV2_GET_MODULE_PTR(pCalibDbV2, mfnr_v1));
94 pAgainCtx->mfnr_mode_3to1 = pCalibv2_mfnr_v1->TuningPara.mode_3to1;
95 pAgainCtx->mfnr_local_gain_en = pCalibv2_mfnr_v1->TuningPara.local_gain_en;
96 #else
97 void *pCalibDb = (void*)(pCfgParam->com.u.prepare.calib);
98 CalibDb_MFNR_2_t *pMfnrCalib=
99 (CalibDb_MFNR_2_t*)(CALIBDB_GET_MODULE_PTR((void*)pCalibDb, mfnr));
100 pAgainCtx->mfnr_mode_3to1 = pMfnrCalib->mode_3to1;
101 pAgainCtx->mfnr_local_gain_en = pMfnrCalib->local_gain_en;
102 #endif
103 }
104
105 Again_result_t ret = Again_Prepare_V1(pAgainCtx, &pCfgParam->stAgainConfig);
106 if(ret != AGAIN_RET_SUCCESS) {
107 result = XCAM_RETURN_ERROR_FAILED;
108 LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
109 }
110
111 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
112 return result;
113 }
114
115 static XCamReturn
pre_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)116 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
117 {
118 XCamReturn result = XCAM_RETURN_NO_ERROR;
119
120 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
121 Again_Context_V1_t* pAgainCtx = (Again_Context_V1_t *)inparams->ctx;
122
123 RkAiqAlgoPreAgain* pAnrPreParams = (RkAiqAlgoPreAgain*)inparams;
124
125 if (pAnrPreParams->com.u.proc.gray_mode) {
126 pAgainCtx->isGrayMode = true;
127 }else {
128 pAgainCtx->isGrayMode = false;
129 }
130
131 Again_result_t ret = Again_PreProcess_V1(pAgainCtx);
132 if(ret != AGAIN_RET_SUCCESS) {
133 result = XCAM_RETURN_ERROR_FAILED;
134 LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
135 }
136
137 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
138 return result;
139 }
140
141 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)142 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
143 {
144 XCamReturn result = XCAM_RETURN_NO_ERROR;
145
146 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
147
148 #if 1
149 RkAiqAlgoProcAgain* pAgainProcParams = (RkAiqAlgoProcAgain*)inparams;
150 RkAiqAlgoProcResAgain* pAgainProcResParams = (RkAiqAlgoProcResAgain*)outparams;
151 Again_Context_V1_t* pAgainCtx = (Again_Context_V1_t *)inparams->ctx;
152 Again_ExpInfo_t stExpInfo;
153 memset(&stExpInfo, 0x00, sizeof(Again_ExpInfo_t));
154
155 LOGD_ANR("%s:%d init:%d hdr mode:%d \n",
156 __FUNCTION__, __LINE__,
157 inparams->u.proc.init,
158 pAgainProcParams->hdr_mode);
159
160 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
161 for(int i = 0; i < 3; i++) {
162 stExpInfo.arIso[i] = 50;
163 stExpInfo.arAGain[i] = 1.0;
164 stExpInfo.arDGain[i] = 1.0;
165 stExpInfo.arTime[i] = 0.01;
166 }
167
168 if(pAgainProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
169 stExpInfo.hdr_mode = 0;
170 } else if(pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
171 || pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
172 stExpInfo.hdr_mode = 1;
173 } else if(pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
174 || pAgainProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
175 stExpInfo.hdr_mode = 2;
176 }
177 stExpInfo.snr_mode = 0;
178
179 #if 1// TODO Merge
180
181 RKAiqAecExpInfo_t *preExp = pAgainProcParams->com.u.proc.preExp;
182 RKAiqAecExpInfo_t *curExp = pAgainProcParams->com.u.proc.curExp;
183
184 if(preExp != NULL && curExp != NULL) {
185 stExpInfo.cur_snr_mode = curExp->CISFeature.SNR;
186 stExpInfo.pre_snr_mode = preExp->CISFeature.SNR;
187 if(pAgainProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
188 stExpInfo.hdr_mode = 0;
189 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
190 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
191 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
192 stExpInfo.arDcgMode[0] = curExp->LinearExp.exp_real_params.dcg_mode;
193 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * 50;
194
195 stExpInfo.preAGain[0] = preExp->LinearExp.exp_real_params.analog_gain;
196 stExpInfo.preDGain[0] = preExp->LinearExp.exp_real_params.digital_gain;
197 stExpInfo.preTime[0] = preExp->LinearExp.exp_real_params.integration_time;
198 stExpInfo.preDcgMode[0] = preExp->LinearExp.exp_real_params.dcg_mode;
199 stExpInfo.preIso[0] = stExpInfo.preAGain[0] * stExpInfo.preDGain[0] * 50;
200 LOGD_ANR("anr: %s-%d, preExp(%f, %f, %f, %d, %d), curExp(%f, %f, %f, %d, %d)\n",
201 __FUNCTION__, __LINE__,
202 preExp->LinearExp.exp_real_params.analog_gain,
203 preExp->LinearExp.exp_real_params.integration_time,
204 preExp->LinearExp.exp_real_params.digital_gain,
205 preExp->LinearExp.exp_real_params.dcg_mode,
206 preExp->CISFeature.SNR,
207 curExp->LinearExp.exp_real_params.analog_gain,
208 curExp->LinearExp.exp_real_params.integration_time,
209 curExp->LinearExp.exp_real_params.digital_gain,
210 curExp->LinearExp.exp_real_params.dcg_mode,
211 curExp->CISFeature.SNR);
212 } else {
213 for(int i = 0; i < 3; i++) {
214 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain,
215 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
216 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
217 stExpInfo.arDcgMode[i] = curExp->HdrExp[i].exp_real_params.dcg_mode;
218 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50;
219
220 stExpInfo.preAGain[i] = preExp->HdrExp[i].exp_real_params.analog_gain,
221 stExpInfo.preDGain[i] = preExp->HdrExp[i].exp_real_params.digital_gain;
222 stExpInfo.preTime[i] = preExp->HdrExp[i].exp_real_params.integration_time;
223 stExpInfo.preDcgMode[i] = preExp->HdrExp[i].exp_real_params.dcg_mode;
224 stExpInfo.preIso[i] = stExpInfo.preAGain[i] * stExpInfo.preDGain[i] * 50;
225
226 LOGD_ANR("%s:%d index:%d again:%f %f dgain:%f %f time:%f %f iso:%d %d hdr_mode:%d \n",
227 __FUNCTION__, __LINE__,
228 i,
229 stExpInfo.preAGain[i], stExpInfo.arAGain[i],
230 stExpInfo.preDGain[i], stExpInfo.arDGain[i],
231 stExpInfo.preTime[i], stExpInfo.arTime[i],
232 stExpInfo.preIso[i], stExpInfo.arIso[i],
233 stExpInfo.hdr_mode);
234 }
235 }
236 } else {
237 LOGE_ANR("%s:%d preExp(%p) or curExp(%p) is NULL, so use default instead \n",
238 __FUNCTION__, __LINE__, preExp, curExp);
239 }
240
241
242 #if 0
243 static int anr_cnt = 0;
244 anr_cnt++;
245
246 if(anr_cnt % 50 == 0) {
247 for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
248 printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d\n",
249 __FUNCTION__, __LINE__,
250 i,
251 stExpInfo.arAGain[i],
252 stExpInfo.arDGain[i],
253 stExpInfo.arTime[i],
254 stExpInfo.arIso[i],
255 stExpInfo.hdr_mode);
256 }
257 }
258 #endif
259
260 #if 0 //TODO: get mfnr result
261 //get mfnr select result
262 RkAiqAlgoProcResAmfnr* pAmfnrProcRes =
263 (RkAiqAlgoProcResAmfnr*)(pAgainProcParams->com.u.proc.proc_res_comb->amfnr_proc_res);
264 for(int i=0; i<17; i++){
265 pAgainCtx->stAuto.stSelect.fix_x_pos_dehaze[i] = pAmfnrProcRes->stAmfnrProcResult.stSelect.fix_x_pos_dehaze[i];
266 pAgainCtx->stAuto.stSelect.noise_sigma_dehaze[i] = pAmfnrProcRes->stAmfnrProcResult.stSelect.noise_sigma_dehaze[i];
267 }
268 #endif
269 #endif
270
271 Again_result_t ret = Again_Process_V1(pAgainCtx, &stExpInfo);
272 if(ret != AGAIN_RET_SUCCESS) {
273 result = XCAM_RETURN_ERROR_FAILED;
274 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
275 }
276
277 Again_GetProcResult_V1(pAgainCtx, &pAgainProcResParams->stAgainProcResult);
278 outparams->cfg_update = true;
279 #endif
280
281 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
282 return XCAM_RETURN_NO_ERROR;
283 }
284
285 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)286 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
287 {
288 LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
289
290 //nothing todo now
291
292 LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
293 return XCAM_RETURN_NO_ERROR;
294 }
295
296 RkAiqAlgoDescription g_RkIspAlgoDescAgain = {
297 .common = {
298 .version = RKISP_ALGO_AGAIN_VERSION_V1,
299 .vendor = RKISP_ALGO_AGAIN_VENDOR_V1,
300 .description = RKISP_ALGO_AGAIN_DESCRIPTION_V1,
301 .type = RK_AIQ_ALGO_TYPE_AGAIN,
302 .id = 0,
303 .create_context = create_context,
304 .destroy_context = destroy_context,
305 },
306 .prepare = prepare,
307 .pre_process = pre_process,
308 .processing = processing,
309 .post_process = post_process,
310 };
311
312 RKAIQ_END_DECLARE
313