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 "rk_aiq_ablc_algo_v32.h"
17
18 #include "rk_aiq_ablc_algo_itf_v32.h"
19
AblcJsonParamInit_V32(AblcParams_V32_t * pParams,AblcV32ParaV2_t * pBlcCalibParams)20 AblcResult_V32_t AblcJsonParamInit_V32(AblcParams_V32_t* pParams,
21 AblcV32ParaV2_t* pBlcCalibParams) {
22 AblcResult_V32_t res = ABLC_V32_RET_SUCCESS;
23
24 if (pParams == NULL || pBlcCalibParams == NULL) {
25 LOGE_ABLC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
26 return ABLC_V32_RET_NULL_POINTER;
27 }
28
29 pParams->enable = pBlcCalibParams->enable;
30 for (int i = 0; i < ABLCV32_MAX_ISO_LEVEL; i++) {
31 pParams->iso[i] = pBlcCalibParams->BLC_Data.ISO[i];
32 pParams->blc_r[i] = pBlcCalibParams->BLC_Data.R_Channel[i];
33 pParams->blc_gr[i] = pBlcCalibParams->BLC_Data.Gr_Channel[i];
34 pParams->blc_gb[i] = pBlcCalibParams->BLC_Data.Gb_Channel[i];
35 pParams->blc_b[i] = pBlcCalibParams->BLC_Data.B_Channel[i];
36
37 LOGD_ABLC("%s(%d): Ablc en:%d iso:%f blc:%f %f %f %f \n", __FUNCTION__, __LINE__,
38 pParams->enable, pParams->iso[i], pParams->blc_r[i], pParams->blc_gr[i],
39 pParams->blc_gb[i], pParams->blc_b[i]);
40 }
41
42 LOG1_ABLC("%s(%d)\n", __FUNCTION__, __LINE__);
43 return res;
44 }
45
AblcOBJsonParamInit_V32(AblcOBParams_V32_t * pParams,AblcV32OBPara_t * pBlcOBCalibParams)46 AblcResult_V32_t AblcOBJsonParamInit_V32(AblcOBParams_V32_t* pParams,
47 AblcV32OBPara_t* pBlcOBCalibParams) {
48 AblcResult_V32_t res = ABLC_V32_RET_SUCCESS;
49
50 if (pParams == NULL || pBlcOBCalibParams == NULL) {
51 LOGE_ABLC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
52 return ABLC_V32_RET_NULL_POINTER;
53 }
54
55 pParams->enable = pBlcOBCalibParams->enable;
56 for (int i = 0; i < ABLCV32_MAX_ISO_LEVEL; i++) {
57 pParams->iso[i] = pBlcOBCalibParams->BLC_OB_Data.ISO[i];
58 pParams->ob_offset[i] = pBlcOBCalibParams->BLC_OB_Data.isp_ob_Offset[i];
59 pParams->ob_predgain[i] = pBlcOBCalibParams->BLC_OB_Data.isp_ob_preDgain[i];
60
61 LOGD_ABLC("%s(%d): blc_OB en:%d iso:%f ob_offset:%f ,ob_predgain: %f \n", __FUNCTION__,
62 __LINE__, pParams->enable, pParams->iso[i], pParams->ob_offset[i],
63 pParams->ob_predgain[i]);
64 }
65
66 LOGD_ABLC("%s(%d)\n", __FUNCTION__, __LINE__);
67 return res;
68 }
69
AblcRefJsonParamInit_V32(AblcRefParams_V32_t * pBlcRefPara,CalibDbV2_Bayer2dnrV23_Calib_t * stBayer2dnrCalib)70 AblcResult_V32_t AblcRefJsonParamInit_V32(AblcRefParams_V32_t* pBlcRefPara, CalibDbV2_Bayer2dnrV23_Calib_t* stBayer2dnrCalib) {
71 LOG1_ABLC("%s:enter!\n", __FUNCTION__);
72
73 AblcResult_V32_t ret = ABLC_V32_RET_SUCCESS;
74 #if (RKAIQ_HAVE_BAYER2DNR_V23)
75 // initial checks
76 DCT_ASSERT(pBlcRefPara != NULL);
77 DCT_ASSERT(stBayer2dnrCalib != NULL);
78
79 for (int j = 0; j < ABLCV32_MAX_ISO_LEVEL; j++) {
80 pBlcRefPara->iso[j] = stBayer2dnrCalib->Blc_Ref[j].iso;
81 pBlcRefPara->Reference_r[j] = stBayer2dnrCalib->Blc_Ref[j].Reference_r;
82 pBlcRefPara->Reference_gr[j] = stBayer2dnrCalib->Blc_Ref[j].Reference_gr;
83 pBlcRefPara->Reference_gb[j] = stBayer2dnrCalib->Blc_Ref[j].Reference_gb;
84 pBlcRefPara->Reference_b[j] = stBayer2dnrCalib->Blc_Ref[j].Reference_b;
85 }
86 LOGD_ABLC("%s(%d): blc ref init done \n", __FUNCTION__, __LINE__);
87 #endif
88 LOG1_ABLC("%s:exit!\n", __FUNCTION__);
89 return ret;
90 }
91
AblcV32_IQParams_Check(AblcParams_V32_t * pBLC0Params,AblcOBParams_V32_t * pBLCOBParams,AblcRefParams_V32_t * pBlcRef)92 AblcResult_V32_t AblcV32_IQParams_Check(AblcParams_V32_t* pBLC0Params, AblcOBParams_V32_t* pBLCOBParams, AblcRefParams_V32_t* pBlcRef) {
93 AblcResult_V32_t ret = ABLC_V32_RET_SUCCESS;
94
95 if (pBLC0Params == NULL) {
96 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
97 return ABLC_V32_RET_NULL_POINTER;
98 }
99
100 if (pBLCOBParams == NULL) {
101 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
102 return ABLC_V32_RET_NULL_POINTER;
103 }
104
105 if (pBlcRef == NULL) {
106 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
107 return ABLC_V32_RET_NULL_POINTER;
108 }
109
110 float blc_r_caculate;
111 float blc_gr_caculate;
112 float blc_gb_caculate;
113 float blc_b_caculate;
114 float diff;
115
116
117 for (int i = 0; i < ABLCV32_MAX_ISO_LEVEL; i++) {
118 blc_r_caculate = pBLC0Params->blc_r[i] - pBLCOBParams->ob_offset[i];
119 blc_gr_caculate = pBLC0Params->blc_gr[i] - pBLCOBParams->ob_offset[i];
120 blc_gb_caculate = pBLC0Params->blc_gb[i] - pBLCOBParams->ob_offset[i];
121 blc_b_caculate = pBLC0Params->blc_b[i] - pBLCOBParams->ob_offset[i];
122
123 diff = ((pBlcRef->Reference_r[i] - blc_r_caculate) > 0 ) ? (pBlcRef->Reference_r[i] - blc_r_caculate) : ( blc_r_caculate - pBlcRef->Reference_r[i]);
124 if (diff > 0.01) {
125 LOGE_ABLC("BLC0_r-ob_offset not equal to the blc Reference_r in iso(%d) Reference_r=%.4f, blc_r_caculate=%.4f\n",
126 int(pBlcRef->iso[i]), pBlcRef->Reference_r[i], blc_r_caculate);
127 }
128
129 diff = ((pBlcRef->Reference_gr[i] - blc_gr_caculate) > 0 ) ? (pBlcRef->Reference_gr[i] - blc_gr_caculate) : ( blc_gr_caculate - pBlcRef->Reference_gr[i]);
130 if (diff > 0.01) {
131 LOGE_ABLC("BLC0_gr-ob_offset not equal to the blc Reference_gr in iso(%d) Reference_gr=%.4f, blc_gr_caculate=%.4f\n, cur-blc-gr=%.4f",
132 int(pBlcRef->iso[i]), pBlcRef->Reference_gr[i], blc_gr_caculate, pBLC0Params->blc_gr[i]);
133 }
134
135 diff = ((pBlcRef->Reference_gb[i] - blc_gb_caculate) > 0 ) ? (pBlcRef->Reference_gb[i] - blc_gb_caculate) : ( blc_gb_caculate - pBlcRef->Reference_gb[i]);
136 if (diff > 0.01) {
137 LOGE_ABLC("BLC0_gb-ob_offset not equal to the blc Reference_gb in iso(%d) Reference_gb=%.4f, blc_gb_caculate=%.4f\n",
138 int(pBlcRef->iso[i]), pBlcRef->Reference_gb[i], blc_gb_caculate);
139 }
140
141 diff = ((pBlcRef->Reference_b[i] - blc_b_caculate) > 0 ) ? (pBlcRef->Reference_b[i] - blc_b_caculate) : ( blc_b_caculate - pBlcRef->Reference_b[i]);
142 if (diff > 0.01) {
143 LOGE_ABLC("BLC0_b-ob_offset not equal to the blc Reference_b in iso(%d) Reference_b=%.4f, blc_b_caculate=%.4f\n",
144 int(pBlcRef->iso[i]), pBlcRef->Reference_b[i], blc_b_caculate);
145 }
146 }
147
148 return ret;
149 }
Ablc_Select_Params_By_ISO_V32(AblcParams_V32_t * pParams,AblcSelect_V32_t * pSelect,AblcExpInfo_V32_t * pExpInfo)150 AblcResult_V32_t Ablc_Select_Params_By_ISO_V32(AblcParams_V32_t* pParams, AblcSelect_V32_t* pSelect,
151 AblcExpInfo_V32_t* pExpInfo) {
152 LOG1_ABLC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
153
154 int isoLowlevel = 0;
155 int isoHighlevel = 0;
156 int lowIso = 0;
157 int highIso = 0;
158 float ratio = 0.0f;
159 int isoValue = 50;
160 int i = 0;
161
162 if (pParams == NULL) {
163 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
164 return ABLC_V32_RET_NULL_POINTER;
165 }
166
167 if (pSelect == NULL) {
168 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
169 return ABLC_V32_RET_NULL_POINTER;
170 }
171
172 if (pExpInfo == NULL) {
173 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
174 return ABLC_V32_RET_NULL_POINTER;
175 }
176
177 isoValue = pExpInfo->arIso[pExpInfo->hdr_mode];
178 for (i = 0; i < ABLCV32_MAX_ISO_LEVEL - 1; i++) {
179 if (isoValue >= pParams->iso[i] && isoValue <= pParams->iso[i + 1]) {
180 isoLowlevel = i;
181 isoHighlevel = i + 1;
182 lowIso = pParams->iso[i];
183 highIso = pParams->iso[i + 1];
184 ratio = (isoValue - lowIso) / (float)(highIso - lowIso);
185
186 LOG1_ABLC("%s:%d iso: %d %d isovalue:%d ratio:%f \n", __FUNCTION__, __LINE__, lowIso,
187 highIso, isoValue, ratio);
188 break;
189 }
190 }
191
192 if (i == ABLCV32_MAX_ISO_LEVEL - 1) {
193 if (isoValue < pParams->iso[0]) {
194 isoLowlevel = 0;
195 isoHighlevel = 1;
196 ratio = 0;
197 }
198
199 if (isoValue > pParams->iso[ABLCV32_MAX_ISO_LEVEL - 1]) {
200 isoLowlevel = ABLCV32_MAX_ISO_LEVEL - 1;
201 isoHighlevel = ABLCV32_MAX_ISO_LEVEL - 1;
202 ratio = 0;
203 }
204 }
205
206 pExpInfo->isoLevelHig = isoHighlevel;
207 pExpInfo->isoLevelLow = isoLowlevel;
208
209 pSelect->enable = pParams->enable;
210
211 pSelect->blc_r =
212 (short int)(ratio * (pParams->blc_r[isoHighlevel] - pParams->blc_r[isoLowlevel]) +
213 pParams->blc_r[isoLowlevel]);
214 pSelect->blc_gr =
215 (short int)(ratio * (pParams->blc_gr[isoHighlevel] - pParams->blc_gr[isoLowlevel]) +
216 pParams->blc_gr[isoLowlevel]);
217 pSelect->blc_gb =
218 (short int)(ratio * (pParams->blc_gb[isoHighlevel] - pParams->blc_gb[isoLowlevel]) +
219 pParams->blc_gb[isoLowlevel]);
220 pSelect->blc_b =
221 (short int)(ratio * (pParams->blc_b[isoHighlevel] - pParams->blc_b[isoLowlevel]) +
222 pParams->blc_b[isoLowlevel]);
223
224 LOGD_ABLC("%s:(%d) Ablc En:%d ISO:%d isoLowlevel:%d isoHighlevel:%d rggb: %d %d %d %d \n",
225 __FUNCTION__, __LINE__, pSelect->enable, isoValue, isoLowlevel, isoHighlevel,
226 pSelect->blc_r, pSelect->blc_gr, pSelect->blc_gb, pSelect->blc_b);
227
228 LOG1_ABLC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
229 return ABLC_V32_RET_SUCCESS;
230 }
231
Ablc_Select_OBParams_By_ISO_V32(AblcOBParams_V32_t * pParams,AblcOBSelect_V32_t * pSelect,AblcExpInfo_V32_t * pExpInfo)232 AblcResult_V32_t Ablc_Select_OBParams_By_ISO_V32(AblcOBParams_V32_t* pParams,
233 AblcOBSelect_V32_t* pSelect,
234 AblcExpInfo_V32_t* pExpInfo) {
235 LOG1_ABLC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
236
237 int isoLowlevel = 0;
238 int isoHighlevel = 0;
239 int lowIso = 0;
240 int highIso = 0;
241 float ratio = 0.0f;
242 int isoValue = 50;
243 int i = 0;
244
245 if (pParams == NULL) {
246 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
247 return ABLC_V32_RET_NULL_POINTER;
248 }
249
250 if (pSelect == NULL) {
251 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
252 return ABLC_V32_RET_NULL_POINTER;
253 }
254
255 if (pExpInfo == NULL) {
256 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
257 return ABLC_V32_RET_NULL_POINTER;
258 }
259
260
261 isoValue = pExpInfo->arIso[pExpInfo->hdr_mode];
262 for (i = 0; i < ABLCV32_MAX_ISO_LEVEL - 1; i++) {
263 if (isoValue >= pParams->iso[i] && isoValue <= pParams->iso[i + 1]) {
264 isoLowlevel = i;
265 isoHighlevel = i + 1;
266 lowIso = pParams->iso[i];
267 highIso = pParams->iso[i + 1];
268 ratio = (isoValue - lowIso) / (float)(highIso - lowIso);
269
270 LOG1_ABLC("%s:%d iso: %d %d isovalue:%d ratio:%f \n", __FUNCTION__, __LINE__, lowIso,
271 highIso, isoValue, ratio);
272 break;
273 }
274 }
275
276 if (i == ABLCV32_MAX_ISO_LEVEL - 1) {
277 if (isoValue < pParams->iso[0]) {
278 isoLowlevel = 0;
279 isoHighlevel = 1;
280 ratio = 0;
281 }
282
283 if (isoValue > pParams->iso[ABLCV32_MAX_ISO_LEVEL - 1]) {
284 isoLowlevel = ABLCV32_MAX_ISO_LEVEL - 1;
285 isoHighlevel = ABLCV32_MAX_ISO_LEVEL - 1;
286 ratio = 0;
287 }
288 }
289
290 if (pExpInfo->hdr_mode == 0) {
291 LOGD_ABLC("%s:(%d) LINE MODE blc_ob enable: hdr_mode = %", __FUNCTION__, __LINE__,
292 pExpInfo->hdr_mode);
293 pSelect->enable = pParams->enable;
294 pSelect->ob_offset = (short int)(ratio * (pParams->ob_offset[isoHighlevel] -
295 pParams->ob_offset[isoLowlevel]) +
296 pParams->ob_offset[isoLowlevel]);
297 pSelect->ob_predgain = (float)(ratio * (pParams->ob_predgain[isoHighlevel] -
298 pParams->ob_predgain[isoLowlevel]) +
299 pParams->ob_predgain[isoLowlevel]);
300 } else {
301 LOGD_ABLC("%s:(%d) HDR MODE blc_ob disable: hdr_mode = %d", __FUNCTION__, __LINE__,
302 pExpInfo->hdr_mode);
303 pSelect->enable = false;
304 pSelect->ob_offset = 0;
305 pSelect->ob_predgain = 0;
306 }
307
308 LOGD_ABLC(
309 "%s:(%d) ISO:%d isoLowlevel:%d isoHighlevel:%d isp_ob_offset: %f isp_ob_predgian %f \n",
310 __FUNCTION__, __LINE__, isoValue, isoLowlevel, isoHighlevel, pSelect->ob_offset,
311 pSelect->ob_predgain);
312
313 LOG1_ABLC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
314 return ABLC_V32_RET_SUCCESS;
315 }
316
AblcV32ParamsUpdate(AblcContext_V32_t * pAblcCtx,CalibDbV2_Blc_V32_t * pCalibDb)317 AblcResult_V32_t AblcV32ParamsUpdate(AblcContext_V32_t* pAblcCtx, CalibDbV2_Blc_V32_t* pCalibDb) {
318 LOGD_ABLC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
319 AblcResult_V32_t ret = ABLC_V32_RET_SUCCESS;
320
321 if (pAblcCtx == NULL || pCalibDb == NULL) {
322 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
323 return ABLC_V32_RET_NULL_POINTER;
324 }
325
326 // blc0
327 AblcJsonParamInit_V32(&pAblcCtx->stBlc0Params, &pCalibDb->Blc0TuningPara);
328
329 // bls1
330 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
331 AblcJsonParamInit_V32(&pAblcCtx->stBlc1Params, &pCalibDb->Blc1TuningPara);
332 }
333
334 // blc_ob
335 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
336 AblcOBJsonParamInit_V32(&pAblcCtx->stBlcOBParams, &pCalibDb->BlcObPara);
337 }
338 // blc_ref
339 if (CHECK_ISP_HW_V32() || CHECK_ISP_HW_V32_LITE()) {
340 #if (RKAIQ_HAVE_BAYER2DNR_V23)
341 AblcRefJsonParamInit_V32(&pAblcCtx->stBlcRefParams, &pAblcCtx->stBayer2dnrCalib);
342 #endif
343 }
344
345 return ret;
346 LOGD_ABLC("%s:exit!\n", __FUNCTION__);
347 }
348
AblcV32Init(AblcContext_V32_t ** ppAblcCtx,CamCalibDbV2Context_t * pCalibDb)349 AblcResult_V32_t AblcV32Init(AblcContext_V32_t** ppAblcCtx, CamCalibDbV2Context_t* pCalibDb) {
350 AblcContext_V32_t* pAblcCtx;
351
352 LOG1_ABLC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
353
354 pAblcCtx = (AblcContext_V32_t*)malloc(sizeof(AblcContext_V32_t));
355 if (pAblcCtx == NULL) {
356 LOGE_ABLC("%s(%d): NULL pointer\n", __FUNCTION__, __LINE__);
357 return ABLC_V32_RET_NULL_POINTER;
358 }
359
360 memset(pAblcCtx, 0x00, sizeof(AblcContext_V32_t));
361 pAblcCtx->eState = ABLC_V32_STATE_INITIALIZED;
362
363 *ppAblcCtx = pAblcCtx;
364
365 // init params for algo work
366 pAblcCtx->eMode = ABLC_V32_OP_MODE_AUTO;
367 pAblcCtx->isReCalculate |= 1;
368 pAblcCtx->isUpdateParam = false;
369
370 CalibDbV2_Blc_V32_t* ablc_calib =
371 (CalibDbV2_Blc_V32_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, ablcV32_calib));
372 #if (RKAIQ_HAVE_BAYER2DNR_V23)
373 CalibDbV2_Bayer2dnrV23_t *bayernr_v23 = (CalibDbV2_Bayer2dnrV23_t*)(CALIBDBV2_GET_MODULE_PTR((void*)pCalibDb, bayer2dnr_v23));
374 pAblcCtx->stBayer2dnrCalib = bayernr_v23->CalibPara;
375 #endif
376 pAblcCtx->stBlcCalib = *ablc_calib;
377 AblcV32ParamsUpdate(pAblcCtx, ablc_calib);
378
379 LOG1_ABLC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
380 return ABLC_V32_RET_SUCCESS;
381 }
382
AblcV32Release(AblcContext_V32_t * pAblcCtx)383 AblcResult_V32_t AblcV32Release(AblcContext_V32_t* pAblcCtx) {
384 LOG1_ABLC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
385 if (pAblcCtx == NULL) {
386 LOGE_ABLC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
387 return ABLC_V32_RET_NULL_POINTER;
388 }
389
390 memset(pAblcCtx, 0x00, sizeof(AblcContext_V32_t));
391 free(pAblcCtx);
392
393 LOG1_ABLC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
394 return ABLC_V32_RET_SUCCESS;
395 }
396
AblcV32Process(AblcContext_V32_t * pAblcCtx,AblcExpInfo_V32_t * pExpInfo)397 AblcResult_V32_t AblcV32Process(AblcContext_V32_t* pAblcCtx, AblcExpInfo_V32_t* pExpInfo) {
398 LOGD_ABLC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
399 AblcResult_V32_t ret = ABLC_V32_RET_SUCCESS;
400 float tmp;
401
402 if (pAblcCtx == NULL) {
403 LOGE_ABLC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
404 return ABLC_V32_RET_NULL_POINTER;
405 }
406
407 if (pExpInfo == NULL) {
408 LOGE_ABLC("%s(%d): null pointer \n", __FUNCTION__, __LINE__);
409 return ABLC_V32_RET_NULL_POINTER;
410 }
411
412 memcpy(&pAblcCtx->stExpInfo, pExpInfo, sizeof(AblcExpInfo_V32_t));
413
414 if (pAblcCtx->eMode == ABLC_V32_OP_MODE_AUTO) {
415 LOGD_ABLC("%s:(%d) Ablc auto !!! \n", __FUNCTION__, __LINE__);
416 ret = Ablc_Select_Params_By_ISO_V32(&pAblcCtx->stBlc0Params, &pAblcCtx->stBlc0Select, pExpInfo);
417 ret = Ablc_Select_Params_By_ISO_V32(&pAblcCtx->stBlc1Params, &pAblcCtx->stBlc1Select, pExpInfo);
418 ret = Ablc_Select_OBParams_By_ISO_V32(&pAblcCtx->stBlcOBParams, &pAblcCtx->stBlcOBSelect, pExpInfo);
419 pAblcCtx->stBlc1Select.blc_r *= pExpInfo->isp_dgain[0];
420 pAblcCtx->stBlc1Select.blc_gr *= pExpInfo->isp_dgain[0];
421 pAblcCtx->stBlc1Select.blc_gb *= pExpInfo->isp_dgain[0];
422 pAblcCtx->stBlc1Select.blc_b *= pExpInfo->isp_dgain[0];
423 } else if (pAblcCtx->eMode == ABLC_V32_OP_MODE_MANUAL) {
424 LOGE_ABLC("%s:(%d) Ablc manual !!! \n", __FUNCTION__, __LINE__);
425
426 pAblcCtx->stBlc1Manual.blc_r *= pExpInfo->isp_dgain[0];
427 pAblcCtx->stBlc1Manual.blc_gr *= pExpInfo->isp_dgain[0];
428 pAblcCtx->stBlc1Manual.blc_gb *= pExpInfo->isp_dgain[0];
429 pAblcCtx->stBlc1Manual.blc_b *= pExpInfo->isp_dgain[0];
430 } else {
431 LOGE_ABLC("%s(%d): not support mode:%d!\n", __FUNCTION__, __LINE__, pAblcCtx->eMode);
432 }
433
434 LOG1_ABLC("%s(%d): exit!\n", __FUNCTION__, __LINE__);
435
436 return ret;
437 }
438
439 //ablc get result
Ablc_GetProcResult_V32(AblcContext_V32_t * pAblcCtx,AblcProc_V32_t * pAblcResult)440 AblcResult_V32_t Ablc_GetProcResult_V32(AblcContext_V32_t* pAblcCtx, AblcProc_V32_t* pAblcResult)
441 {
442 LOGD_ABLC("%s(%d): enter!\n", __FUNCTION__, __LINE__);
443
444 if (pAblcCtx == NULL) {
445 LOGE_ABLC("%s(%d): null pointer\n", __FUNCTION__, __LINE__);
446 return ABLC_V32_RET_NULL_POINTER;
447 }
448
449 if (pAblcResult == NULL) {
450 LOGE_ABLC("%s(%d): null pointer \n", __FUNCTION__, __LINE__);
451 return ABLC_V32_RET_NULL_POINTER;
452 }
453
454 if (pAblcCtx->eMode == ABLC_V32_OP_MODE_AUTO) {
455 if (pAblcCtx->stBlc0Select.enable) {
456 pAblcResult->enable = pAblcCtx->stBlc0Select.enable;
457 pAblcResult->blc_r = pAblcCtx->stBlc0Select.blc_r;
458 pAblcResult->blc_gr = pAblcCtx->stBlc0Select.blc_gr;
459 pAblcResult->blc_gb = pAblcCtx->stBlc0Select.blc_gb;
460 pAblcResult->blc_b = pAblcCtx->stBlc0Select.blc_b;
461 } else {
462 pAblcResult->enable = false;
463 pAblcResult->blc_r = 0;
464 pAblcResult->blc_gr = 0;
465 pAblcResult->blc_gb = 0;
466 pAblcResult->blc_b = 0;
467 }
468 if (pAblcCtx->stBlc1Select.enable) {
469 //hdr won't use blc1
470 pAblcResult->blc1_enable = pAblcCtx->stBlc1Select.enable;
471 pAblcResult->blc1_r = pAblcCtx->stBlc1Select.blc_r;
472 pAblcResult->blc1_gr = pAblcCtx->stBlc1Select.blc_gr;
473 pAblcResult->blc1_gb = pAblcCtx->stBlc1Select.blc_gb;
474 pAblcResult->blc1_b = pAblcCtx->stBlc1Select.blc_b;
475 } else {
476 pAblcResult->blc1_enable = false;
477 pAblcResult->blc1_r = 0;
478 pAblcResult->blc1_gr = 0;
479 pAblcResult->blc1_gb = 0;
480 pAblcResult->blc1_b = 0;
481 }
482 if (pAblcCtx->stBlcOBSelect.enable) {
483 pAblcResult->blc_ob_enable = pAblcCtx->stBlcOBSelect.enable;
484 // isp_ob_offset algo result
485 pAblcResult->isp_ob_offset = pAblcCtx->stBlcOBSelect.ob_offset;
486 // isp_ob_predgain algo result
487 pAblcResult->isp_ob_predgain = pAblcCtx->stBlcOBSelect.ob_predgain;
488 // isp_ob_max algo result
489 pAblcResult->isp_ob_max = (int)(4096 * pAblcResult->isp_ob_predgain) - pAblcResult->isp_ob_offset;
490 } else {
491 pAblcResult->blc_ob_enable = false;
492 pAblcResult->isp_ob_offset = 0;
493 pAblcResult->isp_ob_predgain = 1;
494 pAblcResult->isp_ob_max = 0xfffff;
495 }
496 } else if (pAblcCtx->eMode == ABLC_V32_OP_MODE_MANUAL){
497 pAblcResult->enable = pAblcCtx->stBlc0Manual.enable;
498 if (pAblcResult->enable) {
499 pAblcResult->blc_r = pAblcCtx->stBlc0Manual.blc_r;
500 pAblcResult->blc_gr = pAblcCtx->stBlc0Manual.blc_gr;
501 pAblcResult->blc_gb = pAblcCtx->stBlc0Manual.blc_gb;
502 pAblcResult->blc_b = pAblcCtx->stBlc0Manual.blc_b;
503 } else {
504 pAblcResult->enable = false;
505 pAblcResult->blc_r = 0;
506 pAblcResult->blc_gr = 0;
507 pAblcResult->blc_gb = 0;
508 pAblcResult->blc_b = 0;
509 }
510 if (pAblcCtx->stBlc1Manual.enable) {
511 pAblcResult->blc1_enable = pAblcCtx->stBlc1Manual.enable;
512 pAblcResult->blc1_r = pAblcCtx->stBlc1Manual.blc_r;
513 pAblcResult->blc1_gr = pAblcCtx->stBlc1Manual.blc_gr;
514 pAblcResult->blc1_gb = pAblcCtx->stBlc1Manual.blc_gb;
515 pAblcResult->blc1_b = pAblcCtx->stBlc1Manual.blc_b;
516 }
517 if (pAblcCtx->stBlcOBManual.enable) {
518 pAblcResult->blc_ob_enable = pAblcCtx->stBlcOBManual.enable;
519 // isp_ob_offset
520 pAblcResult->isp_ob_offset = pAblcCtx->stBlcOBManual.ob_offset;
521 // isp_ob_predgain
522 pAblcResult->isp_ob_predgain = pAblcCtx->stBlcOBManual.ob_predgain;
523 // isp_ob_max
524 pAblcResult->isp_ob_max = (int)(4096 * pAblcCtx->stBlcOBManual.ob_predgain) - pAblcCtx->stBlcOBManual.ob_offset;
525 } else {
526 pAblcResult->blc_ob_enable = false;
527 pAblcResult->isp_ob_offset = 0;
528 pAblcResult->isp_ob_predgain = 1;
529 pAblcResult->isp_ob_max = 0xfffff;
530 }
531 }
532
533 if (pAblcCtx->stExpInfo.hdr_mode) {
534 //hdr_mode won't use blc1
535 pAblcResult->blc1_enable = false;
536 pAblcResult->blc1_r = 0;
537 pAblcResult->blc1_gr = 0;
538 pAblcResult->blc1_gb = 0;
539 pAblcResult->blc1_b = 0;
540
541 //hdr_mode won't use blc_ob
542 pAblcResult->blc_ob_enable = false;
543 pAblcResult->isp_ob_offset = 0;
544 pAblcResult->isp_ob_predgain = 1;
545 pAblcResult->isp_ob_max = 0xfffff;
546 }
547
548 return ABLC_V32_RET_SUCCESS;
549 }
550