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_acnr_itf_v2.h"
21 #include "rk_aiq_algo_camgroup_types.h"
22 #include "rk_aiq_types_camgroup_acnr_prvt_v2.h"
23 #include "acnr2/rk_aiq_acnr_algo_itf_v2.h"
24 #include "acnr2/rk_aiq_acnr_algo_v2.h"
25 
26 
27 RKAIQ_BEGIN_DECLARE
28 
29 
groupAcnrV2CreateCtx(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)30 static XCamReturn groupAcnrV2CreateCtx(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
31 {
32     LOGI_ANR("%s enter \n", __FUNCTION__ );
33 
34     XCamReturn ret = XCAM_RETURN_NO_ERROR;
35     CamGroup_AcnrV2_Contex_t *acnr_group_contex = NULL;
36     AlgoCtxInstanceCfgCamGroup *cfgInt = (AlgoCtxInstanceCfgCamGroup*)cfg;
37 
38 
39     if(CHECK_ISP_HW_V30()) {
40         acnr_group_contex = (CamGroup_AcnrV2_Contex_t*)malloc(sizeof(CamGroup_AcnrV2_Contex_t));
41 #if ACNR_USE_JSON_FILE_V2
42         AcnrV2_result_t ret_v2 = ACNRV2_RET_SUCCESS;
43         ret_v2 = Acnr_Init_V2(&(acnr_group_contex->acnr_contex_v2), (void *)cfgInt->s_calibv2);
44         if(ret_v2 != ACNRV2_RET_SUCCESS) {
45             ret = XCAM_RETURN_ERROR_FAILED;
46             LOGE_ANR("%s: Initializaion ANR failed (%d)\n", __FUNCTION__, ret);
47         }
48 #endif
49     }
50     else {
51         ret = XCAM_RETURN_ERROR_FAILED;
52         LOGE_ANR("module_hw_version of acnr  is invalid!!!!");
53     }
54 
55     if(ret != XCAM_RETURN_NO_ERROR) {
56         LOGE_ANR("%s: Initializaion group cnr failed (%d)\n", __FUNCTION__, ret);
57     } else {
58         // to do got acnrSurrViewClib and initinal paras for for surround view
59         acnr_group_contex->group_CalibV2.groupMethod = CalibDbV2_CAMGROUP_ACNRV2_METHOD_MEAN;// to do from json
60         acnr_group_contex->camera_Num = cfgInt->camIdArrayLen;
61 
62         *context = (RkAiqAlgoContext *)(acnr_group_contex);
63 
64         LOGI_ANR("%s:%d surrViewMethod(1-mean):%d, cameraNum %d \n",
65                  __FUNCTION__, __LINE__,
66                  acnr_group_contex->group_CalibV2.groupMethod,
67                  acnr_group_contex->camera_Num);
68     }
69 
70     LOGI_ANR("%s exit ret:%d\n", __FUNCTION__, ret);
71     return ret;
72 
73 }
74 
groupAcnrV2DestroyCtx(RkAiqAlgoContext * context)75 static XCamReturn groupAcnrV2DestroyCtx(RkAiqAlgoContext *context)
76 {
77     LOGI_ANR("%s enter \n", __FUNCTION__ );
78 
79     XCamReturn ret = XCAM_RETURN_NO_ERROR;
80 
81     CamGroup_AcnrV2_Contex_t *acnr_group_contex = (CamGroup_AcnrV2_Contex_t*)context;
82 
83     if(CHECK_ISP_HW_V30()) {
84         AcnrV2_result_t ret_v2 = ACNRV2_RET_SUCCESS;
85         ret_v2 = Acnr_Release_V2(acnr_group_contex->acnr_contex_v2);
86         if(ret_v2 != ACNRV2_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 acr 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(acnr_group_contex);
100     }
101 
102 
103     LOGI_ANR("%s exit ret:%d\n", __FUNCTION__, ret);
104     return ret;
105 }
106 
groupAcnrV2Prepare(RkAiqAlgoCom * params)107 static XCamReturn groupAcnrV2Prepare(RkAiqAlgoCom* params)
108 {
109     LOGI_ANR("%s enter \n", __FUNCTION__ );
110 
111     XCamReturn ret = XCAM_RETURN_NO_ERROR;
112 
113     CamGroup_AcnrV2_Contex_t * acnr_group_contex = (CamGroup_AcnrV2_Contex_t *)params->ctx;
114     RkAiqAlgoCamGroupPrepare* para = (RkAiqAlgoCamGroupPrepare*)params;
115 
116     if(CHECK_ISP_HW_V30()) {
117         Acnr_Context_V2_t * acnr_contex_v2 = acnr_group_contex->acnr_contex_v2;
118         if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
119             // todo  update calib pars for surround view
120 #if ACNR_USE_JSON_FILE_V2
121             void *pCalibdbV2 = (void*)(para->s_calibv2);
122             CalibDbV2_CNRV2_t *cnr_v2 = (CalibDbV2_CNRV2_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, cnr_v2));
123             acnr_contex_v2->cnr_v2 = *cnr_v2;
124             acnr_contex_v2->isIQParaUpdate = true;
125             acnr_contex_v2->isReCalculate |= 1;
126 #endif
127         }
128         Acnr_Config_V2_t stAcnrV2ConfigV2;
129         stAcnrV2ConfigV2.rawHeight =  params->u.prepare.sns_op_height;
130         stAcnrV2ConfigV2.rawWidth = params->u.prepare.sns_op_width;
131         AcnrV2_result_t ret_v2 = ACNRV2_RET_SUCCESS;
132         ret_v2 = Acnr_Prepare_V2(acnr_contex_v2, &stAcnrV2ConfigV2);
133         if(ret_v2 != ACNRV2_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 acnr (%d) is isvalid!!!!");
141     }
142 
143     LOGI_ANR("%s exit ret:%d\n", __FUNCTION__, ret);
144     return ret;
145 }
146 
groupAcnrV2Processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)147 static XCamReturn groupAcnrV2Processing(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_AcnrV2_Contex_t * acnr_group_contex = (CamGroup_AcnrV2_Contex_t *)inparams->ctx;
156     int deltaIso = 0;
157 
158     //method error
159     if (acnr_group_contex->group_CalibV2.groupMethod <= CalibDbV2_CAMGROUP_ACNRV2_METHOD_MIN
160             ||  acnr_group_contex->group_CalibV2.groupMethod >=  CalibDbV2_CAMGROUP_ACNRV2_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     AcnrV2_ExpInfo_t stExpInfoV2;
172     memset(&stExpInfoV2, 0x00, sizeof(AcnrV2_ExpInfo_t));
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             for(int i = 0; i < 3; i++) {
207                 stExpInfoV2.arAGain[i] = pCurExp->HdrExp[i].exp_real_params.analog_gain;
208                 stExpInfoV2.arDGain[i] = pCurExp->HdrExp[i].exp_real_params.digital_gain;
209                 stExpInfoV2.arTime[i] = pCurExp->HdrExp[i].exp_real_params.integration_time;
210                 stExpInfoV2.arIso[i] = stExpInfoV2.arAGain[i] * stExpInfoV2.arDGain[i] * 50;
211             }
212 
213         }
214     } else {
215         LOGW("fail to get sensor gain form AE module,use default value ");
216     }
217 
218 
219 
220     if(CHECK_ISP_HW_V30()) {
221         Acnr_Context_V2_t * acnr_contex_v2 = acnr_group_contex->acnr_contex_v2;
222         Acnr_ProcResult_V2_t stAcnrResultV2;
223         RK_CNR_Fix_V2_t stFix;
224         stAcnrResultV2.stFix = &stFix;
225 
226         deltaIso = abs(stExpInfoV2.arIso[stExpInfoV2.hdr_mode] - acnr_contex_v2->stExpInfo.arIso[stExpInfoV2.hdr_mode]);
227         if(deltaIso > ACNRV2_RECALCULATE_DELTA_ISO) {
228             acnr_contex_v2->isReCalculate |= 1;
229         }
230         if(acnr_contex_v2->isReCalculate) {
231             AcnrV2_result_t ret_v2 = ACNRV2_RET_SUCCESS;
232             ret_v2 = Acnr_Process_V2(acnr_contex_v2, &stExpInfoV2);
233             if(ret_v2 != ACNRV2_RET_SUCCESS) {
234                 ret = XCAM_RETURN_ERROR_FAILED;
235                 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
236             }
237             outparams->cfg_update = true;
238             LOGD_ANR("recalculate: %d delta_iso:%d \n ", acnr_contex_v2->isReCalculate, deltaIso);
239         } else {
240             outparams->cfg_update = false;
241         }
242         Acnr_GetProcResult_V2(acnr_contex_v2, &stAcnrResultV2);
243         for (int i = 0; i < procResParaGroup->arraySize; i++) {
244             *(procResParaGroup->camgroupParmasArray[i]->acnr._acnr_procRes_v2) = *stAcnrResultV2.stFix;
245             IS_UPDATE_MEM((procResParaGroup->camgroupParmasArray[i]->acnr._acnr_procRes_v2), procParaGroup->_offset_is_update) =
246                 outparams->cfg_update;
247         }
248         acnr_contex_v2->isReCalculate = 0;
249     }
250     else {
251         ret = XCAM_RETURN_ERROR_FAILED;
252         LOGE_ANR("module_hw_version of acnr is isvalid!!!!");
253     }
254 
255     LOGI_ANR("%s exit\n", __FUNCTION__);
256     return ret;
257 }
258 
259 RkAiqAlgoDescription g_RkIspAlgoDescCamgroupAcnrV2 = {
260     .common = {
261         .version = RKISP_ALGO_CAMGROUP_ACNRV2_VERSION,
262         .vendor  = RKISP_ALGO_CAMGROUP_ACNRV2_VENDOR,
263         .description = RKISP_ALGO_CAMGROUP_ACNRV2_DESCRIPTION,
264         .type    = RK_AIQ_ALGO_TYPE_ACNR,
265         .id      = 0,
266         .create_context  = groupAcnrV2CreateCtx,
267         .destroy_context = groupAcnrV2DestroyCtx,
268     },
269     .prepare = groupAcnrV2Prepare,
270     .pre_process = NULL,
271     .processing = groupAcnrV2Processing,
272     .post_process = NULL,
273 };
274 
275 RKAIQ_END_DECLARE
276