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_asharp_itf_v33.h"
21 #include "rk_aiq_algo_camgroup_types.h"
22 #include "rk_aiq_types_camgroup_asharp_prvt_v33.h"
23 #include "asharpV33/rk_aiq_asharp_algo_itf_v33.h"
24 #include "asharpV33/rk_aiq_asharp_algo_v33.h"
25
26
27
28 RKAIQ_BEGIN_DECLARE
29
30
groupAsharpV33CreateCtx(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)31 static XCamReturn groupAsharpV33CreateCtx(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
32 {
33 LOGI_ASHARP("%s enter \n", __FUNCTION__ );
34
35 XCamReturn ret = XCAM_RETURN_NO_ERROR;
36 CamGroup_AsharpV33_Contex_t *asharp_group_contex = NULL;
37 AlgoCtxInstanceCfgCamGroup *cfgInt = (AlgoCtxInstanceCfgCamGroup*)cfg;
38
39 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
40 asharp_group_contex = (CamGroup_AsharpV33_Contex_t*)malloc(sizeof(CamGroup_AsharpV33_Contex_t));
41 #if (ASHARP_USE_JSON_FILE_V33)
42 Asharp_result_V33_t ret_v33 = ASHARP_V33_RET_SUCCESS;
43 ret_v33 = Asharp_Init_V33(&(asharp_group_contex->asharp_contex_v33), (void *)cfgInt->s_calibv2);
44 if(ret_v33 != ASHARP_V33_RET_SUCCESS) {
45 ret = XCAM_RETURN_ERROR_FAILED;
46 LOGE_ASHARP("%s: Initializaion ASHARP failed (%d)\n", __FUNCTION__, ret);
47 }
48 #endif
49 } else {
50 ret = XCAM_RETURN_ERROR_FAILED;
51 LOGE_ASHARP("module_hw_version of asharp is invalid!!!!");
52 }
53
54 if(ret != XCAM_RETURN_NO_ERROR) {
55 LOGE_ASHARP("%s: Initializaion group sharp failed (%d)\n", __FUNCTION__, ret);
56 } else {
57 // to do got asharpSurrViewClib and initinal paras for for surround view
58 asharp_group_contex->group_CalibV2.groupMethod = CalibDbV2_CAMGROUP_ASHARPV33_METHOD_MEAN;// to do from json
59 asharp_group_contex->camera_Num = cfgInt->camIdArrayLen;
60
61 *context = (RkAiqAlgoContext *)(asharp_group_contex);
62
63 LOGI_ASHARP("%s:%d surrViewMethod(1-mean):%d, cameraNum %d \n",
64 __FUNCTION__, __LINE__,
65 asharp_group_contex->group_CalibV2.groupMethod,
66 asharp_group_contex->camera_Num);
67 }
68
69 LOGI_ASHARP("%s exit ret:%d\n", __FUNCTION__, ret);
70 return ret;
71
72 }
73
groupAsharpV33DestroyCtx(RkAiqAlgoContext * context)74 static XCamReturn groupAsharpV33DestroyCtx(RkAiqAlgoContext *context)
75 {
76 LOGI_ASHARP("%s enter \n", __FUNCTION__ );
77
78 XCamReturn ret = XCAM_RETURN_NO_ERROR;
79
80 CamGroup_AsharpV33_Contex_t *asharp_group_contex = (CamGroup_AsharpV33_Contex_t*)context;
81
82 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
83 Asharp_result_V33_t ret_v33 = ASHARP_V33_RET_SUCCESS;
84 ret_v33 = Asharp_Release_V33(asharp_group_contex->asharp_contex_v33);
85 if(ret_v33 != ASHARP_V33_RET_SUCCESS) {
86 ret = XCAM_RETURN_ERROR_FAILED;
87 LOGE_ASHARP("%s: Initializaion ASHARP failed (%d)\n", __FUNCTION__, ret);
88 }
89 }
90 else {
91 ret = XCAM_RETURN_ERROR_FAILED;
92 LOGE_ASHARP("module_hw_version of asharp is isvalid!!!!");
93 }
94
95 if(ret != XCAM_RETURN_NO_ERROR) {
96 LOGE_ASHARP("%s: release asharp group failed (%d)\n", __FUNCTION__, ret);
97 } else {
98 free(asharp_group_contex);
99 }
100
101
102 LOGI_ASHARP("%s exit ret:%d\n", __FUNCTION__, ret);
103 return ret;
104 }
105
groupAsharpV33Prepare(RkAiqAlgoCom * params)106 static XCamReturn groupAsharpV33Prepare(RkAiqAlgoCom* params)
107 {
108 LOGI_ASHARP("%s enter \n", __FUNCTION__ );
109
110 XCamReturn ret = XCAM_RETURN_NO_ERROR;
111
112 CamGroup_AsharpV33_Contex_t * asharp_group_contex = (CamGroup_AsharpV33_Contex_t *)params->ctx;
113 RkAiqAlgoCamGroupPrepare* para = (RkAiqAlgoCamGroupPrepare*)params;
114
115 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
116 Asharp_Context_V33_t * asharp_contex_v33 = asharp_group_contex->asharp_contex_v33;
117 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
118 // todo update calib pars for surround view
119 #if ASHARP_USE_JSON_FILE_V33
120 void *pCalibdbV2 = (void*)(para->s_calibv2);
121 #if RKAIQ_HAVE_SHARP_V33
122 CalibDbV2_SharpV33_t *sharp_v33 = (CalibDbV2_SharpV33_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, sharp_v33));
123 #else
124 CalibDbV2_SharpV33Lite_t* sharp_v33 =
125 (CalibDbV2_SharpV33Lite_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibdbV2, sharp_v33));
126 #endif
127 asharp_contex_v33->sharp_v33 = *sharp_v33;
128 asharp_contex_v33->isIQParaUpdate = true;
129 asharp_contex_v33->isReCalculate |= 1;
130 #endif
131 }
132 Asharp_Config_V33_t stAsharpConfigV33;
133 stAsharpConfigV33.rawHeight = params->u.prepare.sns_op_height;
134 stAsharpConfigV33.rawWidth = params->u.prepare.sns_op_width;
135 Asharp_result_V33_t ret_v33 = ASHARP_V33_RET_SUCCESS;
136 ret_v33 = Asharp_Prepare_V33(asharp_contex_v33, &stAsharpConfigV33);
137 if(ret_v33 != ASHARP_V33_RET_SUCCESS) {
138 ret = XCAM_RETURN_ERROR_FAILED;
139 LOGE_ASHARP("%s: config ASHARP failed (%d)\n", __FUNCTION__, ret);
140 }
141 }
142 else {
143 ret = XCAM_RETURN_ERROR_FAILED;
144 LOGE_ASHARP("module_hw_version of asharp is isvalid!!!!");
145 }
146
147 LOGI_ASHARP("%s exit ret:%d\n", __FUNCTION__, ret);
148 return ret;
149 }
150
groupAsharpV33Processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)151 static XCamReturn groupAsharpV33Processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
152 {
153 LOGI_ASHARP("%s enter \n", __FUNCTION__ );
154 LOGI_ASHARP("----------------------------------------------frame_id (%d)----------------------------------------------\n", inparams->frame_id);
155
156 XCamReturn ret = XCAM_RETURN_NO_ERROR;
157 RkAiqAlgoCamGroupProcIn* procParaGroup = (RkAiqAlgoCamGroupProcIn*)inparams;
158 RkAiqAlgoCamGroupProcOut* procResParaGroup = (RkAiqAlgoCamGroupProcOut*)outparams;
159 CamGroup_AsharpV33_Contex_t * asharp_group_contex = (CamGroup_AsharpV33_Contex_t *)inparams->ctx;
160 int deltaIso = 0;
161
162 //method error
163 if (asharp_group_contex->group_CalibV2.groupMethod <= CalibDbV2_CAMGROUP_ASHARPV33_METHOD_MIN
164 || asharp_group_contex->group_CalibV2.groupMethod >= CalibDbV2_CAMGROUP_ASHARPV33_METHOD_MAX) {
165 return (ret);
166 }
167
168 //group empty
169 if(procParaGroup->camgroupParmasArray == nullptr) {
170 LOGE_ASHARP("camgroupParmasArray is null");
171 return(XCAM_RETURN_ERROR_FAILED);
172 }
173
174 //get cur ae exposure
175 Asharp_ExpInfo_V33_t stExpInfoV33;
176 memset(&stExpInfoV33, 0x00, sizeof(Asharp3_ExpInfo_t));
177 stExpInfoV33.hdr_mode = 0; //pAnrProcParams->hdr_mode;
178 stExpInfoV33.snr_mode = 0;
179 for(int i = 0; i < 3; i++) {
180 stExpInfoV33.arIso[i] = 50;
181 stExpInfoV33.arAGain[i] = 1.0;
182 stExpInfoV33.arDGain[i] = 1.0;
183 stExpInfoV33.arTime[i] = 0.01;
184 }
185
186 stExpInfoV33.blc_ob_predgain = 1.0f;
187 if(procParaGroup != NULL) {
188 LOGD_ANR(" predgain:%f\n",
189 procParaGroup->stAblcV32_proc_res.isp_ob_predgain);
190 stExpInfoV33.blc_ob_predgain = procParaGroup->stAblcV32_proc_res.isp_ob_predgain;
191
192 }
193 //merge ae result, iso mean value
194 rk_aiq_singlecam_3a_result_t* scam_3a_res = procParaGroup->camgroupParmasArray[0];
195 if(scam_3a_res->aec._bEffAecExpValid) {
196 RKAiqAecExpInfo_t* pCurExp = &scam_3a_res->aec._effAecExpInfo;
197 stExpInfoV33.snr_mode = pCurExp->CISFeature.SNR;
198 if((rk_aiq_working_mode_t)procParaGroup->working_mode == RK_AIQ_WORKING_MODE_NORMAL) {
199 stExpInfoV33.hdr_mode = 0;
200 stExpInfoV33.arAGain[0] = pCurExp->LinearExp.exp_real_params.analog_gain;
201 stExpInfoV33.arDGain[0] = pCurExp->LinearExp.exp_real_params.digital_gain;
202 stExpInfoV33.arTime[0] = pCurExp->LinearExp.exp_real_params.integration_time;
203 if(stExpInfoV33.arAGain[0] < 1.0) {
204 stExpInfoV33.arAGain[0] = 1.0;
205 }
206 if(stExpInfoV33.arDGain[0] < 1.0) {
207 stExpInfoV33.arDGain[0] = 1.0;
208 }
209 if(stExpInfoV33.blc_ob_predgain < 1.0) {
210 stExpInfoV33.blc_ob_predgain = 1.0;
211 }
212 stExpInfoV33.arIso[0] = stExpInfoV33.arAGain[0] * stExpInfoV33.arDGain[0] * stExpInfoV33.blc_ob_predgain * 50;
213
214 } else {
215 if(procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
216 || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR)
217 stExpInfoV33.hdr_mode = 1;
218 else if (procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
219 || procParaGroup->working_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR)
220 stExpInfoV33.hdr_mode = 2;
221 else {
222 stExpInfoV33.hdr_mode = 0;
223 LOGE_ANR("mode error\n");
224 }
225
226 for(int i = 0; i < 3; i++) {
227 stExpInfoV33.arAGain[i] = pCurExp->HdrExp[i].exp_real_params.analog_gain;
228 stExpInfoV33.arDGain[i] = pCurExp->HdrExp[i].exp_real_params.digital_gain;
229 stExpInfoV33.arTime[i] = pCurExp->HdrExp[i].exp_real_params.integration_time;
230 if(stExpInfoV33.arAGain[i] < 1.0) {
231 stExpInfoV33.arAGain[i] = 1.0;
232 }
233 if(stExpInfoV33.arDGain[i] < 1.0) {
234 stExpInfoV33.arDGain[i] = 1.0;
235 }
236 stExpInfoV33.blc_ob_predgain = 1.0;
237 stExpInfoV33.arIso[i] = stExpInfoV33.arAGain[i] * stExpInfoV33.arDGain[i] * 50;
238 }
239
240 }
241 } else {
242 LOGW("fail to get sensor gain form AE module,use default value ");
243 }
244
245
246
247 if(CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
248 Asharp_Context_V33_t * asharp_contex_v33 = asharp_group_contex->asharp_contex_v33;
249 Asharp_ProcResult_V33_t stAsharpResultV33;
250 RK_SHARP_Fix_V33_t stFix;
251 stAsharpResultV33.stFix = &stFix;
252
253 deltaIso = abs(stExpInfoV33.arIso[stExpInfoV33.hdr_mode] - asharp_contex_v33->stExpInfo.arIso[stExpInfoV33.hdr_mode]);
254 if(deltaIso > ASHARPV33_RECALCULATE_DELTA_ISO) {
255 asharp_contex_v33->isReCalculate |= 1;
256 }
257 if(stExpInfoV33.blc_ob_predgain != asharp_contex_v33->stExpInfo.blc_ob_predgain) {
258 asharp_contex_v33->isReCalculate |= 1;
259 }
260 if(asharp_contex_v33->isReCalculate) {
261 Asharp_result_V33_t ret_v33 = ASHARP_V33_RET_SUCCESS;
262 ret_v33 = Asharp_Process_V33(asharp_contex_v33, &stExpInfoV33);
263 if(ret_v33 != ASHARP_V33_RET_SUCCESS) {
264 ret = XCAM_RETURN_ERROR_FAILED;
265 LOGE_ASHARP("%s: processing ASHARP failed (%d)\n", __FUNCTION__, ret);
266 }
267 outparams->cfg_update = true;
268 LOGD_ASHARP("recalculate: %d delta_iso:%d \n ", asharp_contex_v33->isReCalculate, deltaIso);
269 } else {
270 outparams->cfg_update = false;
271 }
272 Asharp_GetProcResult_V33(asharp_contex_v33, &stAsharpResultV33);
273 for (int i = 0; i < procResParaGroup->arraySize; i++) {
274 *(procResParaGroup->camgroupParmasArray[i]->asharp._asharp_procRes_v33) = *stAsharpResultV33.stFix;
275 IS_UPDATE_MEM((procResParaGroup->camgroupParmasArray[i]->asharp._asharp_procRes_v33), procParaGroup->_offset_is_update) =
276 outparams->cfg_update;
277 }
278 asharp_contex_v33->isReCalculate = 0;
279
280 }
281 else {
282 ret = XCAM_RETURN_ERROR_FAILED;
283 LOGE_ASHARP("module_hw_version of asharp is isvalid!!!!");
284 }
285
286 LOGI_ASHARP("%s exit\n", __FUNCTION__);
287 return ret;
288 }
289
290 RkAiqAlgoDescription g_RkIspAlgoDescCamgroupAsharpV33 = {
291 .common = {
292 .version = RKISP_ALGO_CAMGROUP_ASHARPV33_VERSION,
293 .vendor = RKISP_ALGO_CAMGROUP_ASHARPV33_VENDOR,
294 .description = RKISP_ALGO_CAMGROUP_ASHARPV33_DESCRIPTION,
295 .type = RK_AIQ_ALGO_TYPE_ASHARP,
296 .id = 0,
297 .create_context = groupAsharpV33CreateCtx,
298 .destroy_context = groupAsharpV33DestroyCtx,
299 },
300 .prepare = groupAsharpV33Prepare,
301 .pre_process = NULL,
302 .processing = groupAsharpV33Processing,
303 .post_process = NULL,
304 };
305
306 RKAIQ_END_DECLARE
307