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