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 "abayertnr2/rk_aiq_abayertnr_algo_itf_v2.h"
21 #include "abayertnr2/rk_aiq_abayertnr_algo_v2.h"
22 #include "rk_aiq_algo_types.h"
23 
24 RKAIQ_BEGIN_DECLARE
25 
26 typedef struct _RkAiqAlgoContext {
27     Abayertnr_Context_V2_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_V2_t* pAbayertnrCtx = NULL;
40 #if (ABAYERTNR_USE_JSON_FILE_V2)
41     Abayertnr_result_V2_t ret = Abayertnr_Init_V2(&pAbayertnrCtx, cfg->calibv2);
42 #endif
43     if(ret != ABAYERTNRV2_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_V2_t* pAbayertnrCtx = (Abayertnr_Context_V2_t*)context;
64     Abayertnr_result_V2_t ret = Abayertnr_Release_V2(pAbayertnrCtx);
65     if(ret != ABAYERTNRV2_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_V2_t* pAbayertnrCtx = (Abayertnr_Context_V2_t *)params->ctx;
83     RkAiqAlgoConfigAbayertnrV2* pCfgParam = (RkAiqAlgoConfigAbayertnrV2*)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_V2
88         void *pCalibDbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
89         CalibDbV2_BayerTnrV2_t *bayertnr_v2 = (CalibDbV2_BayerTnrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbV2, bayertnr_v2));
90         pAbayertnrCtx->bayertnr_v2 = *bayertnr_v2;
91 #endif
92         pAbayertnrCtx->isIQParaUpdate = true;
93         pAbayertnrCtx->isReCalculate |= 1;
94     }
95 
96     Abayertnr_result_V2_t ret = Abayertnr_Prepare_V2(pAbayertnrCtx, &pCfgParam->stAbayertnrConfig);
97     if(ret != ABAYERTNRV2_RET_SUCCESS) {
98         result = XCAM_RETURN_ERROR_FAILED;
99         LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
100     }
101 
102     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
103     return result;
104 }
105 
106 static XCamReturn
pre_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)107 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
108 {
109     XCamReturn result = XCAM_RETURN_NO_ERROR;
110     bool oldGrayMode = false;
111 
112     LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
113     Abayertnr_Context_V2_t* pAbayertnrCtx = (Abayertnr_Context_V2_t *)inparams->ctx;
114 
115     RkAiqAlgoPreAbayertnrV2* pAbayertnrPreParams = (RkAiqAlgoPreAbayertnrV2*)inparams;
116 
117     oldGrayMode = pAbayertnrCtx->isGrayMode;
118     if (pAbayertnrPreParams->com.u.proc.gray_mode) {
119         pAbayertnrCtx->isGrayMode = true;
120     } else {
121         pAbayertnrCtx->isGrayMode = false;
122     }
123 
124     if(oldGrayMode != pAbayertnrCtx->isGrayMode) {
125         pAbayertnrCtx->isReCalculate |= 1;
126     }
127 
128     Abayertnr_result_V2_t ret = Abayertnr_PreProcess_V2(pAbayertnrCtx);
129     if(ret != ABAYERTNRV2_RET_SUCCESS) {
130         result = XCAM_RETURN_ERROR_FAILED;
131         LOGE_ANR("%s: ANRPreProcess failed (%d)\n", __FUNCTION__, ret);
132     }
133 
134     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
135     return result;
136 }
137 
138 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)139 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
140 {
141     XCamReturn result = XCAM_RETURN_NO_ERROR;
142     int delta_iso = 0;
143 
144     LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
145 
146 #if 1
147     RkAiqAlgoProcAbayertnrV2* pAbayertnrProcParams = (RkAiqAlgoProcAbayertnrV2*)inparams;
148     RkAiqAlgoProcResAbayertnrV2* pAbayertnrProcResParams = (RkAiqAlgoProcResAbayertnrV2*)outparams;
149     Abayertnr_Context_V2_t* pAbayertnrCtx = (Abayertnr_Context_V2_t *)inparams->ctx;
150     Abayertnr_ExpInfo_V2_t stExpInfo;
151     memset(&stExpInfo, 0x00, sizeof(Abayertnr_ExpInfo_V2_t));
152 
153     LOGD_ANR("%s:%d init:%d hdr mode:%d  \n",
154              __FUNCTION__, __LINE__,
155              inparams->u.proc.init,
156              pAbayertnrProcParams->hdr_mode);
157 
158     stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
159     for(int i = 0; i < 3; i++) {
160         stExpInfo.arIso[i] = 50;
161         stExpInfo.arAGain[i] = 1.0;
162         stExpInfo.arDGain[i] = 1.0;
163         stExpInfo.arTime[i] = 0.01;
164     }
165 
166     if(pAbayertnrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
167         stExpInfo.hdr_mode = 0;
168     } else if(pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
169               || pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
170         stExpInfo.hdr_mode = 1;
171     } else if(pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
172               || pAbayertnrProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
173         stExpInfo.hdr_mode = 2;
174     }
175     stExpInfo.snr_mode = 0;
176 
177 #if 0// TODO Merge:
178     XCamVideoBuffer* xCamAePreRes = pAbayertnrProcParams->com.u.proc.res_comb->ae_pre_res;
179     RkAiqAlgoPreResAe* pAEPreRes = nullptr;
180     if (xCamAePreRes) {
181         // xCamAePreRes->ref(xCamAePreRes);
182         pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
183         if (!pAEPreRes) {
184             LOGE_ANR("ae pre result is null");
185         } else {
186 
187         }
188     }
189 #endif
190 
191     RKAiqAecExpInfo_t *curExp = pAbayertnrProcParams->com.u.proc.curExp;
192     if(curExp != NULL) {
193         stExpInfo.snr_mode = curExp->CISFeature.SNR;
194         if(pAbayertnrProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
195             stExpInfo.hdr_mode = 0;
196             if(curExp->LinearExp.exp_real_params.analog_gain < 1.0) {
197                 stExpInfo.arAGain[0] = 1.0;
198                 LOGW_ANR("leanr mode again is wrong, use 1.0 instead\n");
199             } else {
200                 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
201             }
202             if(curExp->LinearExp.exp_real_params.digital_gain < 1.0) {
203                 stExpInfo.arDGain[0] = 1.0;
204                 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
205             } else {
206                 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
207             }
208             if(curExp->LinearExp.exp_real_params.isp_dgain < 1.0) {
209                 stExpInfo.arDGain[0] *= 1.0;
210                 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
211             } else {
212                 stExpInfo.arDGain[0] *= curExp->LinearExp.exp_real_params.isp_dgain;
213             }
214             stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
215             stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * 50;
216         } else {
217             for(int i = 0; i < 3; i++) {
218                 if(curExp->HdrExp[i].exp_real_params.analog_gain < 1.0) {
219                     stExpInfo.arAGain[i] = 1.0;
220                     LOGW_ANR("hdr mode again is wrong, use 1.0 instead\n");
221                 } else {
222                     stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
223                 }
224                 if(curExp->HdrExp[i].exp_real_params.digital_gain < 1.0) {
225                     stExpInfo.arDGain[i] = 1.0;
226                 } else {
227                     LOGW_ANR("hdr mode dgain is wrong, use 1.0 instead\n");
228                     stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
229                 }
230                 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
231                 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50;
232 
233                 LOGD_ANR("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d\n",
234                          __FUNCTION__, __LINE__,
235                          i,
236                          stExpInfo.arAGain[i],
237                          stExpInfo.arDGain[i],
238                          stExpInfo.arTime[i],
239                          stExpInfo.arIso[i],
240                          stExpInfo.hdr_mode);
241             }
242         }
243     } else {
244         LOGE_ANR("%s:%d curExp is NULL, so use default instead \n", __FUNCTION__, __LINE__);
245     }
246 
247 
248 #if 0
249     static int anr_cnt = 0;
250     anr_cnt++;
251 
252     if(anr_cnt % 50 == 0) {
253         for(int i = 0; i < stExpInfo.hdr_mode + 1; i++) {
254             printf("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d snr_mode:%d\n",
255                    __FUNCTION__, __LINE__,
256                    i,
257                    stExpInfo.arAGain[i],
258                    stExpInfo.arDGain[i],
259                    stExpInfo.arTime[i],
260                    stExpInfo.arIso[i],
261                    stExpInfo.hdr_mode,
262                    stExpInfo.snr_mode);
263         }
264     }
265 #endif
266     delta_iso = abs(stExpInfo.arIso[stExpInfo.hdr_mode] - pAbayertnrCtx->stExpInfo.arIso[stExpInfo.hdr_mode]);
267     if(delta_iso > ABAYERTNRV2_DELTA_ISO) {
268         pAbayertnrCtx->isReCalculate |= 1;
269     }
270 
271     if(pAbayertnrCtx->isReCalculate) {
272         Abayertnr_result_V2_t ret = Abayertnr_Process_V2(pAbayertnrCtx, &stExpInfo);
273         if(ret != ABAYERTNRV2_RET_SUCCESS) {
274             result = XCAM_RETURN_ERROR_FAILED;
275             LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
276         }
277 
278         Abayertnr_GetProcResult_V2(pAbayertnrCtx, &pAbayertnrProcResParams->stAbayertnrProcResult);
279 
280         LOGD_ANR("recalculate: %d delta_iso:%d \n ", pAbayertnrCtx->isReCalculate, delta_iso);
281 
282         outparams->cfg_update = true;
283     } else {
284         outparams->cfg_update = false;
285     }
286 
287     pAbayertnrCtx->isReCalculate = 0;
288 
289 #endif
290 
291     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
292     return XCAM_RETURN_NO_ERROR;
293 }
294 
295 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)296 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
297 {
298     LOGI_ANR("%s: (enter)\n", __FUNCTION__ );
299 
300     //nothing todo now
301 
302     LOGI_ANR("%s: (exit)\n", __FUNCTION__ );
303     return XCAM_RETURN_NO_ERROR;
304 }
305 
306 RkAiqAlgoDescription g_RkIspAlgoDescAbayertnrV2 = {
307     .common = {
308         .version = RKISP_ALGO_ABAYERTNR_VERSION_V2,
309         .vendor  = RKISP_ALGO_ABAYERTNR_VENDOR_V2,
310         .description = RKISP_ALGO_ABAYERTNR_DESCRIPTION_V2,
311         .type    = RK_AIQ_ALGO_TYPE_AMFNR,
312         .id      = 0,
313         .create_context  = create_context,
314         .destroy_context = destroy_context,
315     },
316     .prepare = prepare,
317     .pre_process = pre_process,
318     .processing = processing,
319     .post_process = post_process,
320 };
321 
322 RKAIQ_END_DECLARE
323