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 "abayertnrV23/rk_aiq_abayertnr_algo_itf_v23.h"
21 #include "abayertnrV23/rk_aiq_abayertnr_algo_v23.h"
22 #include "rk_aiq_algo_types.h"
23 
24 RKAIQ_BEGIN_DECLARE
25 
26 typedef struct _RkAiqAlgoContext {
27     Abayertnr_Context_V23_t AbayertnrCtx;
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     Abayertnr_Context_V23_t* pAbayertnrCtx = NULL;
40 #if (ABAYERTNR_USE_JSON_FILE_V23)
41     Abayertnr_result_V23_t ret = Abayertnr_Init_V23(&pAbayertnrCtx, cfg->calibv2);
42 #endif
43     if(ret != ABAYERTNRV23_RET_SUCCESS) {
44         result = XCAM_RETURN_ERROR_FAILED;
45         LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
46     } else {
47         *context = (RkAiqAlgoContext *)(pAbayertnrCtx);
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     Abayertnr_Context_V23_t* pAbayertnrCtx = (Abayertnr_Context_V23_t*)context;
64     Abayertnr_result_V23_t ret = Abayertnr_Release_V23(pAbayertnrCtx);
65     if(ret != ABAYERTNRV23_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     Abayertnr_Context_V23_t* pAbayertnrCtx = (Abayertnr_Context_V23_t *)params->ctx;
83     RkAiqAlgoConfigAbayertnrV23* pCfgParam = (RkAiqAlgoConfigAbayertnrV23*)params;
84     pAbayertnrCtx->prepare_type = params->u.prepare.conf_type;
85 
86     if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
87 #if ABAYERTNR_USE_JSON_FILE_V23
88         void* pCalibDbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
89 #if (RKAIQ_HAVE_BAYERTNR_V23)
90         CalibDbV2_BayerTnrV23_t *bayertnr_v23 = (CalibDbV2_BayerTnrV23_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbV2, bayertnr_v23));
91 #else
92         CalibDbV2_BayerTnrV23Lite_t* bayertnr_v23 =
93             (CalibDbV2_BayerTnrV23Lite_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbV2,
94                                                                     bayertnr_v23));
95 #endif
96         pAbayertnrCtx->bayertnr_v23 = *bayertnr_v23;
97 #endif
98         pAbayertnrCtx->isIQParaUpdate = true;
99         pAbayertnrCtx->isReCalculate |= 1;
100     }
101 
102     Abayertnr_result_V23_t ret = Abayertnr_Prepare_V23(pAbayertnrCtx, &pCfgParam->stAbayertnrConfig);
103     if(ret != ABAYERTNRV23_RET_SUCCESS) {
104         result = XCAM_RETURN_ERROR_FAILED;
105         LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
106     }
107 
108     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
109     return result;
110 }
111 #if 0
112 static XCamReturn
113 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
114 {
115     XCamReturn result = XCAM_RETURN_NO_ERROR;
116     bool oldGrayMode = false;
117 
118     LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
119     Abayertnr_Context_V23_t* pAbayertnrCtx = (Abayertnr_Context_V23_t *)inparams->ctx;
120 
121     RkAiqAlgoPreAbayertnrV23* pAbayertnrPreParams = (RkAiqAlgoPreAbayertnrV23*)inparams;
122 
123     oldGrayMode = pAbayertnrCtx->isGrayMode;
124     if (pAbayertnrPreParams->com.u.proc.gray_mode) {
125         pAbayertnrCtx->isGrayMode = true;
126     } else {
127         pAbayertnrCtx->isGrayMode = false;
128     }
129 
130     if(oldGrayMode != pAbayertnrCtx->isGrayMode) {
131         pAbayertnrCtx->isReCalculate |= 1;
132     }
133 
134     Abayertnr_result_V23_t ret = Abayertnr_PreProcess_V23(pAbayertnrCtx);
135     if(ret != ABAYERTNRV23_RET_SUCCESS) {
136         result = XCAM_RETURN_ERROR_FAILED;
137         LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
138     }
139 
140     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
141     return result;
142 }
143 #endif
144 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)145 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
146 {
147     XCamReturn result = XCAM_RETURN_NO_ERROR;
148     int delta_iso = 0;
149 
150     LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
151 
152 #if 1
153     RkAiqAlgoProcAbayertnrV23* pAbayertnrProcParams = (RkAiqAlgoProcAbayertnrV23*)inparams;
154     RkAiqAlgoProcResAbayertnrV23* pAbayertnrProcResParams = (RkAiqAlgoProcResAbayertnrV23*)outparams;
155     Abayertnr_Context_V23_t* pAbayertnrCtx = (Abayertnr_Context_V23_t *)inparams->ctx;
156     Abayertnr_ExpInfo_V23_t stExpInfo;
157     memset(&stExpInfo, 0x00, sizeof(Abayertnr_ExpInfo_V23_t));
158 
159     LOGD_ANR("%s:%d init:%d hdr mode:%d  \n",
160              __FUNCTION__, __LINE__,
161              inparams->u.proc.init,
162              pAbayertnrProcParams->hdr_mode);
163 
164     bool oldGrayMode = false;
165     oldGrayMode = pAbayertnrCtx->isGrayMode;
166     if (inparams->u.proc.gray_mode) {
167         pAbayertnrCtx->isGrayMode = true;
168     } else {
169         pAbayertnrCtx->isGrayMode = false;
170     }
171 
172     if(oldGrayMode != pAbayertnrCtx->isGrayMode) {
173         pAbayertnrCtx->isReCalculate |= 1;
174     }
175 
176     Abayertnr_result_V23_t ret = Abayertnr_PreProcess_V23(pAbayertnrCtx);
177     if(ret != ABAYERTNRV23_RET_SUCCESS) {
178         result = XCAM_RETURN_ERROR_FAILED;
179         LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
180     }
181 
182     stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
183     for(int i = 0; i < 3; i++) {
184         stExpInfo.arIso[i] = 50;
185         stExpInfo.arAGain[i] = 1.0;
186         stExpInfo.arDGain[i] = 1.0;
187         stExpInfo.arTime[i] = 0.01;
188     }
189 
190     if(pAbayertnrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
191         stExpInfo.hdr_mode = 0;
192     } else if(pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
193               || pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
194         stExpInfo.hdr_mode = 1;
195     } else if(pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
196               || pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
197         stExpInfo.hdr_mode = 2;
198     }
199     stExpInfo.snr_mode = 0;
200 
201     stExpInfo.blc_ob_predgain = 1.0f;
202     if(pAbayertnrProcParams != NULL) {
203         LOGD_ANR(" predgain:%f\n",
204                  pAbayertnrProcParams->stAblcV32_proc_res->isp_ob_predgain);
205         stExpInfo.blc_ob_predgain = pAbayertnrProcParams->stAblcV32_proc_res->isp_ob_predgain;
206         if(stExpInfo.blc_ob_predgain != pAbayertnrCtx->stExpInfo.blc_ob_predgain) {
207             pAbayertnrCtx->isReCalculate |= 1;
208         }
209     }
210 #if 0// TODO Merge:
211     XCamVideoBuffer* xCamAePreRes = pAbayertnrProcParams->com.u.proc.res_comb->ae_pre_res;
212     RkAiqAlgoPreResAe* pAEPreRes = nullptr;
213     if (xCamAePreRes) {
214         // xCamAePreRes->ref(xCamAePreRes);
215         pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
216         if (!pAEPreRes) {
217             LOGE_ANR("ae pre result is null");
218         } else {
219 
220         }
221     }
222 #endif
223 
224     RKAiqAecExpInfo_t *curExp = pAbayertnrProcParams->com.u.proc.curExp;
225     if(curExp != NULL) {
226         stExpInfo.snr_mode = curExp->CISFeature.SNR;
227         if(pAbayertnrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
228             stExpInfo.hdr_mode = 0;
229             if(curExp->LinearExp.exp_real_params.analog_gain < 1.0) {
230                 stExpInfo.arAGain[0] = 1.0;
231                 LOGW_ANR("leanr mode again is wrong, use 1.0 instead\n");
232             } else {
233                 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
234             }
235             if(curExp->LinearExp.exp_real_params.digital_gain < 1.0) {
236                 stExpInfo.arDGain[0] = 1.0;
237                 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
238             } else {
239                 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
240             }
241             if(curExp->LinearExp.exp_real_params.isp_dgain < 1.0) {
242                 stExpInfo.isp_dgain[0] = 1.0;
243                 LOGW_ANR("leanr mode isp_dgain is wrong, use 1.0 instead\n");
244             } else {
245                 stExpInfo.isp_dgain[0] = curExp->LinearExp.exp_real_params.isp_dgain;
246             }
247             if(stExpInfo.blc_ob_predgain < 1.0) {
248                 stExpInfo.blc_ob_predgain = 1.0;
249             }
250             // stExpInfo.arAGain[0] = 64.0;
251             stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
252             stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * stExpInfo.blc_ob_predgain * 50 * stExpInfo.isp_dgain[0];
253         } else {
254             for(int i = 0; i < 3; i++) {
255                 if(curExp->HdrExp[i].exp_real_params.analog_gain < 1.0) {
256                     stExpInfo.arAGain[i] = 1.0;
257                     LOGW_ANR("hdr mode again is wrong, use 1.0 instead\n");
258                 } else {
259                     stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
260                 }
261                 if(curExp->HdrExp[i].exp_real_params.digital_gain < 1.0) {
262                     stExpInfo.arDGain[i] = 1.0;
263                 } else {
264                     LOGW_ANR("hdr mode dgain is wrong, use 1.0 instead\n");
265                     stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
266                 }
267                 if(curExp->HdrExp[i].exp_real_params.isp_dgain < 1.0) {
268                     stExpInfo.isp_dgain[i] = 1.0;
269                 } else {
270                     LOGW_ANR("hdr mode isp_dgain is wrong, use 1.0 instead\n");
271                     stExpInfo.isp_dgain[i] = curExp->HdrExp[i].exp_real_params.isp_dgain;
272                 }
273                 stExpInfo.blc_ob_predgain = 1.0;
274                 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
275                 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50 * stExpInfo.isp_dgain[i];
276 
277                 LOGD_ANR("%s:%d index:%d again:%f dgain:%f isp_dgain:%f time:%f iso:%d hdr_mode:%d\n",
278                          __FUNCTION__, __LINE__,
279                          i,
280                          stExpInfo.arAGain[i],
281                          stExpInfo.arDGain[i],
282                          stExpInfo.isp_dgain[i],
283                          stExpInfo.arTime[i],
284                          stExpInfo.arIso[i],
285                          stExpInfo.hdr_mode);
286             }
287         }
288     } else {
289         LOGE_ANR("%s:%d curExp is NULL, so use default instead \n", __FUNCTION__, __LINE__);
290     }
291 
292 
293 #if 0
294     static int anr_cnt = 0;
295     anr_cnt++;
296 
297     if(anr_cnt % 50 == 0) {
298         for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
299             printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d snr_mode:%d\n",
300                    __FUNCTION__, __LINE__,
301                    i,
302                    stExpInfo.arAGain[i],
303                    stExpInfo.arDGain[i],
304                    stExpInfo.arTime[i],
305                    stExpInfo.arIso[i],
306                    stExpInfo.hdr_mode,
307                    stExpInfo.snr_mode);
308         }
309     }
310 #endif
311     delta_iso = abs(stExpInfo.arIso[stExpInfo.hdr_mode] - pAbayertnrCtx->stExpInfo.arIso[stExpInfo.hdr_mode]);
312     if(delta_iso > ABAYERTNRV23_RECALCULATE_DELTA_ISO) {
313         pAbayertnrCtx->isReCalculate |= 1;
314     }
315 
316     if(pAbayertnrCtx->isReCalculate) {
317         Abayertnr_result_V23_t ret = Abayertnr_Process_V23(pAbayertnrCtx, &stExpInfo);
318         if(ret != ABAYERTNRV23_RET_SUCCESS) {
319             result = XCAM_RETURN_ERROR_FAILED;
320             LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
321         }
322 
323         Abayertnr_GetProcResult_V23(pAbayertnrCtx, &pAbayertnrProcResParams->stAbayertnrProcResult);
324 
325         LOGD_ANR("recalculate: %d delta_iso:%d \n ", pAbayertnrCtx->isReCalculate, delta_iso);
326 
327         outparams->cfg_update = true;
328     } else {
329         outparams->cfg_update = false;
330     }
331 
332     pAbayertnrCtx->isReCalculate = 0;
333 
334 #endif
335 
336     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
337     return XCAM_RETURN_NO_ERROR;
338 }
339 
340 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)341 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
342 {
343     LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
344 
345     //nothing todo now
346 
347     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
348     return XCAM_RETURN_NO_ERROR;
349 }
350 
351 RkAiqAlgoDescription g_RkIspAlgoDescAbayertnrV23 = {
352     .common = {
353         .version = RKISP_ALGO_ABAYERTNR_VERSION_V23,
354         .vendor  = RKISP_ALGO_ABAYERTNR_VENDOR_V23,
355         .description = RKISP_ALGO_ABAYERTNR_DESCRIPTION_V23,
356         .type    = RK_AIQ_ALGO_TYPE_AMFNR,
357         .id      = 0,
358         .create_context  = create_context,
359         .destroy_context = destroy_context,
360     },
361     .prepare = prepare,
362     .pre_process = NULL,
363     .processing = processing,
364     .post_process = NULL,
365 };
366 
367 RKAIQ_END_DECLARE
368