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_v22.h"
21 #include "rk_aiq_algo_camgroup_types.h"
22 #include "rk_aiq_types_camgroup_aynr_prvt_v22.h"
23 #include "aynrV22/rk_aiq_aynr_algo_itf_v22.h"
24 #include "aynrV22/rk_aiq_aynr_algo_v22.h"
25
26
27
28 RKAIQ_BEGIN_DECLARE
29
30
groupAynrV22CreateCtx(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)31 static XCamReturn groupAynrV22CreateCtx(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
32 {
33 LOGI_ANR("%s enter \n", __FUNCTION__ );
34
35 XCamReturn ret = XCAM_RETURN_NO_ERROR;
36 CamGroup_AynrV22_Contex_t *aynr_group_contex = NULL;
37 AlgoCtxInstanceCfgCamGroup *cfgInt = (AlgoCtxInstanceCfgCamGroup*)cfg;
38
39 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
40 aynr_group_contex = (CamGroup_AynrV22_Contex_t*)malloc(sizeof(CamGroup_AynrV22_Contex_t));
41 #if AYNR_USE_JSON_FILE_V22
42 Aynr_result_V22_t ret_v22 = AYNRV22_RET_SUCCESS;
43 ret_v22 = Aynr_Init_V22(&(aynr_group_contex->aynr_contex_v22), (void *)cfgInt->s_calibv2);
44 if(ret_v22 != AYNRV22_RET_SUCCESS) {
45 ret = XCAM_RETURN_ERROR_FAILED;
46 LOGE_ANR("%s: Initializaion ynr group v22 failed (%d)\n", __FUNCTION__, ret);
47 }
48 #endif
49 }
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_AYNRV22_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
groupAynrV22DestroyCtx(RkAiqAlgoContext * context)75 static XCamReturn groupAynrV22DestroyCtx(RkAiqAlgoContext *context)
76 {
77 LOGI_ANR("%s enter \n", __FUNCTION__ );
78
79 XCamReturn ret = XCAM_RETURN_NO_ERROR;
80
81 CamGroup_AynrV22_Contex_t *aynr_group_contex = (CamGroup_AynrV22_Contex_t*)context;
82
83 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
84 Aynr_result_V22_t ret_v22 = AYNRV22_RET_SUCCESS;
85 ret_v22 = Aynr_Release_V22(aynr_group_contex->aynr_contex_v22);
86 if(ret_v22 != AYNRV22_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
groupAynrV22Prepare(RkAiqAlgoCom * params)107 static XCamReturn groupAynrV22Prepare(RkAiqAlgoCom* params)
108 {
109 LOGI_ANR("%s enter \n", __FUNCTION__ );
110
111 XCamReturn ret = XCAM_RETURN_NO_ERROR;
112
113 CamGroup_AynrV22_Contex_t * aynr_group_contex = (CamGroup_AynrV22_Contex_t *)params->ctx;
114 RkAiqAlgoCamGroupPrepare* para = (RkAiqAlgoCamGroupPrepare*)params;
115
116 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
117 Aynr_Context_V22_t * aynr_contex_v22 = aynr_group_contex->aynr_contex_v22;
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_V22
121 void *pCalibdbV2 = (void*)(para->s_calibv2);
122 CalibDbV2_YnrV22_t *ynr_v22 = (CalibDbV2_YnrV22_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, ynr_v22));
123 aynr_contex_v22->ynr_v22 = *ynr_v22;
124 aynr_contex_v22->isIQParaUpdate = true;
125 aynr_contex_v22->isReCalculate |= 1;
126 #endif
127 }
128 Aynr_Config_V22_t stAynrConfigV22;
129 stAynrConfigV22.rawHeight = params->u.prepare.sns_op_height;
130 stAynrConfigV22.rawWidth = params->u.prepare.sns_op_width;
131 Aynr_result_V22_t ret_v22 = AYNRV22_RET_SUCCESS;
132 ret_v22 = Aynr_Prepare_V22(aynr_contex_v22, &stAynrConfigV22);
133 if(ret_v22 != AYNRV22_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
groupAynrV22Processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)147 static XCamReturn groupAynrV22Processing(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_AynrV22_Contex_t * aynr_group_contex = (CamGroup_AynrV22_Contex_t *)inparams->ctx;
156 int deltaIso = 0;
157
158 //method error
159 if (aynr_group_contex->group_CalibV2.groupMethod <= CalibDbV2_CAMGROUP_AYNRV22_METHOD_MIN
160 || aynr_group_contex->group_CalibV2.groupMethod >= CalibDbV2_CAMGROUP_AYNRV22_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_V22_t stExpInfoV22;
172 memset(&stExpInfoV22, 0x00, sizeof(Aynr_ExpInfo_V22_t));
173 stExpInfoV22.hdr_mode = 0; //pAnrProcParams->hdr_mode;
174 stExpInfoV22.snr_mode = 0;
175 for(int i = 0; i < 3; i++) {
176 stExpInfoV22.arIso[i] = 50;
177 stExpInfoV22.arAGain[i] = 1.0;
178 stExpInfoV22.arDGain[i] = 1.0;
179 stExpInfoV22.arTime[i] = 0.01;
180 }
181
182 stExpInfoV22.blc_ob_predgain = 1.0f;
183 if(procParaGroup != NULL) {
184 LOGD_ANR(" predgain:%f\n",
185 procParaGroup->stAblcV32_proc_res.isp_ob_predgain);
186 stExpInfoV22.blc_ob_predgain = procParaGroup->stAblcV32_proc_res.isp_ob_predgain;
187
188 }
189 //merge ae result, iso mean value
190 rk_aiq_singlecam_3a_result_t* scam_3a_res = procParaGroup->camgroupParmasArray[0];
191 if(scam_3a_res->aec._bEffAecExpValid) {
192 RKAiqAecExpInfo_t* pCurExp = &scam_3a_res->aec._effAecExpInfo;
193 stExpInfoV22.snr_mode = pCurExp->CISFeature.SNR;
194 if((rk_aiq_working_mode_t)procParaGroup->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
195 stExpInfoV22.hdr_mode = 0;
196 stExpInfoV22.arAGain[0] = pCurExp->LinearExp.exp_real_params.analog_gain;
197 stExpInfoV22.arDGain[0] = pCurExp->LinearExp.exp_real_params.digital_gain;
198 stExpInfoV22.arTime[0] = pCurExp->LinearExp.exp_real_params.integration_time;
199 if(stExpInfoV22.arAGain[0] < 1.0) {
200 stExpInfoV22.arAGain[0] = 1.0;
201 }
202 if(stExpInfoV22.arDGain[0] < 1.0) {
203 stExpInfoV22.arDGain[0] = 1.0;
204 }
205 if(stExpInfoV22.blc_ob_predgain < 1.0) {
206 stExpInfoV22.blc_ob_predgain = 1.0;
207 }
208 stExpInfoV22.arIso[0] = stExpInfoV22.arAGain[0] * stExpInfoV22.arDGain[0] * stExpInfoV22.blc_ob_predgain * 50;
209
210 } else {
211 if(procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
212 || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
213 stExpInfoV22.hdr_mode = 1;
214 else if (procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
215 || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
216 stExpInfoV22.hdr_mode = 2;
217 else {
218 stExpInfoV22.hdr_mode = 0;
219 LOGE_ANR("mode error\n");
220 }
221
222 for(int i = 0; i < 3; i++) {
223 stExpInfoV22.arAGain[i] = pCurExp->HdrExp[i].exp_real_params.analog_gain;
224 stExpInfoV22.arDGain[i] = pCurExp->HdrExp[i].exp_real_params.digital_gain;
225 stExpInfoV22.arTime[i] = pCurExp->HdrExp[i].exp_real_params.integration_time;
226 if(stExpInfoV22.arAGain[i] < 1.0) {
227 stExpInfoV22.arAGain[i] = 1.0;
228 }
229 if(stExpInfoV22.arDGain[i] < 1.0) {
230 stExpInfoV22.arDGain[i] = 1.0;
231 }
232 stExpInfoV22.blc_ob_predgain = 1.0;
233 stExpInfoV22.arIso[i] = stExpInfoV22.arAGain[i] * stExpInfoV22.arDGain[i] * 50;
234 }
235
236 }
237 } else {
238 LOGW("fail to get sensor gain form AE module,use default value ");
239 }
240
241
242
243 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
244 Aynr_Context_V22_t * aynr_contex_v22 = aynr_group_contex->aynr_contex_v22;
245 Aynr_ProcResult_V22_t stAynrResultV22;
246 RK_YNR_Fix_V22_t stFix;
247 stAynrResultV22.stFix = &stFix;
248
249 deltaIso = abs(stExpInfoV22.arIso[stExpInfoV22.hdr_mode] - aynr_contex_v22->stExpInfo.arIso[stExpInfoV22.hdr_mode]);
250 if(deltaIso > AYNRV22_RECALCULATE_DELTA_ISO) {
251 aynr_contex_v22->isReCalculate |= 1;
252 }
253 if(stExpInfoV22.blc_ob_predgain != aynr_contex_v22->stExpInfo.blc_ob_predgain) {
254 aynr_contex_v22->isReCalculate |= 1;
255 }
256 if(aynr_contex_v22->isReCalculate) {
257 Aynr_result_V22_t ret_v22 = AYNRV22_RET_SUCCESS;
258 ret_v22 = Aynr_Process_V22(aynr_contex_v22, &stExpInfoV22);
259 if(ret_v22 != AYNRV22_RET_SUCCESS) {
260 ret = XCAM_RETURN_ERROR_FAILED;
261 LOGE_ANR("%s: processing ANR failed (%d)\n", __FUNCTION__, ret);
262 }
263 Aynr_GetProcResult_V22(aynr_contex_v22, &stAynrResultV22);
264 outparams->cfg_update = true;
265 LOGD_ANR("recalculate: %d delta_iso:%d \n ", aynr_contex_v22->isReCalculate, deltaIso);
266 } else {
267 outparams->cfg_update = false;
268 }
269
270 for (int i = 0; i < procResParaGroup->arraySize; i++) {
271 if (aynr_contex_v22->isReCalculate) {
272 *(procResParaGroup->camgroupParmasArray[i]->aynr._aynr_procRes_v22) = *stAynrResultV22.stFix;
273 memcpy(procResParaGroup->camgroupParmasArray[i]->aynr_sigma._aynr_sigma_v22,
274 stAynrResultV22.stSelect->sigma, sizeof(stAynrResultV22.stSelect->sigma));
275 }
276 IS_UPDATE_MEM((procResParaGroup->camgroupParmasArray[i]->aynr._aynr_procRes_v22), procParaGroup->_offset_is_update) =
277 outparams->cfg_update;
278 }
279 aynr_contex_v22->isReCalculate = 0;
280 }
281 else {
282 ret = XCAM_RETURN_ERROR_FAILED;
283 LOGE_ANR("module_hw_version of aynr is isvalid!!!!");
284 }
285
286 LOGI_ANR("%s exit\n", __FUNCTION__);
287 return ret;
288 }
289
290 RkAiqAlgoDescription g_RkIspAlgoDescCamgroupAynrV22 = {
291 .common = {
292 .version = RKISP_ALGO_CAMGROUP_AYNRV22_VERSION,
293 .vendor = RKISP_ALGO_CAMGROUP_AYNRV22_VENDOR,
294 .description = RKISP_ALGO_CAMGROUP_AYNRV22_DESCRIPTION,
295 .type = RK_AIQ_ALGO_TYPE_AYNR,
296 .id = 0,
297 .create_context = groupAynrV22CreateCtx,
298 .destroy_context = groupAynrV22DestroyCtx,
299 },
300 .prepare = groupAynrV22Prepare,
301 .pre_process = NULL,
302 .processing = groupAynrV22Processing,
303 .post_process = NULL,
304 };
305
306 RKAIQ_END_DECLARE
307