1 /*
2 * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "ablcV32/rk_aiq_ablc_algo_itf_v32.h"
17
18 #include "ablcV32/rk_aiq_ablc_algo_v32.h"
19 #include "rk_aiq_algo_types.h"
20
21 RKAIQ_BEGIN_DECLARE
22
23 typedef struct _RkAiqAlgoContext {
24 void* place_holder[0];
25 } RkAiqAlgoContext;
26
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)27 static XCamReturn create_context(RkAiqAlgoContext** context, const AlgoCtxInstanceCfg* cfg) {
28 XCamReturn result = XCAM_RETURN_NO_ERROR;
29
30 LOG1_ABLC("%s: (enter)\n", __FUNCTION__);
31
32 AblcContext_V32_t* pAblcCtx = NULL;
33 AblcResult_V32_t ret = AblcV32Init(&pAblcCtx, cfg->calibv2);
34 if (ret != ABLC_V32_RET_SUCCESS) {
35 result = XCAM_RETURN_ERROR_FAILED;
36 LOGE_ABLC("%s: Initializaion Ablc failed (%d)\n", __FUNCTION__, ret);
37 } else {
38 *context = (RkAiqAlgoContext*)(pAblcCtx);
39 }
40
41 LOG1_ABLC("%s: (exit)\n", __FUNCTION__);
42 return result;
43 }
44
destroy_context(RkAiqAlgoContext * context)45 static XCamReturn destroy_context(RkAiqAlgoContext* context) {
46 XCamReturn result = XCAM_RETURN_NO_ERROR;
47
48 LOG1_ABLC("%s: (enter)\n", __FUNCTION__);
49
50 #if 1
51 AblcContext_V32_t* pAblcCtx = (AblcContext_V32_t*)context;
52 AblcResult_V32_t ret = AblcV32Release(pAblcCtx);
53 if (ret != ABLC_V32_RET_SUCCESS) {
54 result = XCAM_RETURN_ERROR_FAILED;
55 LOGE_ABLC("%s: release Ablc failed (%d)\n", __FUNCTION__, ret);
56 }
57 #endif
58
59 LOG1_ABLC("%s: (exit)\n", __FUNCTION__);
60 return result;
61 }
62
prepare(RkAiqAlgoCom * params)63 static XCamReturn prepare(RkAiqAlgoCom* params) {
64 LOG1_ABLC("%s: (enter)\n", __FUNCTION__);
65 XCamReturn result = XCAM_RETURN_NO_ERROR;
66
67 AblcContext_V32_t* pAblcCtx = (AblcContext_V32_t*)params->ctx;
68 RkAiqAlgoConfigAblcV32* pCfgParam = (RkAiqAlgoConfigAblcV32*)params;
69 pAblcCtx->prepare_type = params->u.prepare.conf_type;
70
71 if (!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB)) {
72 CalibDbV2_Blc_V32_t* calibv2_ablc_calib = (CalibDbV2_Blc_V32_t*)(CALIBDBV2_GET_MODULE_PTR(
73 (void*)(pCfgParam->com.u.prepare.calibv2), ablcV32_calib));
74
75 void *pCalibDbV2 = (void*)(pCfgParam->com.u.prepare.calibv2);
76 #if (RKAIQ_HAVE_BAYER2DNR_V23)
77 CalibDbV2_Bayer2dnrV23_t *bayernr_v23 = (CalibDbV2_Bayer2dnrV23_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDbV2, bayer2dnr_v23));
78 pAblcCtx->stBayer2dnrCalib = bayernr_v23->CalibPara;
79 #endif
80 LOGE_ABLC("%s: Ablc Reload Para!\n", __FUNCTION__);
81 pAblcCtx->stBlcCalib = *calibv2_ablc_calib;
82 pAblcCtx->isUpdateParam = true;
83 pAblcCtx->isReCalculate |= 1;
84 }
85
86 LOG1_ABLC("%s: (exit)\n", __FUNCTION__);
87 return result;
88 }
89
90
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)91 static XCamReturn processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams) {
92 XCamReturn result = XCAM_RETURN_NO_ERROR;
93 int iso;
94 int delta_iso = 0;
95 LOG1_ABLC("%s: (enter)\n", __FUNCTION__);
96
97 RkAiqAlgoProcAblcV32* pAblcProcParams = (RkAiqAlgoProcAblcV32*)inparams;
98 RkAiqAlgoProcResAblcV32* pAblcProcResParams = (RkAiqAlgoProcResAblcV32*)outparams;
99 AblcContext_V32_t* pAblcCtx = (AblcContext_V32_t*)inparams->ctx;
100 AblcExpInfo_V32_t stExpInfo;
101 memset(&stExpInfo, 0x00, sizeof(AblcExpInfo_V32_t));
102
103
104 stExpInfo.hdr_mode = 0;
105 for (int i = 0; i < 3; i++) {
106 stExpInfo.arIso[i] = 50;
107 stExpInfo.arAGain[i] = 1.0;
108 stExpInfo.arDGain[i] = 1.0;
109 stExpInfo.arTime[i] = 0.01;
110 }
111
112 if (pAblcProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
113 stExpInfo.hdr_mode = 0;
114 } else if (pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR ||
115 pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR) {
116 stExpInfo.hdr_mode = 1;
117 } else if (pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR ||
118 pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR) {
119 stExpInfo.hdr_mode = 2;
120 }
121
122 if (pAblcCtx->isUpdateParam) {
123 AblcV32ParamsUpdate(pAblcCtx, &pAblcCtx->stBlcCalib);
124 // blc0 check
125 if ( stExpInfo.hdr_mode == 0)
126 AblcV32_IQParams_Check(&pAblcCtx->stBlc0Params, &pAblcCtx->stBlcOBParams, &pAblcCtx->stBlcRefParams);
127 pAblcCtx->isReCalculate |= 1;
128 pAblcCtx->isUpdateParam = false;
129 }
130
131 RKAiqAecExpInfo_t* curExp = pAblcProcParams->com.u.proc.curExp;
132 if (curExp != NULL) {
133 if (pAblcProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
134 if (curExp->LinearExp.exp_real_params.analog_gain < 1.0) {
135 stExpInfo.arAGain[0] = 1.0;
136 LOGW_ANR("leanr mode again is wrong, use 1.0 instead\n");
137 } else {
138 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
139 }
140 if (curExp->LinearExp.exp_real_params.digital_gain < 1.0) {
141 stExpInfo.arDGain[0] = 1.0;
142 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
143 } else {
144 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
145 }
146 if (curExp->LinearExp.exp_real_params.isp_dgain < 1.0) {
147 stExpInfo.isp_dgain[0] = 1.0;
148 LOGW_ANR("leanr mode isp_dgain is wrong, use 1.0 instead\n");
149 } else {
150 stExpInfo.isp_dgain[0] = curExp->LinearExp.exp_real_params.isp_dgain;
151 }
152 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
153 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * 50 * stExpInfo.isp_dgain[0];
154 } else {
155 for (int i = 0; i < 3; i++) {
156 if (curExp->HdrExp[i].exp_real_params.analog_gain < 1.0) {
157 stExpInfo.arAGain[i] = 1.0;
158 LOGW_ANR("hdr mode again is wrong, use 1.0 instead\n");
159 } else {
160 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
161 }
162 if (curExp->HdrExp[i].exp_real_params.digital_gain < 1.0) {
163 stExpInfo.arDGain[i] = 1.0;
164 LOGW_ANR("hdr mode dgain is wrong, use 1.0 instead\n");
165 } else {
166 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
167 }
168 if (curExp->HdrExp[i].exp_real_params.isp_dgain < 1.0) {
169 stExpInfo.isp_dgain[i] = 1.0;
170 LOGW_ANR("hdr mode isp_dgain is wrong, use 1.0 instead\n");
171 } else {
172 stExpInfo.isp_dgain[i] = curExp->HdrExp[i].exp_real_params.isp_dgain;
173 }
174 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
175 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * 50 * stExpInfo.isp_dgain[i];
176
177 LOGD_ABLC("%s:%d index:%d again:%f dgain:%f isp_dgain:%f time:%f iso:%d hdr_mode:%d\n",
178 __FUNCTION__, __LINE__, i, stExpInfo.arAGain[i], stExpInfo.arDGain[i], stExpInfo.isp_dgain[i],
179 stExpInfo.arTime[i], stExpInfo.arIso[i], stExpInfo.hdr_mode);
180 }
181 }
182 } else {
183 LOGE_ABLC("%s:%d curExp is NULL, so use default instead \n", __FUNCTION__, __LINE__);
184 }
185
186 delta_iso = abs(stExpInfo.arIso[stExpInfo.hdr_mode] -
187 pAblcCtx->stExpInfo.arIso[pAblcCtx->stExpInfo.hdr_mode]);
188 if (delta_iso > ABLC_V32_RECALCULATE_DELTE_ISO) {
189 pAblcCtx->isReCalculate |= 1;
190 }
191
192 if (pAblcCtx->isReCalculate) {
193 AblcResult_V32_t ret = AblcV32Process(pAblcCtx, &stExpInfo);
194 if (ret != ABLC_V32_RET_SUCCESS) {
195 result = XCAM_RETURN_ERROR_FAILED;
196 LOGE_ABLC("%s: processing ABLC failed (%d)\n", __FUNCTION__, ret);
197 }
198 pAblcProcResParams->res_com.cfg_update = true;
199 Ablc_GetProcResult_V32(pAblcCtx, pAblcProcResParams->ablcV32_proc_res);
200 LOGD_ABLC("%s:%d processing ABLC recalculate delta_iso:%d \n", __FUNCTION__, __LINE__,
201 delta_iso);
202 } else {
203 pAblcProcResParams->res_com.cfg_update = false;
204 }
205
206 pAblcCtx->isReCalculate = 0;
207
208 LOG1_ABLC("%s: (exit)\n", __FUNCTION__);
209 return XCAM_RETURN_NO_ERROR;
210 }
211
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)212 static XCamReturn post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams) {
213 return XCAM_RETURN_NO_ERROR;
214 }
215
216 RkAiqAlgoDescription g_RkIspAlgoDescAblcV32 = {
217 .common =
218 {
219 .version = RKISP_ALGO_ABLC_V32_VERSION,
220 .vendor = RKISP_ALGO_ABLC_V32_VENDOR,
221 .description = RKISP_ALGO_ABLC_V32_DESCRIPTION,
222 .type = RK_AIQ_ALGO_TYPE_ABLC,
223 .id = 0,
224 .create_context = create_context,
225 .destroy_context = destroy_context,
226 },
227 .prepare = prepare,
228 .pre_process = NULL,
229 .processing = processing,
230 .post_process = NULL,
231 };
232
233 RKAIQ_END_DECLARE
234