1 /*
2 * rk_aiq_algo_ablc_itf.c
3 *
4 * Copyright (c) 2019 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 "ablc/rk_aiq_algo_ablc_itf.h"
21 #include "ablc/rk_aiq_ablc_algo.h"
22 #include "rk_aiq_algo_types.h"
23
24 RKAIQ_BEGIN_DECLARE
25
26 typedef struct _RkAiqAlgoContext {
27 AblcContext_t AblcCtx;
28 } RkAiqAlgoContext;
29
30
31 static XCamReturn
create_context(RkAiqAlgoContext ** context,const AlgoCtxInstanceCfg * cfg)32 create_context(RkAiqAlgoContext **context, const AlgoCtxInstanceCfg* cfg)
33 { XCamReturn result = XCAM_RETURN_NO_ERROR;
34
35 LOG1_ABLC("%s: (enter)\n", __FUNCTION__ );
36
37 AblcContext_t* pAblcCtx = NULL;
38 AblcResult_t ret = AblcInit(&pAblcCtx, cfg->calibv2);
39 if(ret != ABLC_RET_SUCCESS) {
40 result = XCAM_RETURN_ERROR_FAILED;
41 LOGE_ABLC("%s: Initializaion Ablc failed (%d)\n", __FUNCTION__, ret);
42 } else {
43 *context = (RkAiqAlgoContext *)(pAblcCtx);
44 }
45
46
47 LOG1_ABLC("%s: (exit)\n", __FUNCTION__ );
48 return result;
49
50 }
51
52 static XCamReturn
destroy_context(RkAiqAlgoContext * context)53 destroy_context(RkAiqAlgoContext *context)
54 {
55 XCamReturn result = XCAM_RETURN_NO_ERROR;
56
57 LOG1_ABLC("%s: (enter)\n", __FUNCTION__ );
58
59 #if 1
60 AblcContext_t* pAblcCtx = (AblcContext_t*)context;
61 AblcResult_t ret = AblcRelease(pAblcCtx);
62 if(ret != ABLC_RET_SUCCESS) {
63 result = XCAM_RETURN_ERROR_FAILED;
64 LOGE_ABLC("%s: release Ablc failed (%d)\n", __FUNCTION__, ret);
65 }
66 #endif
67
68 LOG1_ABLC("%s: (exit)\n", __FUNCTION__ );
69 return result;
70
71 }
72
73 static XCamReturn
prepare(RkAiqAlgoCom * params)74 prepare(RkAiqAlgoCom* params)
75 {
76 LOG1_ABLC("%s: (enter)\n", __FUNCTION__ );
77 XCamReturn result = XCAM_RETURN_NO_ERROR;
78
79 AblcContext_t* pAblcCtx = (AblcContext_t *)params->ctx;
80 RkAiqAlgoConfigAblc* pCfgParam = (RkAiqAlgoConfigAblc*)params;
81 pAblcCtx->prepare_type = params->u.prepare.conf_type;
82
83 if(!!(params->u.prepare.conf_type & RK_AIQ_ALGO_CONFTYPE_UPDATECALIB )) {
84 CalibDbV2_Ablc_t* calibv2_ablc_calib =
85 (CalibDbV2_Ablc_t*)(CALIBDBV2_GET_MODULE_PTR((void*)(pCfgParam->com.u.prepare.calibv2), ablc_calib));
86
87 LOGD_ABLC("%s: Ablc Reload Para!\n", __FUNCTION__);
88 memcpy(&pAblcCtx->stBlcCalib, calibv2_ablc_calib, sizeof(pAblcCtx->stBlcCalib));
89 pAblcCtx->isUpdateParam = true;
90 pAblcCtx->isReCalculate |= 1;
91 }
92
93 if(pAblcCtx->isUpdateParam) {
94 AblcParamsUpdate(pAblcCtx, &pAblcCtx->stBlcCalib);
95 pAblcCtx->isReCalculate |= 1;
96 pAblcCtx->isUpdateParam = false;
97 }
98
99 LOG1_ABLC("%s: (exit)\n", __FUNCTION__ );
100 return result;
101 }
102
103 static XCamReturn
pre_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)104 pre_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
105 {
106 LOG1_ABLC("%s: (enter)\n", __FUNCTION__ );
107 XCamReturn result = XCAM_RETURN_NO_ERROR;
108 AblcContext_t* pAblcCtx = (AblcContext_t *)inparams->ctx;
109
110 LOG1_ABLC("%s: (exit)\n", __FUNCTION__ );
111 return result;
112 }
113
114 static XCamReturn
processing(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)115 processing(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
116 {
117 XCamReturn result = XCAM_RETURN_NO_ERROR;
118 int iso;
119 int delta_iso = 0;
120 LOG1_ABLC("%s: (enter)\n", __FUNCTION__ );
121
122
123 RkAiqAlgoProcAblc* pAblcProcParams = (RkAiqAlgoProcAblc*)inparams;
124 RkAiqAlgoProcResAblc* pAblcProcResParams = (RkAiqAlgoProcResAblc*)outparams;
125 AblcContext_t* pAblcCtx = (AblcContext_t *)inparams->ctx;
126 AblcExpInfo_t stExpInfo;
127 memset(&stExpInfo, 0x00, sizeof(AblcExpInfo_t));
128
129 stExpInfo.hdr_mode = 0; //pAnrProcParams->hdr_mode;
130 for(int i = 0; i < 3; i++) {
131 stExpInfo.arIso[i] = 50;
132 stExpInfo.arAGain[i] = 1.0;
133 stExpInfo.arDGain[i] = 1.0;
134 stExpInfo.arTime[i] = 0.01;
135 }
136
137 if(pAblcProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
138 stExpInfo.hdr_mode = 0;
139 } else if(pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_FRAME_HDR
140 || pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_2_LINE_HDR ) {
141 stExpInfo.hdr_mode = 1;
142 } else if(pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_FRAME_HDR
143 || pAblcProcParams->hdr_mode == RK_AIQ_ISP_HDR_MODE_3_LINE_HDR ) {
144 stExpInfo.hdr_mode = 2;
145 }
146
147 RKAiqAecExpInfo_t *curExp = pAblcProcParams->com.u.proc.curExp;
148 if(curExp != NULL) {
149 if(pAblcProcParams->hdr_mode == RK_AIQ_WORKING_MODE_NORMAL) {
150 if(curExp->LinearExp.exp_real_params.analog_gain < 1.0) {
151 stExpInfo.arAGain[0] = 1.0;
152 LOGW_ANR("leanr mode again is wrong, use 1.0 instead\n");
153 } else {
154 stExpInfo.arAGain[0] = curExp->LinearExp.exp_real_params.analog_gain;
155 }
156 if(curExp->LinearExp.exp_real_params.digital_gain < 1.0) {
157 stExpInfo.arDGain[0] = 1.0;
158 LOGW_ANR("leanr mode dgain is wrong, use 1.0 instead\n");
159 } else {
160 stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
161 }
162 if (curExp->LinearExp.exp_real_params.isp_dgain < 1.0) {
163 stExpInfo.isp_dgain[0] = 1.0;
164 LOGW_ANR("leanr mode isp_dgain is wrong, use 1.0 instead\n");
165 } else {
166 stExpInfo.isp_dgain[0] = curExp->LinearExp.exp_real_params.isp_dgain;
167 }
168 // stExpInfo.arDGain[0] = curExp->LinearExp.exp_real_params.digital_gain;
169 stExpInfo.arTime[0] = curExp->LinearExp.exp_real_params.integration_time;
170 stExpInfo.arIso[0] = stExpInfo.arAGain[0] * stExpInfo.arDGain[0] * stExpInfo.isp_dgain[0] * 50;
171 } else {
172 for(int i = 0; i < 3; i++) {
173 if(curExp->HdrExp[i].exp_real_params.analog_gain < 1.0) {
174 stExpInfo.arAGain[i] = 1.0;
175 LOGW_ANR("hdr mode again is wrong, use 1.0 instead\n");
176 } else {
177 stExpInfo.arAGain[i] = curExp->HdrExp[i].exp_real_params.analog_gain;
178 }
179 if(curExp->HdrExp[i].exp_real_params.digital_gain < 1.0) {
180 stExpInfo.arDGain[i] = 1.0;
181 LOGW_ANR("hdr mode dgain is wrong, use 1.0 instead\n");
182 } else {
183 stExpInfo.arDGain[i] = curExp->HdrExp[i].exp_real_params.digital_gain;
184 }
185 if (curExp->HdrExp[i].exp_real_params.isp_dgain < 1.0) {
186 stExpInfo.isp_dgain[i] = 1.0;
187 LOGW_ANR("hdr mode isp_dgain is wrong, use 1.0 instead\n");
188 } else {
189 stExpInfo.isp_dgain[i] = curExp->HdrExp[i].exp_real_params.isp_dgain;
190 }
191 stExpInfo.arTime[i] = curExp->HdrExp[i].exp_real_params.integration_time;
192 stExpInfo.arIso[i] = stExpInfo.arAGain[i] * stExpInfo.arDGain[i] * stExpInfo.isp_dgain[i] * 50;
193
194 LOGD_ABLC("%s:%d index:%d again:%f dgain:%f time:%f iso:%d hdr_mode:%d\n",
195 __FUNCTION__, __LINE__,
196 i,
197 stExpInfo.arAGain[i],
198 stExpInfo.arDGain[i],
199 stExpInfo.arTime[i],
200 stExpInfo.arIso[i],
201 stExpInfo.hdr_mode);
202 }
203 }
204 } else {
205 LOGE_ABLC("%s:%d curExp is NULL, so use default instead \n", __FUNCTION__, __LINE__);
206 }
207
208 delta_iso = abs(stExpInfo.arIso[stExpInfo.hdr_mode] - pAblcCtx->stExpInfo.arIso[pAblcCtx->stExpInfo.hdr_mode]);
209 if(delta_iso > ABLC_RECALCULATE_DELTE_ISO) {
210 pAblcCtx->isReCalculate |= 1;
211 }
212
213 if(pAblcCtx->isReCalculate ) {
214 AblcResult_t ret = AblcProcess(pAblcCtx, &stExpInfo);
215 if(ret != ABLC_RET_SUCCESS) {
216 result = XCAM_RETURN_ERROR_FAILED;
217 LOGE_ABLC("%s: processing ABLC failed (%d)\n", __FUNCTION__, ret);
218 }
219 pAblcProcResParams->res_com.cfg_update = true;
220 memcpy(pAblcProcResParams->ablc_proc_res, &pAblcCtx->ProcRes, sizeof(AblcProc_t));
221 LOGD_ABLC("%s:%d processing ABLC recalculate delta_iso:%d \n", __FUNCTION__, __LINE__, delta_iso);
222 } else {
223 pAblcProcResParams->res_com.cfg_update = false;
224 }
225
226 pAblcCtx->isReCalculate = 0;
227
228 LOG1_ABLC("%s: (exit)\n", __FUNCTION__ );
229 return XCAM_RETURN_NO_ERROR;
230 }
231
232 static XCamReturn
post_process(const RkAiqAlgoCom * inparams,RkAiqAlgoResCom * outparams)233 post_process(const RkAiqAlgoCom* inparams, RkAiqAlgoResCom* outparams)
234 {
235 return XCAM_RETURN_NO_ERROR;
236 }
237
238 RkAiqAlgoDescription g_RkIspAlgoDescAblc = {
239 .common = {
240 .version = RKISP_ALGO_ABLC_VERSION,
241 .vendor = RKISP_ALGO_ABLC_VENDOR,
242 .description = RKISP_ALGO_ABLC_DESCRIPTION,
243 .type = RK_AIQ_ALGO_TYPE_ABLC,
244 .id = 0,
245 .create_context = create_context,
246 .destroy_context = destroy_context,
247 },
248 .prepare = prepare,
249 .pre_process = pre_process,
250 .processing = processing,
251 .post_process = post_process,
252 };
253
254 RKAIQ_END_DECLARE
255