1 /*
2  * rk_aiq_algo_camgroup_awb_itf.c
3  *
4  *  Copyright (c) 2021 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 "rk_aiq_algo_camgroup_aynr_itf_v2.h"
21 #include "rk_aiq_algo_camgroup_types.h"
22 #include "rk_aiq_types_camgroup_aynr_prvt_v2.h"
23 #include "aynr2/rk_aiq_aynr_algo_itf_v2.h"
24 #include "aynr2/rk_aiq_aynr_algo_v2.h"
25 
26 
27 
28 RKAIQ_BEGIN_DECLARE
29 
30 
groupAynrV2CreateCtx(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)31 static XCamReturn groupAynrV2CreateCtx(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
32 {
33     LOGI_ANR("%s enter \n", __FUNCTION__ );
34 
35     XCamReturn ret = XCAM_RETURN_NO_ERROR;
36     CamGroup_AynrV2_Contex_t *aynr_group_contex = NULL;
37     AlgoCtxInstanceCfgCamGroup *cfgInt = (AlgoCtxInstanceCfgCamGroup*)cfg;
38 
39 
40     if(CHECK_ISP_HW_V21()) {
41         aynr_group_contex = (CamGroup_AynrV2_Contex_t*)malloc(sizeof(CamGroup_AynrV2_Contex_t));
42 #if (AYNR_USE_JSON_FILE_V2)
43         Aynr_result_t ret_v2 = AYNR_RET_SUCCESS;
44         ret_v2 = Aynr_Init_V2(&(aynr_group_contex->aynr_contex_v2), (void *)cfgInt->s_calibv2);
45         if(ret_v2 != AYNR_RET_SUCCESS) {
46             ret = XCAM_RETURN_ERROR_FAILED;
47             LOGE_ANR("%s: Initializaion ynr group v2 failed (%d)\n", __FUNCTION__, ret);
48         }
49 #endif
50     } else {
51         ret = XCAM_RETURN_ERROR_FAILED;
52         LOGE_ANR("module_hw_version of aynr is invalid!!!!");
53     }
54 
55     if(ret != XCAM_RETURN_NO_ERROR) {
56         LOGE_ANR("%s: Initializaion group ynr failed (%d)\n", __FUNCTION__, ret);
57     } else {
58         // to do got aynrSurrViewClib and initinal paras for for surround view
59         aynr_group_contex->group_CalibV2.groupMethod = CalibDbV2_CAMGROUP_AYNRV2_METHOD_MEAN;// to do from json
60         aynr_group_contex->camera_Num = cfgInt->camIdArrayLen;
61 
62         *context = (RkAiqAlgoContext *)(aynr_group_contex);
63 
64         LOGI_ANR("%s:%d surrViewMethod(1-mean):%d, cameraNum %d \n",
65                  __FUNCTION__, __LINE__,
66                  aynr_group_contex->group_CalibV2.groupMethod,
67                  aynr_group_contex->camera_Num);
68     }
69 
70     LOGI_ANR("%s exit ret:%d\n", __FUNCTION__, ret);
71     return ret;
72 
73 }
74 
groupAynrV2DestroyCtx(RkAiqAlgoContext * context)75 static XCamReturn groupAynrV2DestroyCtx(RkAiqAlgoContext *context)
76 {
77     LOGI_ANR("%s enter \n", __FUNCTION__ );
78 
79     XCamReturn ret = XCAM_RETURN_NO_ERROR;
80 
81     CamGroup_AynrV2_Contex_t *aynr_group_contex = (CamGroup_AynrV2_Contex_t*)context;
82 
83     if(CHECK_ISP_HW_V21()) {
84         Aynr_result_t ret_v2 = AYNR_RET_SUCCESS;
85         ret_v2 = Aynr_Release_V2(aynr_group_contex->aynr_contex_v2);
86         if(ret_v2 != AYNR_RET_SUCCESS) {
87             ret = XCAM_RETURN_ERROR_FAILED;
88             LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
89         }
90     }
91     else {
92         ret = XCAM_RETURN_ERROR_FAILED;
93         LOGE_ANR("module_hw_version of aynr is isvalid!!!!");
94     }
95 
96     if(ret != XCAM_RETURN_NO_ERROR) {
97         LOGE_ANR("%s: release ANR failed (%d)\n", __FUNCTION__, ret);
98     } else {
99         free(aynr_group_contex);
100     }
101 
102 
103     LOGI_ANR("%s exit ret:%d\n", __FUNCTION__, ret);
104     return ret;
105 }
106 
groupAynrV2Prepare(RkAiqAlgoCom * params)107 static XCamReturn groupAynrV2Prepare(RkAiqAlgoCom* params)
108 {
109     LOGI_ANR("%s enter \n", __FUNCTION__ );
110 
111     XCamReturn ret = XCAM_RETURN_NO_ERROR;
112 
113     CamGroup_AynrV2_Contex_t * aynr_group_contex = (CamGroup_AynrV2_Contex_t *)params->ctx;
114     RkAiqAlgoCamGroupPrepare* para = (RkAiqAlgoCamGroupPrepare*)params;
115 
116     if(CHECK_ISP_HW_V21()) {
117         Aynr_Context_V2_t * aynr_contex_v2 = aynr_group_contex->aynr_contex_v2;
118         if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
119             // todo  update calib pars for surround view
120 #if AYNR_USE_JSON_FILE_V2
121             void *pCalibdbV2 = (void*)(para->s_calibv2);
122             CalibDbV2_YnrV2_t *ynr_v2 = (CalibDbV2_YnrV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, ynr_v2));
123             aynr_contex_v2->ynr_v2 = *ynr_v2;
124             aynr_contex_v2->isIQParaUpdate = true;
125             aynr_contex_v2->isReCalculate |= 1;
126 #endif
127         }
128         Aynr_Config_V2_t stAynrConfigV2;
129         stAynrConfigV2.rawHeight =  params->u.prepare.sns_op_height;
130         stAynrConfigV2.rawWidth = params->u.prepare.sns_op_width;
131         Aynr_result_t ret_v2 = AYNR_RET_SUCCESS;
132         ret_v2 = Aynr_Prepare_V2(aynr_contex_v2, &stAynrConfigV2);
133         if(ret_v2 != AYNR_RET_SUCCESS) {
134             ret = XCAM_RETURN_ERROR_FAILED;
135             LOGE_ANR("%s: config ANR failed (%d)\n", __FUNCTION__, ret);
136         }
137     }
138     else {
139         ret = XCAM_RETURN_ERROR_FAILED;
140         LOGE_ANR("module_hw_version of aynr is isvalid!!!!");
141     }
142 
143     LOGI_ANR("%s exit ret:%d\n", __FUNCTION__, ret);
144     return ret;
145 }
146 
groupAynrV2Processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)147 static XCamReturn groupAynrV2Processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
148 {
149     LOGI_ANR("%s enter \n", __FUNCTION__ );
150     LOGI_ANR("----------------------------------------------frame_id (%d)----------------------------------------------\n", inparams->frame_id);
151 
152     XCamReturn ret = XCAM_RETURN_NO_ERROR;
153     RkAiqAlgoCamGroupProcIn* procParaGroup = (RkAiqAlgoCamGroupProcIn*)inparams;
154     RkAiqAlgoCamGroupProcOut* procResParaGroup = (RkAiqAlgoCamGroupProcOut*)outparams;
155     CamGroup_AynrV2_Contex_t * aynr_group_contex = (CamGroup_AynrV2_Contex_t *)inparams->ctx;
156     int deltaIso = 0;
157 
158     //method error
159     if (aynr_group_contex->group_CalibV2.groupMethod <= CalibDbV2_CAMGROUP_AYNRV2_METHOD_MIN
160             ||  aynr_group_contex->group_CalibV2.groupMethod >=  CalibDbV2_CAMGROUP_AYNRV2_METHOD_MAX) {
161         return (ret);
162     }
163 
164     //group empty
165     if(procParaGroup->camgroupParmasArray == nullptr) {
166         LOGE_ANR("camgroupParmasArray is null");
167         return(XCAM_RETURN_ERROR_FAILED);
168     }
169 
170     //get cur ae exposure
171     Aynr_ExpInfo_t stExpInfoV2;
172     memset(&stExpInfoV2, 0x00, sizeof(stExpInfoV2));
173     stExpInfoV2.hdr_mode = 0; //pAnrProcParams->hdr_mode;
174     stExpInfoV2.snr_mode = 0;
175     for(int i = 0; i < 3; i++) {
176         stExpInfoV2.arIso[i] = 50;
177         stExpInfoV2.arAGain[i] = 1.0;
178         stExpInfoV2.arDGain[i] = 1.0;
179         stExpInfoV2.arTime[i] = 0.01;
180     }
181 
182 
183     //merge ae result, iso mean value
184     rk_aiq_singlecam_3a_result_t* scam_3a_res = procParaGroup->camgroupParmasArray[0];
185     if(scam_3a_res->aec._bEffAecExpValid) {
186         RKAiqAecExpInfo_t* pCurExp = &scam_3a_res->aec._effAecExpInfo;
187         stExpInfoV2.snr_mode = pCurExp->CISFeature.SNR;
188         if((rk_aiq_working_mode_t)procParaGroup->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
189             stExpInfoV2.hdr_mode = 0;
190             stExpInfoV2.arAGain[0] = pCurExp->LinearExp.exp_real_params.analog_gain;
191             stExpInfoV2.arDGain[0] = pCurExp->LinearExp.exp_real_params.digital_gain;
192             stExpInfoV2.arTime[0] = pCurExp->LinearExp.exp_real_params.integration_time;
193             stExpInfoV2.arIso[0] = stExpInfoV2.arAGain[0] * stExpInfoV2.arDGain[0] * 50;
194 
195         } else {
196             if(procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
197                     || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
198                 stExpInfoV2.hdr_mode = 1;
199             else if (procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
200                      || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
201                 stExpInfoV2.hdr_mode = 2;
202             else {
203                 stExpInfoV2.hdr_mode = 0;
204                 LOGE_ANR("mode error\n");
205             }
206 
207             for(int i = 0; i < 3; i++) {
208                 stExpInfoV2.arAGain[i] = pCurExp->HdrExp[i].exp_real_params.analog_gain;
209                 stExpInfoV2.arDGain[i] = pCurExp->HdrExp[i].exp_real_params.digital_gain;
210                 stExpInfoV2.arTime[i] = pCurExp->HdrExp[i].exp_real_params.integration_time;
211                 stExpInfoV2.arIso[i] = stExpInfoV2.arAGain[i] * stExpInfoV2.arDGain[i] * 50;
212             }
213 
214         }
215     } else {
216         LOGW("fail to get sensor gain form AE module,use default value ");
217     }
218 
219 
220 
221     if(CHECK_ISP_HW_V21()) {
222         Aynr_Context_V2_t * aynr_contex_v2 = aynr_group_contex->aynr_contex_v2;
223         Aynr_ProcResult_V2_t stAynrResultV2;
224         RK_YNR_Fix_V2_t stFix;
225         stAynrResultV2.stFix = &stFix;
226 
227         deltaIso = abs(stExpInfoV2.arIso[stExpInfoV2.hdr_mode] - aynr_contex_v2->stExpInfo.arIso[stExpInfoV2.hdr_mode]);
228         if(deltaIso > AYNRV3_RECALCULATE_DELTA_ISO) {
229             aynr_contex_v2->isReCalculate |= 1;
230         }
231         if(aynr_contex_v2->isReCalculate) {
232             Aynr_result_t ret_v2 = AYNR_RET_SUCCESS;
233             ret_v2 = Aynr_Process_V2(aynr_contex_v2, &stExpInfoV2);
234             if(ret_v2 != AYNR_RET_SUCCESS) {
235                 ret = XCAM_RETURN_ERROR_FAILED;
236                 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
237             }
238             Aynr_GetProcResult_V2(aynr_contex_v2, &stAynrResultV2);
239             outparams->cfg_update = true;
240             LOGD_ANR("recalculate: %d delta_iso:%d \n ", aynr_contex_v2->isReCalculate, deltaIso);
241         } else {
242             outparams->cfg_update = false;
243         }
244 
245         for (int i = 0; i < procResParaGroup->arraySize; i++) {
246             *(procResParaGroup->camgroupParmasArray[i]->aynr._aynr_procRes_v2) = *stAynrResultV2.stFix;
247             IS_UPDATE_MEM((procResParaGroup->camgroupParmasArray[i]->aynr._aynr_procRes_v2), procParaGroup->_offset_is_update) =
248                 outparams->cfg_update;
249         }
250         aynr_contex_v2->isReCalculate = 0;
251 
252     }
253     else {
254         ret = XCAM_RETURN_ERROR_FAILED;
255         LOGE_ANR("module_hw_version of awnr is isvalid!!!!");
256     }
257 
258     LOGI_ANR("%s exit\n", __FUNCTION__);
259     return ret;
260 }
261 
262 RkAiqAlgoDescription g_RkIspAlgoDescCamgroupAynrV2 = {
263     .common = {
264         .version = RKISP_ALGO_CAMGROUP_AYNRV2_VERSION,
265         .vendor  = RKISP_ALGO_CAMGROUP_AYNRV2_VENDOR,
266         .description = RKISP_ALGO_CAMGROUP_AYNRV2_DESCRIPTION,
267         .type    = RK_AIQ_ALGO_TYPE_AYNR,
268         .id      = 0,
269         .create_context  = groupAynrV2CreateCtx,
270         .destroy_context = groupAynrV2DestroyCtx,
271     },
272     .prepare = groupAynrV2Prepare,
273     .pre_process = NULL,
274     .processing = groupAynrV2Processing,
275     .post_process = NULL,
276 };
277 
278 RKAIQ_END_DECLARE
279