1 /*
2 * rk_aiq_adehaze_algo_v12.cpp
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 #include "rk_aiq_adehaze_algo_v12.h"
20 #include <string.h>
21 #include "xcam_log.h"
22
DehazeHistWrTableInterpV12(const HistWr_t * pCurveIn,mManual_curve_t * pCurveOut,float posx)23 void DehazeHistWrTableInterpV12(const HistWr_t* pCurveIn, mManual_curve_t* pCurveOut, float posx) {
24 int i = 0;
25 float ratio = 1.0;
26
27 if (posx < pCurveIn->manual_curve[0].CtrlData) {
28 for (int i = 0; i < DHAZ_V12_HIST_WR_CURVE_NUM; i++) {
29 pCurveOut->curve_x[i] = pCurveIn->manual_curve[0].curve_x[i];
30 pCurveOut->curve_y[i] = pCurveIn->manual_curve[0].curve_y[i];
31 }
32 } else if (posx >= pCurveIn->manual_curve[12].CtrlData) {
33 for (int i = 0; i < DHAZ_V12_HIST_WR_CURVE_NUM; i++) {
34 pCurveOut->curve_x[i] = pCurveIn->manual_curve[12].curve_x[i];
35 pCurveOut->curve_y[i] = pCurveIn->manual_curve[12].curve_y[i];
36 }
37 } else {
38 for (int i = 0; i < DHAZ_CTRL_DATA_STEP_MAX; i++) {
39 if (posx >= pCurveIn->manual_curve[i].CtrlData &&
40 posx < pCurveIn->manual_curve[i + 1].CtrlData) {
41 if ((pCurveIn->manual_curve[i + 1].CtrlData - pCurveIn->manual_curve[i].CtrlData) !=
42 0)
43 ratio = (posx - pCurveIn->manual_curve[i].CtrlData) /
44 (pCurveIn->manual_curve[i + 1].CtrlData -
45 pCurveIn->manual_curve[i].CtrlData);
46 else
47 LOGE_ADEHAZE("Dehaze zero in %s(%d) \n", __func__, __LINE__);
48
49 for (int j = 0; j < DHAZ_V12_HIST_WR_CURVE_NUM; j++) {
50 pCurveOut->curve_x[j] = ratio * (pCurveIn->manual_curve[i + 1].curve_x[j] -
51 pCurveIn->manual_curve[i].curve_x[j]) +
52 pCurveIn->manual_curve[i].curve_x[j];
53 pCurveOut->curve_y[j] = ratio * (pCurveIn->manual_curve[i + 1].curve_y[j] -
54 pCurveIn->manual_curve[i].curve_y[j]) +
55 pCurveIn->manual_curve[i].curve_y[j];
56 }
57 break;
58 } else
59 continue;
60 }
61 }
62
63 // check curve_x
64 for (int i = 1; i < DHAZ_CTRL_DATA_STEP_MAX; i++) {
65 if (!(pCurveOut->curve_x[i] % HSIT_WR_MIN_STEP))
66 continue;
67 else {
68 int orig_x = pCurveOut->curve_x[i];
69 pCurveOut->curve_x[i] = HSIT_WR_MIN_STEP * (pCurveOut->curve_x[i] / HSIT_WR_MIN_STEP);
70 if (orig_x != 0) {
71 pCurveOut->curve_y[i] = pCurveOut->curve_y[i - 1] +
72 (pCurveOut->curve_x[i] - pCurveOut->curve_x[i - 1]) *
73 (pCurveOut->curve_y[i] - pCurveOut->curve_y[i - 1]) /
74 (orig_x - pCurveOut->curve_x[i - 1]);
75 }
76 continue;
77 }
78 }
79
80 #if 0
81 LOGD_ADEHAZE(
82 "%s hist_wr.curve_x[0~11]:0x%x 0x%x 0x%x "
83 "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
84 __func__, pCurveOut->curve_x[0], pCurveOut->curve_x[1], pCurveOut->curve_x[2],
85 pCurveOut->curve_x[3], pCurveOut->curve_x[4], pCurveOut->curve_x[5], pCurveOut->curve_x[6],
86 pCurveOut->curve_x[7], pCurveOut->curve_x[8], pCurveOut->curve_x[9], pCurveOut->curve_x[10],
87 pCurveOut->curve_x[11]);
88 LOGD_ADEHAZE(
89 "%s hist_wr.curve_y[0~11]:0x%x 0x%x 0x%x "
90 "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
91 __func__, pCurveOut->curve_y[0], pCurveOut->curve_y[1], pCurveOut->curve_y[2],
92 pCurveOut->curve_y[3], pCurveOut->curve_y[4], pCurveOut->curve_y[5], pCurveOut->curve_y[6],
93 pCurveOut->curve_y[7], pCurveOut->curve_y[8], pCurveOut->curve_y[9], pCurveOut->curve_y[10],
94 pCurveOut->curve_y[11]);
95 #endif
96 }
97
GetInterpRatioV12(float * pX,int lo,int hi,float CtrlValue,int length_max)98 float GetInterpRatioV12(float* pX, int lo, int hi, float CtrlValue, int length_max) {
99 float ratio = 0.0f;
100
101 if (CtrlValue < pX[0]) {
102 lo = 0;
103 hi = 0;
104 ratio = 0.0f;
105 } else if (CtrlValue >= pX[length_max - 1]) {
106 lo = length_max - 1;
107 hi = length_max - 1;
108 ratio = 0.0f;
109 } else {
110 for (int i = 0; i < length_max - 1; i++) {
111 if (CtrlValue >= pX[i] && CtrlValue < pX[i + 1]) {
112 lo = i;
113 hi = i + 1;
114 ratio = (CtrlValue - pX[i]) / (pX[i + 1] - pX[i]);
115 break;
116 } else
117 continue;
118 }
119 }
120
121 return ratio;
122 }
123
ClipValueV12(float posx,int BitInt,int BitFloat)124 int ClipValueV12(float posx, int BitInt, int BitFloat) {
125 int yOutInt = 0;
126 int yOutIntMax = (int)(pow(2, (BitFloat + BitInt)) - 1);
127 int yOutIntMin = 0;
128
129 yOutInt = LIMIT_VALUE((int)(posx * pow(2, BitFloat)), yOutIntMax, yOutIntMin);
130
131 return yOutInt;
132 }
133
TransferHistWr2Res(RkAiqAdehazeProcResult_t * pProcRes,mManual_curve_t * pCurve)134 XCamReturn TransferHistWr2Res(RkAiqAdehazeProcResult_t* pProcRes, mManual_curve_t* pCurve) {
135 LOG1_ADEHAZE("ENTER: %s \n", __func__);
136 XCamReturn ret = XCAM_RETURN_NO_ERROR;
137
138 // check curve_x
139 for (int i = 0; i < DHAZ_V12_HIST_WR_CURVE_NUM - 2; i++) {
140 if (!(pCurve->curve_x[i] % HSIT_WR_MIN_STEP) &&
141 !(pCurve->curve_x[i + 1] % HSIT_WR_MIN_STEP)) {
142 if (pCurve->curve_x[i] < pCurve->curve_x[i + 1])
143 continue;
144 else {
145 LOGE_ADEHAZE("%s hist_wr.manu_curve.curve_x[%d] is samller than curve_x[%d]\n",
146 __func__, i + 1, i);
147 return XCAM_RETURN_ERROR_PARAM;
148 }
149 } else {
150 LOGE_ADEHAZE("%s hist_wr.manu_curve.curve_x[%d] can not be divided by 16\n", __func__,
151 i);
152 return XCAM_RETURN_ERROR_PARAM;
153 }
154 }
155 if (!(!(pCurve->curve_x[16] % HSIT_WR_MIN_STEP) || pCurve->curve_x[16] == HSIT_WR_X_MAX)) {
156 LOGE_ADEHAZE("%s hist_wr.manu_curve.curve_x[12] can not be divided by 16\n", __func__);
157 return XCAM_RETURN_ERROR_PARAM;
158 }
159
160 int step = 0;
161 int add_knots = 0;
162 int k = 0;
163 for (int i = 0; i < DHAZ_V12_HIST_WR_CURVE_NUM - 2; i++) {
164 pProcRes->ProcResV12.hist_wr[k] = pCurve->curve_y[i];
165 pProcRes->ProcResV12.hist_wr[k] =
166 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.hist_wr[k], BIT_10_MAX);
167 step = (pCurve->curve_x[i + 1] - pCurve->curve_x[i]) / HSIT_WR_MIN_STEP;
168 add_knots = step;
169 for (int j = 1; step; step--) {
170 pProcRes->ProcResV12.hist_wr[k + j] =
171 pCurve->curve_y[i] + HSIT_WR_MIN_STEP * j *
172 (pCurve->curve_y[i + 1] - pCurve->curve_y[i]) /
173 (pCurve->curve_x[i + 1] - pCurve->curve_x[i]);
174 pProcRes->ProcResV12.hist_wr[k + j] =
175 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.hist_wr[k + j], BIT_10_MAX);
176 j++;
177 }
178 k += add_knots;
179 }
180
181 step = (1024 - pCurve->curve_x[15]) / HSIT_WR_MIN_STEP;
182 for (int j = 1; step; step--) {
183 pProcRes->ProcResV12.hist_wr[k + j] =
184 pCurve->curve_y[15] +
185 HSIT_WR_MIN_STEP * j * (1024 - pCurve->curve_y[15]) / (1024 - pCurve->curve_x[15]);
186 pProcRes->ProcResV12.hist_wr[k + j] =
187 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.hist_wr[k + j], BIT_10_MAX);
188 j++;
189 }
190
191 LOG1_ADEHAZE("EIXT: %s \n", __func__);
192 return ret;
193 }
194
calc_cdf(int * hist,int * cdf,int bin_num,float clim,uint16_t vmin,uint16_t vmax)195 void calc_cdf(int* hist, int* cdf, int bin_num, float clim, uint16_t vmin, uint16_t vmax) {
196 int sum = 0;
197 int i;
198 int fix_clim;
199 int extra = 0;
200 int add;
201
202 if (bin_num <= 0) return;
203
204 for (i = 0; i < bin_num; ++i) {
205 hist[i] = hist[i] * 8;
206 sum += hist[i];
207 }
208
209 fix_clim = ((int)(clim * sum)) / bin_num;
210
211 for (i = 0; i < bin_num; ++i) {
212 if (hist[i] > fix_clim) {
213 extra += hist[i] - fix_clim;
214 hist[i] = fix_clim;
215 }
216 }
217
218 add = (extra + bin_num / 2) / bin_num;
219
220 for (i = 0; i < bin_num; ++i) {
221 hist[i] += add;
222 }
223
224 cdf[0] = hist[0];
225
226 for (i = 1; i < bin_num; ++i) {
227 cdf[i] = cdf[i - 1] + hist[i];
228 }
229
230 if (cdf[bin_num - 1] > 0) {
231 for (i = 0; i < bin_num; ++i) {
232 cdf[i] = cdf[i] * (vmax - vmin) / cdf[bin_num - 1] + vmin;
233 }
234 } else {
235 for (i = 0; i < bin_num; ++i) {
236 cdf[i] = i * (vmax - vmin) / (bin_num - 1) + vmin;
237 }
238 }
239 }
240
TransferHistWrSemiAtuos2Res(RkAiqAdehazeProcResult_t * pProcRes,mhist_wr_semiauto_t * pSemiAutoCurve,dehaze_stats_v12_t * pStats,bool stats_true)241 XCamReturn TransferHistWrSemiAtuos2Res(RkAiqAdehazeProcResult_t* pProcRes,
242 mhist_wr_semiauto_t* pSemiAutoCurve,
243 dehaze_stats_v12_t* pStats, bool stats_true) {
244 LOG1_ADEHAZE("ENTER: %s \n", __func__);
245
246 if (!stats_true) return XCAM_RETURN_BYPASS;
247
248 XCamReturn ret = XCAM_RETURN_NO_ERROR;
249 int i;
250 int hist[64];
251 int cdf_out[64];
252 int dark_idx = 1;
253 int mean = 0;
254 static bool first_time = true;
255
256 if (first_time) {
257 for (i = 0; i < 63; ++i) {
258 pProcRes->ProcResV12.hist_wr[i] = (i + 1) * 16;
259 }
260 pProcRes->ProcResV12.hist_wr[i] = 1023;
261 first_time = false;
262 return XCAM_RETURN_NO_ERROR;
263 }
264
265 if (pStats->h_rgb_iir[63] != 1023) {
266 LOGW_ADEHAZE("invalid cdf input, using normalize output\n");
267 return XCAM_RETURN_BYPASS;
268 }
269
270 for (i = 0; i < 64; ++i) {
271 hist[i] = (pStats->h_rgb_iir[i / 2] >> ((i % 2) * 16)) & 0xffff;
272 }
273
274 for (i = 63; i > 0; --i) {
275 hist[i] = LIMIT_VALUE(pStats->h_rgb_iir[i] - pStats->h_rgb_iir[i - 1], 1023, 0);
276 mean += (i + 1) * 16 * hist[i];
277 }
278
279 hist[0] = pStats->h_rgb_iir[0];
280 mean += 16 * hist[0];
281 mean = mean >> 10;
282 pSemiAutoCurve->dark_th = MAX(1024 - mean, pSemiAutoCurve->dark_th);
283 dark_idx = (int(pSemiAutoCurve->dark_th + 8.0f) / 16.0f);
284 dark_idx = LIMIT_VALUE(dark_idx, 64, 1);
285
286 calc_cdf(hist, cdf_out, dark_idx, pSemiAutoCurve->clim0, 0, dark_idx * 16);
287 calc_cdf(hist + dark_idx, cdf_out + dark_idx, 64 - dark_idx, pSemiAutoCurve->clim1,
288 dark_idx * 16, 1023);
289
290 for (i = 0; i < 64; ++i) {
291 if (i < dark_idx)
292 cdf_out[i] = cdf_out[i] < (i + 1) * 16 ? (i + 1) * 16 : cdf_out[i];
293 else if (cdf_out[i] < cdf_out[i - 1])
294 cdf_out[i] = cdf_out[i - 1];
295 pProcRes->ProcResV12.hist_wr[i] =
296 (7 * pProcRes->ProcResV12.hist_wr[i] + cdf_out[i] + 4) / 8;
297 pProcRes->ProcResV12.hist_wr[i] =
298 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.hist_wr[i], 1023);
299 }
300
301 LOG1_ADEHAZE("EIXT: %s \n", __func__);
302 return ret;
303 }
304
stManuGetDehazeParamsV12(mDehazeAttrV12_t * pStManu,RkAiqAdehazeProcResult_t * pProcRes,int rawWidth,int rawHeight,unsigned int MDehazeStrth)305 void stManuGetDehazeParamsV12(mDehazeAttrV12_t* pStManu, RkAiqAdehazeProcResult_t* pProcRes,
306 int rawWidth, int rawHeight, unsigned int MDehazeStrth) {
307 LOG1_ADEHAZE("ENTER: %s \n", __func__);
308
309 pProcRes->ProcResV12.air_lc_en =
310 pStManu->dehaze_setting.air_lc_en ? FUNCTION_ENABLE : FUNCTION_DISABLE;
311 pProcRes->ProcResV12.dc_min_th =
312 ClipValueV12(pStManu->dehaze_setting.DehazeData.dc_min_th, 8, 0);
313 pProcRes->ProcResV12.dc_max_th =
314 ClipValueV12(pStManu->dehaze_setting.DehazeData.dc_max_th, 8, 0);
315 pProcRes->ProcResV12.yhist_th = ClipValueV12(pStManu->dehaze_setting.DehazeData.yhist_th, 8, 0);
316 pProcRes->ProcResV12.yblk_th = int(pStManu->dehaze_setting.DehazeData.yblk_th *
317 ((rawWidth + 15) / 16) * ((rawHeight + 15) / 16));
318 pProcRes->ProcResV12.dark_th = ClipValueV12(pStManu->dehaze_setting.DehazeData.dark_th, 8, 0);
319 pProcRes->ProcResV12.bright_min =
320 ClipValueV12(pStManu->dehaze_setting.DehazeData.bright_min, 8, 0);
321 pProcRes->ProcResV12.bright_max =
322 ClipValueV12(pStManu->dehaze_setting.DehazeData.bright_max, 8, 0);
323 pProcRes->ProcResV12.wt_max = ClipValueV12(pStManu->dehaze_setting.DehazeData.wt_max, 0, 8);
324 pProcRes->ProcResV12.air_min = ClipValueV12(pStManu->dehaze_setting.DehazeData.air_min, 8, 0);
325 pProcRes->ProcResV12.air_max = ClipValueV12(pStManu->dehaze_setting.DehazeData.air_max, 8, 0);
326 pProcRes->ProcResV12.tmax_base =
327 ClipValueV12(pStManu->dehaze_setting.DehazeData.tmax_base, 8, 0);
328 pProcRes->ProcResV12.tmax_off =
329 ClipValueV12(pStManu->dehaze_setting.DehazeData.tmax_off, 0, 10);
330 pProcRes->ProcResV12.tmax_max =
331 ClipValueV12(pStManu->dehaze_setting.DehazeData.tmax_max, 0, 10);
332 pProcRes->ProcResV12.cfg_wt = ClipValueV12(pStManu->dehaze_setting.DehazeData.cfg_wt, 0, 8);
333 pProcRes->ProcResV12.cfg_air = ClipValueV12(pStManu->dehaze_setting.DehazeData.cfg_air, 8, 0);
334 pProcRes->ProcResV12.cfg_tmax =
335 ClipValueV12(pStManu->dehaze_setting.DehazeData.cfg_tmax, 0, 10);
336 pProcRes->ProcResV12.range_sima =
337 ClipValueV12(pStManu->dehaze_setting.DehazeData.range_sigma, 0, 8);
338 pProcRes->ProcResV12.space_sigma_cur =
339 ClipValueV12(pStManu->dehaze_setting.DehazeData.space_sigma_cur, 0, 8);
340 pProcRes->ProcResV12.space_sigma_pre =
341 ClipValueV12(pStManu->dehaze_setting.DehazeData.space_sigma_pre, 0, 8);
342 pProcRes->ProcResV12.bf_weight =
343 ClipValueV12(pStManu->dehaze_setting.DehazeData.bf_weight, 0, 8);
344 pProcRes->ProcResV12.dc_weitcur =
345 ClipValueV12(pStManu->dehaze_setting.DehazeData.dc_weitcur, 0, 8);
346 pProcRes->ProcResV12.stab_fnum = ClipValueV12(pStManu->dehaze_setting.stab_fnum, 5, 0);
347 if (pStManu->dehaze_setting.sigma)
348 pProcRes->ProcResV12.iir_sigma =
349 LIMIT_VALUE(int(256.0f / pStManu->dehaze_setting.sigma), 255, 0);
350 else
351 pProcRes->ProcResV12.iir_sigma = 0x1;
352 if (pStManu->dehaze_setting.wt_sigma >= 0.0f)
353 pProcRes->ProcResV12.iir_wt_sigma =
354 LIMIT_VALUE(int(1024.0f / (8.0f * pStManu->dehaze_setting.wt_sigma + 0.5f)), 0x7ff, 0);
355 else
356 pProcRes->ProcResV12.iir_wt_sigma = 0x7ff;
357 if (pStManu->dehaze_setting.air_sigma)
358 pProcRes->ProcResV12.iir_air_sigma =
359 LIMIT_VALUE(int(1024.0f / pStManu->dehaze_setting.air_sigma), 255, 0);
360 else
361 pProcRes->ProcResV12.iir_air_sigma = 0x8;
362 if (pStManu->dehaze_setting.tmax_sigma)
363 pProcRes->ProcResV12.iir_tmax_sigma =
364 LIMIT_VALUE(int(1.0f / pStManu->dehaze_setting.tmax_sigma), 0x7ff, 0);
365 else
366 pProcRes->ProcResV12.iir_tmax_sigma = 0x5f;
367 pProcRes->ProcResV12.iir_pre_wet =
368 LIMIT_VALUE(int(pStManu->dehaze_setting.pre_wet - 1.0f), 15, 0);
369 pProcRes->ProcResV12.gaus_h0 = DEHAZE_GAUS_H4;
370 pProcRes->ProcResV12.gaus_h1 = DEHAZE_GAUS_H1;
371 pProcRes->ProcResV12.gaus_h2 = DEHAZE_GAUS_H0;
372
373 // add for rk_aiq_uapi2_setMDehazeStrth
374 if (MDehazeStrth != DEHAZE_DEFAULT_LEVEL) {
375 pProcRes->ProcResV12.cfg_alpha = BIT_8_MAX;
376 unsigned int level_diff = MDehazeStrth > DEHAZE_DEFAULT_LEVEL
377 ? (MDehazeStrth - DEHAZE_DEFAULT_LEVEL)
378 : (DEHAZE_DEFAULT_LEVEL - MDehazeStrth);
379 bool level_up = MDehazeStrth > DEHAZE_DEFAULT_LEVEL;
380 if (level_up) {
381 pProcRes->ProcResV12.cfg_wt += level_diff * DEHAZE_DEFAULT_CFG_WT_STEP;
382 pProcRes->ProcResV12.cfg_air += level_diff * DEHAZE_DEFAULT_CFG_AIR_STEP;
383 pProcRes->ProcResV12.cfg_tmax += level_diff * DEHAZE_DEFAULT_CFG_TMAX_STEP;
384 } else {
385 pProcRes->ProcResV12.cfg_wt =
386 level_diff * DEHAZE_DEFAULT_CFG_WT_STEP > pProcRes->ProcResV12.cfg_wt
387 ? 0
388 : (pProcRes->ProcResV12.cfg_wt - level_diff * DEHAZE_DEFAULT_CFG_WT_STEP);
389 pProcRes->ProcResV12.cfg_air =
390 level_diff * DEHAZE_DEFAULT_CFG_AIR_STEP > pProcRes->ProcResV12.cfg_air
391 ? 0
392 : (pProcRes->ProcResV12.cfg_air - level_diff * DEHAZE_DEFAULT_CFG_AIR_STEP);
393 pProcRes->ProcResV12.cfg_tmax =
394 level_diff * DEHAZE_DEFAULT_CFG_TMAX_STEP > pProcRes->ProcResV12.cfg_tmax
395 ? 0
396 : (pProcRes->ProcResV12.cfg_tmax - level_diff * DEHAZE_DEFAULT_CFG_TMAX_STEP);
397 }
398 pProcRes->ProcResV12.cfg_wt = LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.cfg_wt, BIT_8_MAX);
399 pProcRes->ProcResV12.cfg_tmax =
400 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.cfg_tmax, BIT_10_MAX);
401 }
402
403 if (pProcRes->ProcResV12.dc_en && !(pProcRes->ProcResV12.enhance_en)) {
404 if (pProcRes->ProcResV12.cfg_alpha == 255) {
405 LOGD_ADEHAZE("%s cfg_alpha:1 cfg_air:%f cfg_tmax:%f cfg_wt:%f\n", __func__,
406 pProcRes->ProcResV12.cfg_air / 1.0f,
407 pProcRes->ProcResV12.cfg_tmax / 1023.0f,
408 pProcRes->ProcResV12.cfg_wt / 255.0f);
409 LOGD_ADEHAZE("%s cfg_alpha_reg:0x255 cfg_air:0x%x cfg_tmax:0x%x cfg_wt:0x%x\n",
410 __func__, pProcRes->ProcResV12.cfg_air, pProcRes->ProcResV12.cfg_tmax,
411 pProcRes->ProcResV12.cfg_wt);
412 } else if (pProcRes->ProcResV12.cfg_alpha == 0) {
413 LOGD_ADEHAZE("%s cfg_alpha:0 air_max:%f air_min:%f tmax_base:%f wt_max:%f\n", __func__,
414 pProcRes->ProcResV12.air_max / 1.0f, pProcRes->ProcResV12.air_min / 1.0f,
415 pProcRes->ProcResV12.tmax_base / 1.0f,
416 pProcRes->ProcResV12.wt_max / 255.0f);
417 LOGD_ADEHAZE(
418 "%s cfg_alpha_reg:0x0 air_max:0x%x air_min:0x%x tmax_base:0x%x wt_max:0x%x\n",
419 __func__, pProcRes->ProcResV12.air_max, pProcRes->ProcResV12.air_min,
420 pProcRes->ProcResV12.tmax_base, pProcRes->ProcResV12.wt_max);
421 }
422 }
423
424 LOG1_ADEHAZE("EIXT: %s \n", __func__);
425 }
426
stManuGetEnhanceParamsV12(mDehazeAttrV12_t * pStManu,RkAiqAdehazeProcResult_t * pProcRes,unsigned int MEnhanceStrth,unsigned int MEnhanceChromeStrth)427 void stManuGetEnhanceParamsV12(mDehazeAttrV12_t* pStManu, RkAiqAdehazeProcResult_t* pProcRes,
428 unsigned int MEnhanceStrth, unsigned int MEnhanceChromeStrth) {
429 LOG1_ADEHAZE("ENTER: %s \n", __func__);
430 bool level_up = false;
431 unsigned int level_diff = 0;
432
433 pProcRes->ProcResV12.enhance_value =
434 ClipValueV12(pStManu->enhance_setting.EnhanceData.enhance_value, 4, 10);
435 pProcRes->ProcResV12.enhance_chroma =
436 ClipValueV12(pStManu->enhance_setting.EnhanceData.enhance_chroma, 4, 10);
437
438 for (int i = 0; i < DHAZ_V12_ENHANCE_CRUVE_NUM; i++)
439 pProcRes->ProcResV12.enh_curve[i] =
440 (int)(pStManu->enhance_setting.EnhanceData.enhance_curve[i]);
441
442 // dehaze v12 add
443 pProcRes->ProcResV12.color_deviate_en = pStManu->enhance_setting.color_deviate_en;
444 pProcRes->ProcResV12.enh_luma_en = pStManu->enhance_setting.enh_luma_en;
445 for (int i = 0; i < DHAZ_V12_ENH_LUMA_NUM; i++)
446 pProcRes->ProcResV12.enh_luma[i] =
447 ClipValueV12(pStManu->enhance_setting.EnhanceData.enh_luma[i], 4, 6);
448
449 // add for rk_aiq_uapi2_setMEnhanceStrth
450 if (MEnhanceStrth != ENHANCE_DEFAULT_LEVEL) {
451 level_diff = MEnhanceStrth > ENHANCE_DEFAULT_LEVEL
452 ? (MEnhanceStrth - ENHANCE_DEFAULT_LEVEL)
453 : (ENHANCE_DEFAULT_LEVEL - MEnhanceStrth);
454 level_up = MEnhanceStrth > ENHANCE_DEFAULT_LEVEL;
455 if (pProcRes->ProcResV12.enh_luma_en) {
456 if (level_up) {
457 for (int j = 0; j < DHAZ_V12_ENH_LUMA_NUM; j++) {
458 pProcRes->ProcResV12.enh_luma[j] += level_diff * ENH_LUMA_DEFAULT_STEP;
459 pProcRes->ProcResV12.enh_luma[j] =
460 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enh_luma[j], BIT_10_MAX);
461 }
462 } else {
463 for (int j = 0; j < DHAZ_V12_ENH_LUMA_NUM; j++) {
464 pProcRes->ProcResV12.enh_luma[j] =
465 level_diff * ENH_LUMA_DEFAULT_STEP > pProcRes->ProcResV12.enh_luma[j]
466 ? 0
467 : (pProcRes->ProcResV12.enh_luma[j] -
468 level_diff * ENH_LUMA_DEFAULT_STEP);
469 pProcRes->ProcResV12.enh_luma[j] =
470 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enh_luma[j], BIT_10_MAX);
471 }
472 }
473 } else {
474 if (level_up) {
475 pProcRes->ProcResV12.enhance_value += level_diff * ENHANCE_VALUE_DEFAULT_STEP;
476 } else {
477 pProcRes->ProcResV12.enhance_value =
478 level_diff * ENHANCE_VALUE_DEFAULT_STEP > pProcRes->ProcResV12.enhance_value
479 ? 0
480 : (pProcRes->ProcResV12.enhance_value -
481 level_diff * ENHANCE_VALUE_DEFAULT_STEP);
482 }
483 pProcRes->ProcResV12.enhance_value =
484 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enhance_value, BIT_14_MAX);
485 }
486 }
487
488 // add for rk_aiq_uapi2_setMEnhanceChromeStrth
489 if (MEnhanceChromeStrth != ENHANCE_DEFAULT_LEVEL) {
490 level_diff = MEnhanceChromeStrth > ENHANCE_DEFAULT_LEVEL
491 ? (MEnhanceChromeStrth - ENHANCE_DEFAULT_LEVEL)
492 : (ENHANCE_DEFAULT_LEVEL - MEnhanceChromeStrth);
493 level_up = MEnhanceChromeStrth > ENHANCE_DEFAULT_LEVEL;
494 if (level_up) {
495 pProcRes->ProcResV12.enhance_chroma += level_diff * ENHANCE_VALUE_DEFAULT_STEP;
496 } else {
497 pProcRes->ProcResV12.enhance_chroma =
498 level_diff * ENHANCE_VALUE_DEFAULT_STEP > pProcRes->ProcResV12.enhance_chroma
499 ? 0
500 : (pProcRes->ProcResV12.enhance_chroma -
501 level_diff * ENHANCE_VALUE_DEFAULT_STEP);
502 }
503 pProcRes->ProcResV12.enhance_chroma =
504 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enhance_chroma, BIT_14_MAX);
505 }
506
507 if (pProcRes->ProcResV12.dc_en && pProcRes->ProcResV12.enhance_en) {
508 LOGD_ADEHAZE("%s color_deviate_en:%d enh_luma_en:%d\n", __func__,
509 pProcRes->ProcResV12.color_deviate_en, pProcRes->ProcResV12.enh_luma_en);
510 LOGD_ADEHAZE("%s enhance_value:%f enhance_chroma:%f\n", __func__,
511 pStManu->enhance_setting.EnhanceData.enhance_value / 1024.0f,
512 pStManu->enhance_setting.EnhanceData.enhance_chroma / 1024.0f);
513 if (pProcRes->ProcResV12.enh_luma_en) {
514 LOGD_ADEHAZE(
515 "%s enh_luma[0~7]:%f %f %f %f %f %f %f %f\n", __func__,
516 pProcRes->ProcResV12.enh_luma[0] / 64.0f, pProcRes->ProcResV12.enh_luma[1] / 64.0f,
517 pProcRes->ProcResV12.enh_luma[2] / 64.0f, pProcRes->ProcResV12.enh_luma[3] / 64.0f,
518 pProcRes->ProcResV12.enh_luma[4] / 64.0f, pProcRes->ProcResV12.enh_luma[5] / 64.0f,
519 pProcRes->ProcResV12.enh_luma[6] / 64.0f, pProcRes->ProcResV12.enh_luma[7] / 64.0f);
520 }
521 LOGD_ADEHAZE("%s enhance_value_reg:0x%x enhance_chroma_reg:0x%x\n", __func__,
522 pProcRes->ProcResV12.enhance_value, pProcRes->ProcResV12.enhance_chroma);
523 }
524
525 LOG1_ADEHAZE("EIXT: %s \n", __func__);
526 }
527
stManuGetHistParamsV12(mDehazeAttrV12_t * pStManu,RkAiqAdehazeProcResult_t * pProcRes,dehaze_stats_v12_t * pStats,bool stats_true)528 void stManuGetHistParamsV12(mDehazeAttrV12_t* pStManu, RkAiqAdehazeProcResult_t* pProcRes,
529 dehaze_stats_v12_t* pStats, bool stats_true) {
530 LOG1_ADEHAZE("ENTER: %s \n", __func__);
531
532 pProcRes->ProcResV12.hpara_en =
533 pStManu->hist_setting.hist_para_en ? FUNCTION_ENABLE : FUNCTION_DISABLE;
534 // clip hpara_en
535 pProcRes->ProcResV12.hpara_en =
536 pProcRes->ProcResV12.dc_en ? pProcRes->ProcResV12.hpara_en : FUNCTION_ENABLE;
537
538 pProcRes->ProcResV12.hist_gratio =
539 ClipValueV12(pStManu->hist_setting.HistData.hist_gratio, 5, 3);
540 pProcRes->ProcResV12.hist_th_off =
541 ClipValueV12(pStManu->hist_setting.HistData.hist_th_off, 8, 0);
542 pProcRes->ProcResV12.hist_k = ClipValueV12(pStManu->hist_setting.HistData.hist_k, 3, 2);
543 pProcRes->ProcResV12.hist_min = ClipValueV12(pStManu->hist_setting.HistData.hist_min, 1, 8);
544 pProcRes->ProcResV12.cfg_gratio = ClipValueV12(pStManu->hist_setting.HistData.cfg_gratio, 5, 8);
545 pProcRes->ProcResV12.hist_scale = ClipValueV12(pStManu->hist_setting.HistData.hist_scale, 5, 8);
546
547 XCamReturn ret = XCAM_RETURN_NO_ERROR;
548 if (pStManu->hist_setting.hist_wr.mode == HIST_WR_MANUAL) {
549 ret = TransferHistWr2Res(pProcRes, &pStManu->hist_setting.hist_wr.manual_curve);
550 if (ret == XCAM_RETURN_NO_ERROR)
551 pProcRes->ProcResV12.soft_wr_en = FUNCTION_ENABLE;
552 else
553 pProcRes->ProcResV12.soft_wr_en = FUNCTION_DISABLE;
554 } else if (pStManu->hist_setting.hist_wr.mode == HIST_WR_AUTO) {
555 pProcRes->ProcResV12.soft_wr_en = FUNCTION_DISABLE;
556 } else if (pStManu->hist_setting.hist_wr.mode == HIST_WR_SEMIAUTO) {
557 ret = TransferHistWrSemiAtuos2Res(pProcRes, &pStManu->hist_setting.hist_wr.semiauto_curve,
558 pStats, stats_true);
559 if (ret == XCAM_RETURN_NO_ERROR)
560 pProcRes->ProcResV12.soft_wr_en = FUNCTION_ENABLE;
561 else
562 pProcRes->ProcResV12.soft_wr_en = FUNCTION_DISABLE;
563 }
564
565 if (pProcRes->ProcResV12.hist_en) {
566 LOGV_ADEHAZE(
567 "%s: stats_true:%d dhaz_adp_air_base:%d dhaz_adp_wt:%d dhaz_adp_gratio:%d "
568 "dhaz_adp_tmax:%d "
569 "dhaz_pic_sumh:%d \n",
570 __FUNCTION__, stats_true, pStats->dhaz_adp_air_base, pStats->dhaz_adp_wt,
571 pStats->dhaz_adp_gratio, pStats->dhaz_adp_tmax, pStats->dhaz_pic_sumh);
572 LOGV_ADEHAZE(
573 "%s h_rgb_iir[0~1]:0x%x 0x%x 0x%x "
574 "0x%x 0x%x 0x%x 0x%x\n",
575 __func__, pStats->h_rgb_iir[0], pStats->h_rgb_iir[1], pStats->h_rgb_iir[2],
576 pStats->h_rgb_iir[3], pStats->h_rgb_iir[4], pStats->h_rgb_iir[5], pStats->h_rgb_iir[6]);
577 LOGD_ADEHAZE(
578 "%s cfg_alpha:%f hist_para_en:%d hist_gratio:%f hist_th_off:%f hist_k:%f "
579 "hist_min:%f hist_scale:%f cfg_gratio:%f\n",
580 __func__, pProcRes->ProcResV12.cfg_alpha / 255.0f, pProcRes->ProcResV12.hpara_en,
581 pProcRes->ProcResV12.hist_gratio / 255.0f, pProcRes->ProcResV12.hist_th_off / 1.0f,
582 pProcRes->ProcResV12.hist_k / 4.0f, pProcRes->ProcResV12.hist_min / 256.0f,
583 pProcRes->ProcResV12.hist_scale / 256.0f, pProcRes->ProcResV12.cfg_gratio / 256.0f);
584 LOGD_ADEHAZE(
585 "%s cfg_alpha_reg:0x%x hist_gratio_reg:0x%x hist_th_off_reg:0x%x hist_k_reg:0x%x "
586 "hist_min_reg:0x%x hist_scale_reg:0x%x cfg_gratio_reg:0x%x\n",
587 __func__, pProcRes->ProcResV12.cfg_alpha, pProcRes->ProcResV12.hist_gratio,
588 pProcRes->ProcResV12.hist_th_off, pProcRes->ProcResV12.hist_k,
589 pProcRes->ProcResV12.hist_min, pProcRes->ProcResV12.hist_scale,
590 pProcRes->ProcResV12.cfg_gratio);
591 LOGD_ADEHAZE("%s soft_wr_en:%d hist_wr.mode:%d\n", __func__,
592 pProcRes->ProcResV12.soft_wr_en, pStManu->hist_setting.hist_wr.mode);
593 if (pProcRes->ProcResV12.soft_wr_en) {
594 LOGD_ADEHAZE(
595 "%s hist_wr[0~9]:0x%x 0x%x 0x%x "
596 "0x%x 0x%x 0x%x\n",
597 __func__, pProcRes->ProcResV12.hist_wr[0], pProcRes->ProcResV12.hist_wr[1],
598 pProcRes->ProcResV12.hist_wr[2], pProcRes->ProcResV12.hist_wr[3],
599 pProcRes->ProcResV12.hist_wr[4], pProcRes->ProcResV12.hist_wr[5],
600 pProcRes->ProcResV12.hist_wr[6], pProcRes->ProcResV12.hist_wr[7],
601 pProcRes->ProcResV12.hist_wr[8], pProcRes->ProcResV12.hist_wr[9]);
602 }
603 }
604
605 LOG1_ADEHAZE("EIXT: %s \n", __func__);
606 }
607
GetDehazeParamsV12(CalibDbDehazeV12_t * pCalibV12,RkAiqAdehazeProcResult_t * pProcRes,int rawWidth,int rawHeight,unsigned int MDehazeStrth,float CtrlValue)608 void GetDehazeParamsV12(CalibDbDehazeV12_t* pCalibV12, RkAiqAdehazeProcResult_t* pProcRes,
609 int rawWidth, int rawHeight, unsigned int MDehazeStrth, float CtrlValue) {
610 LOG1_ADEHAZE("ENTER: %s \n", __func__);
611 int lo = 0, hi = 0;
612 float ratio = GetInterpRatioV12(pCalibV12->dehaze_setting.DehazeData.CtrlData, lo, hi,
613 CtrlValue, DHAZ_CTRL_DATA_STEP_MAX);
614
615 pProcRes->ProcResV12.dc_min_th =
616 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.dc_min_th[hi] -
617 pCalibV12->dehaze_setting.DehazeData.dc_min_th[lo]) +
618 pCalibV12->dehaze_setting.DehazeData.dc_min_th[lo],
619 8, 0);
620 pProcRes->ProcResV12.dc_max_th =
621 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.dc_max_th[hi] -
622 pCalibV12->dehaze_setting.DehazeData.dc_max_th[lo]) +
623 pCalibV12->dehaze_setting.DehazeData.dc_max_th[lo],
624 8, 0);
625 pProcRes->ProcResV12.yhist_th =
626 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.yhist_th[hi] -
627 pCalibV12->dehaze_setting.DehazeData.yhist_th[lo]) +
628 pCalibV12->dehaze_setting.DehazeData.yhist_th[lo],
629 8, 0);
630 pProcRes->ProcResV12.yblk_th = (ratio * (pCalibV12->dehaze_setting.DehazeData.yblk_th[hi] -
631 pCalibV12->dehaze_setting.DehazeData.yblk_th[lo]) +
632 pCalibV12->dehaze_setting.DehazeData.yblk_th[lo]) *
633 ((rawWidth + 15) / 16) * ((rawHeight + 15) / 16);
634 pProcRes->ProcResV12.dark_th =
635 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.dark_th[hi] -
636 pCalibV12->dehaze_setting.DehazeData.dark_th[lo]) +
637 pCalibV12->dehaze_setting.DehazeData.dark_th[lo],
638 8, 0);
639
640 pProcRes->ProcResV12.bright_min =
641 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.bright_min[hi] -
642 pCalibV12->dehaze_setting.DehazeData.bright_min[lo]) +
643 pCalibV12->dehaze_setting.DehazeData.bright_min[lo],
644 8, 0);
645 pProcRes->ProcResV12.bright_max =
646 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.bright_max[hi] -
647 pCalibV12->dehaze_setting.DehazeData.bright_max[lo]) +
648 pCalibV12->dehaze_setting.DehazeData.bright_max[lo],
649 8, 0);
650 pProcRes->ProcResV12.wt_max =
651 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.wt_max[hi] -
652 pCalibV12->dehaze_setting.DehazeData.wt_max[lo]) +
653 pCalibV12->dehaze_setting.DehazeData.wt_max[lo],
654 0, 8);
655 pProcRes->ProcResV12.air_min =
656 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.air_min[hi] -
657 pCalibV12->dehaze_setting.DehazeData.air_min[lo]) +
658 pCalibV12->dehaze_setting.DehazeData.air_min[lo],
659 8, 0);
660 pProcRes->ProcResV12.air_max =
661 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.air_max[hi] -
662 pCalibV12->dehaze_setting.DehazeData.air_max[lo]) +
663 pCalibV12->dehaze_setting.DehazeData.air_max[lo],
664 8, 0);
665 pProcRes->ProcResV12.tmax_base =
666 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.tmax_base[hi] -
667 pCalibV12->dehaze_setting.DehazeData.tmax_base[lo]) +
668 pCalibV12->dehaze_setting.DehazeData.tmax_base[lo],
669 8, 0);
670 pProcRes->ProcResV12.tmax_off =
671 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.tmax_off[hi] -
672 pCalibV12->dehaze_setting.DehazeData.tmax_off[lo]) +
673 pCalibV12->dehaze_setting.DehazeData.tmax_off[lo],
674 0, 10);
675 pProcRes->ProcResV12.tmax_max =
676 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.tmax_max[hi] -
677 pCalibV12->dehaze_setting.DehazeData.tmax_max[lo]) +
678 pCalibV12->dehaze_setting.DehazeData.tmax_max[lo],
679 0, 10);
680 pProcRes->ProcResV12.cfg_wt =
681 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.cfg_wt[hi] -
682 pCalibV12->dehaze_setting.DehazeData.cfg_wt[lo]) +
683 pCalibV12->dehaze_setting.DehazeData.cfg_wt[lo],
684 0, 8);
685 pProcRes->ProcResV12.cfg_air =
686 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.cfg_air[hi] -
687 pCalibV12->dehaze_setting.DehazeData.cfg_air[lo]) +
688 pCalibV12->dehaze_setting.DehazeData.cfg_air[lo],
689 8, 0);
690 pProcRes->ProcResV12.cfg_tmax =
691 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.cfg_tmax[hi] -
692 pCalibV12->dehaze_setting.DehazeData.cfg_tmax[lo]) +
693 pCalibV12->dehaze_setting.DehazeData.cfg_tmax[lo],
694 0, 10);
695 pProcRes->ProcResV12.range_sima =
696 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.range_sigma[hi] -
697 pCalibV12->dehaze_setting.DehazeData.range_sigma[lo]) +
698 pCalibV12->dehaze_setting.DehazeData.range_sigma[lo],
699 0, 8);
700 pProcRes->ProcResV12.space_sigma_cur =
701 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.space_sigma_cur[hi] -
702 pCalibV12->dehaze_setting.DehazeData.space_sigma_cur[lo]) +
703 pCalibV12->dehaze_setting.DehazeData.space_sigma_cur[lo],
704 0, 8);
705 pProcRes->ProcResV12.space_sigma_pre =
706 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.space_sigma_pre[hi] -
707 pCalibV12->dehaze_setting.DehazeData.space_sigma_pre[lo]) +
708 pCalibV12->dehaze_setting.DehazeData.space_sigma_pre[lo],
709 0, 8);
710 pProcRes->ProcResV12.bf_weight =
711 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.bf_weight[hi] -
712 pCalibV12->dehaze_setting.DehazeData.bf_weight[lo]) +
713 pCalibV12->dehaze_setting.DehazeData.bf_weight[lo],
714 0, 8);
715 pProcRes->ProcResV12.dc_weitcur =
716 ClipValueV12(ratio * (pCalibV12->dehaze_setting.DehazeData.dc_weitcur[hi] -
717 pCalibV12->dehaze_setting.DehazeData.dc_weitcur[lo]) +
718 pCalibV12->dehaze_setting.DehazeData.dc_weitcur[lo],
719 0, 8);
720 pProcRes->ProcResV12.air_lc_en =
721 pCalibV12->dehaze_setting.air_lc_en ? FUNCTION_ENABLE : FUNCTION_DISABLE;
722 pProcRes->ProcResV12.stab_fnum = ClipValueV12(pCalibV12->dehaze_setting.stab_fnum, 5, 0);
723 if (pCalibV12->dehaze_setting.sigma)
724 pProcRes->ProcResV12.iir_sigma =
725 LIMIT_VALUE(int(256.0f / pCalibV12->dehaze_setting.sigma), 255, 0);
726 else
727 pProcRes->ProcResV12.iir_sigma = 0x1;
728 if (pCalibV12->dehaze_setting.wt_sigma >= 0.0f)
729 pProcRes->ProcResV12.iir_wt_sigma = LIMIT_VALUE(
730 int(1024.0f / (8.0f * pCalibV12->dehaze_setting.wt_sigma + 0.5f)), 0x7ff, 0);
731 else
732 pProcRes->ProcResV12.iir_wt_sigma = 0x7ff;
733 if (pCalibV12->dehaze_setting.air_sigma)
734 pProcRes->ProcResV12.iir_air_sigma =
735 LIMIT_VALUE(int(1024.0f / pCalibV12->dehaze_setting.air_sigma), 255, 0);
736 else
737 pProcRes->ProcResV12.iir_air_sigma = 0x8;
738 if (pCalibV12->dehaze_setting.tmax_sigma)
739 pProcRes->ProcResV12.iir_tmax_sigma =
740 LIMIT_VALUE(int(1.0f / pCalibV12->dehaze_setting.tmax_sigma), 0x7ff, 0);
741 else
742 pProcRes->ProcResV12.iir_tmax_sigma = 0x5f;
743 pProcRes->ProcResV12.iir_pre_wet =
744 LIMIT_VALUE(int(pCalibV12->dehaze_setting.pre_wet - 1.0f), 15, 0);
745 pProcRes->ProcResV12.gaus_h0 = DEHAZE_GAUS_H4;
746 pProcRes->ProcResV12.gaus_h1 = DEHAZE_GAUS_H1;
747 pProcRes->ProcResV12.gaus_h2 = DEHAZE_GAUS_H0;
748
749 // add for rk_aiq_uapi2_setMDehazeStrth
750 if (MDehazeStrth != DEHAZE_DEFAULT_LEVEL) {
751 pProcRes->ProcResV12.cfg_alpha = BIT_8_MAX;
752 unsigned int level_diff = MDehazeStrth > DEHAZE_DEFAULT_LEVEL
753 ? (MDehazeStrth - DEHAZE_DEFAULT_LEVEL)
754 : (DEHAZE_DEFAULT_LEVEL - MDehazeStrth);
755 bool level_up = MDehazeStrth > DEHAZE_DEFAULT_LEVEL;
756 if (level_up) {
757 pProcRes->ProcResV12.cfg_wt += level_diff * DEHAZE_DEFAULT_CFG_WT_STEP;
758 pProcRes->ProcResV12.cfg_air += level_diff * DEHAZE_DEFAULT_CFG_AIR_STEP;
759 pProcRes->ProcResV12.cfg_tmax += level_diff * DEHAZE_DEFAULT_CFG_TMAX_STEP;
760 } else {
761 pProcRes->ProcResV12.cfg_wt =
762 level_diff * DEHAZE_DEFAULT_CFG_WT_STEP > pProcRes->ProcResV12.cfg_wt
763 ? 0
764 : (pProcRes->ProcResV12.cfg_wt - level_diff * DEHAZE_DEFAULT_CFG_WT_STEP);
765 pProcRes->ProcResV12.cfg_air =
766 level_diff * DEHAZE_DEFAULT_CFG_AIR_STEP > pProcRes->ProcResV12.cfg_air
767 ? 0
768 : (pProcRes->ProcResV12.cfg_air - level_diff * DEHAZE_DEFAULT_CFG_AIR_STEP);
769 pProcRes->ProcResV12.cfg_tmax =
770 level_diff * DEHAZE_DEFAULT_CFG_TMAX_STEP > pProcRes->ProcResV12.cfg_tmax
771 ? 0
772 : (pProcRes->ProcResV12.cfg_tmax - level_diff * DEHAZE_DEFAULT_CFG_TMAX_STEP);
773 }
774 pProcRes->ProcResV12.cfg_wt = LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.cfg_wt, BIT_8_MAX);
775 pProcRes->ProcResV12.cfg_tmax =
776 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.cfg_tmax, BIT_10_MAX);
777 }
778
779 if (pProcRes->ProcResV12.dc_en && !(pProcRes->ProcResV12.enhance_en)) {
780 if (pProcRes->ProcResV12.cfg_alpha == 255) {
781 LOGD_ADEHAZE("%s cfg_alpha:1 CtrlValue:%f cfg_air:%f cfg_tmax:%f cfg_wt:%f\n", __func__,
782 CtrlValue, pProcRes->ProcResV12.cfg_air / 1.0f,
783 pProcRes->ProcResV12.cfg_tmax / 1023.0f,
784 pProcRes->ProcResV12.cfg_wt / 255.0f);
785 LOGD_ADEHAZE("%s cfg_alpha_reg:0x255 cfg_air:0x%x cfg_tmax:0x%x cfg_wt:0x%x\n",
786 __func__, pProcRes->ProcResV12.cfg_air, pProcRes->ProcResV12.cfg_tmax,
787 pProcRes->ProcResV12.cfg_wt);
788 } else if (pProcRes->ProcResV12.cfg_alpha == 0) {
789 LOGD_ADEHAZE(
790 "%s cfg_alpha:0 CtrlValue:%f air_max:%f air_min:%f tmax_base:%f wt_max:%f\n",
791 __func__, CtrlValue, pProcRes->ProcResV12.air_max / 1.0f,
792 pProcRes->ProcResV12.air_min / 1.0f, pProcRes->ProcResV12.tmax_base / 1.0f,
793 pProcRes->ProcResV12.wt_max / 255.0f);
794 LOGD_ADEHAZE(
795 "%s cfg_alpha_reg:0x0 air_max:0x%x air_min:0x%x tmax_base:0x%x wt_max:0x%x\n",
796 __func__, pProcRes->ProcResV12.air_max, pProcRes->ProcResV12.air_min,
797 pProcRes->ProcResV12.tmax_base, pProcRes->ProcResV12.wt_max);
798 }
799 }
800
801 LOG1_ADEHAZE("EIXT: %s \n", __func__);
802 }
803
GetEnhanceParamsV12(CalibDbDehazeV12_t * pCalibV12,RkAiqAdehazeProcResult_t * pProcRes,unsigned int MEnhanceStrth,unsigned int MEnhanceChromeStrth,float CtrlValue)804 void GetEnhanceParamsV12(CalibDbDehazeV12_t* pCalibV12, RkAiqAdehazeProcResult_t* pProcRes,
805 unsigned int MEnhanceStrth, unsigned int MEnhanceChromeStrth,
806 float CtrlValue) {
807 LOG1_ADEHAZE("ENTER: %s \n", __func__);
808 bool level_up = false;
809 unsigned int level_diff = 0;
810 int lo = 0, hi = 0;
811 float ratio = 1.0f;
812
813 if (CtrlValue < pCalibV12->enhance_setting.EnhanceData[0].CtrlData) {
814 lo = 0;
815 hi = 0;
816 ratio = 0.0f;
817 } else if (CtrlValue >=
818 pCalibV12->enhance_setting.EnhanceData[DHAZ_CTRL_DATA_STEP_MAX - 1].CtrlData) {
819 lo = DHAZ_CTRL_DATA_STEP_MAX - 1;
820 hi = DHAZ_CTRL_DATA_STEP_MAX - 1;
821 ratio = 0.0f;
822 } else {
823 for (int i = 0; i < DHAZ_CTRL_DATA_STEP_MAX - 1; i++) {
824 if (CtrlValue >= pCalibV12->enhance_setting.EnhanceData[i].CtrlData &&
825 CtrlValue < pCalibV12->enhance_setting.EnhanceData[i + 1].CtrlData) {
826 lo = i;
827 lo = i + 1;
828 ratio = (CtrlValue - pCalibV12->enhance_setting.EnhanceData[i].CtrlData) /
829 (pCalibV12->enhance_setting.EnhanceData[i + 1].CtrlData -
830 pCalibV12->enhance_setting.EnhanceData[i].CtrlData);
831 break;
832 } else
833 continue;
834 }
835 }
836 pProcRes->ProcResV12.enhance_value =
837 ClipValueV12(ratio * (pCalibV12->enhance_setting.EnhanceData[hi].enhance_value -
838 pCalibV12->enhance_setting.EnhanceData[lo].enhance_value) +
839 pCalibV12->enhance_setting.EnhanceData[lo].enhance_value,
840 4, 10);
841 pProcRes->ProcResV12.enhance_chroma =
842 ClipValueV12(ratio * (pCalibV12->enhance_setting.EnhanceData[hi].enhance_chroma -
843 pCalibV12->enhance_setting.EnhanceData[lo].enhance_chroma) +
844 pCalibV12->enhance_setting.EnhanceData[lo].enhance_chroma,
845 4, 10);
846 for (int j = 0; j < DHAZ_V12_ENHANCE_CRUVE_NUM; j++) {
847 pProcRes->ProcResV12.enh_curve[j] =
848 (unsigned short)(ratio * (pCalibV12->enhance_setting.EnhanceData[hi].enhance_curve[j] -
849 pCalibV12->enhance_setting.EnhanceData[lo].enhance_curve[j]) +
850 pCalibV12->enhance_setting.EnhanceData[lo].enhance_curve[j]);
851 }
852 for (int j = 0; j < DHAZ_V12_ENH_LUMA_NUM; j++) {
853 pProcRes->ProcResV12.enh_luma[j] =
854 ClipValueV12(ratio * (pCalibV12->enhance_setting.EnhanceData[hi].enh_luma[j] -
855 pCalibV12->enhance_setting.EnhanceData[lo].enh_luma[j]) +
856 pCalibV12->enhance_setting.EnhanceData[lo].enh_luma[j],
857 4, 6);
858 }
859
860 // dehaze v12 add
861 pProcRes->ProcResV12.color_deviate_en =
862 pCalibV12->enhance_setting.color_deviate_en ? FUNCTION_ENABLE : FUNCTION_DISABLE;
863 pProcRes->ProcResV12.enh_luma_en =
864 pCalibV12->enhance_setting.enh_luma_en ? FUNCTION_ENABLE : FUNCTION_DISABLE;
865
866 // add for rk_aiq_uapi2_setMEnhanceStrth
867 if (MEnhanceStrth != ENHANCE_DEFAULT_LEVEL) {
868 level_diff = MEnhanceStrth > ENHANCE_DEFAULT_LEVEL
869 ? (MEnhanceStrth - ENHANCE_DEFAULT_LEVEL)
870 : (ENHANCE_DEFAULT_LEVEL - MEnhanceStrth);
871 level_up = MEnhanceStrth > ENHANCE_DEFAULT_LEVEL;
872 if (pProcRes->ProcResV12.enh_luma_en) {
873 if (level_up) {
874 for (int j = 0; j < DHAZ_V12_ENH_LUMA_NUM; j++) {
875 pProcRes->ProcResV12.enh_luma[j] += level_diff * ENH_LUMA_DEFAULT_STEP;
876 pProcRes->ProcResV12.enh_luma[j] =
877 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enh_luma[j], BIT_10_MAX);
878 }
879 } else {
880 for (int j = 0; j < DHAZ_V12_ENH_LUMA_NUM; j++) {
881 pProcRes->ProcResV12.enh_luma[j] =
882 level_diff * ENH_LUMA_DEFAULT_STEP > pProcRes->ProcResV12.enh_luma[j]
883 ? 0
884 : (pProcRes->ProcResV12.enh_luma[j] -
885 level_diff * ENH_LUMA_DEFAULT_STEP);
886 pProcRes->ProcResV12.enh_luma[j] =
887 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enh_luma[j], BIT_10_MAX);
888 }
889 }
890 } else {
891 if (level_up) {
892 pProcRes->ProcResV12.enhance_value += level_diff * ENHANCE_VALUE_DEFAULT_STEP;
893 } else {
894 pProcRes->ProcResV12.enhance_value =
895 level_diff * ENHANCE_VALUE_DEFAULT_STEP > pProcRes->ProcResV12.enhance_value
896 ? 0
897 : (pProcRes->ProcResV12.enhance_value -
898 level_diff * ENHANCE_VALUE_DEFAULT_STEP);
899 }
900 pProcRes->ProcResV12.enhance_value =
901 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enhance_value, BIT_14_MAX);
902 }
903 }
904
905 // add for rk_aiq_uapi2_setMEnhanceChromeStrth
906 if (MEnhanceChromeStrth != ENHANCE_DEFAULT_LEVEL) {
907 level_diff = MEnhanceChromeStrth > ENHANCE_DEFAULT_LEVEL
908 ? (MEnhanceChromeStrth - ENHANCE_DEFAULT_LEVEL)
909 : (ENHANCE_DEFAULT_LEVEL - MEnhanceChromeStrth);
910 level_up = MEnhanceChromeStrth > ENHANCE_DEFAULT_LEVEL;
911 if (level_up) {
912 pProcRes->ProcResV12.enhance_chroma += level_diff * ENHANCE_VALUE_DEFAULT_STEP;
913 } else {
914 pProcRes->ProcResV12.enhance_chroma =
915 level_diff * ENHANCE_VALUE_DEFAULT_STEP > pProcRes->ProcResV12.enhance_chroma
916 ? 0
917 : (pProcRes->ProcResV12.enhance_chroma -
918 level_diff * ENHANCE_VALUE_DEFAULT_STEP);
919 }
920 pProcRes->ProcResV12.enhance_chroma =
921 LIMIT_VALUE_UNSIGNED(pProcRes->ProcResV12.enhance_chroma, BIT_14_MAX);
922 }
923
924 if (pProcRes->ProcResV12.dc_en && pProcRes->ProcResV12.enhance_en) {
925 LOGD_ADEHAZE("%s color_deviate_en:%d enh_luma_en:%d\n", __func__,
926 pProcRes->ProcResV12.color_deviate_en, pProcRes->ProcResV12.enh_luma_en);
927 LOGD_ADEHAZE("%s CtrlValue:%f enhance_value:%f enhance_chroma:%f\n", __func__, CtrlValue,
928 pProcRes->ProcResV12.enhance_value / 1024.0f,
929 pProcRes->ProcResV12.enhance_chroma / 1024.0f);
930 if (pProcRes->ProcResV12.enh_luma_en) {
931 LOGD_ADEHAZE(
932 "%s enh_luma[0~7]:%f %f %f %f %f %f %f %f\n", __func__,
933 pProcRes->ProcResV12.enh_luma[0] / 64.0f, pProcRes->ProcResV12.enh_luma[1] / 64.0f,
934 pProcRes->ProcResV12.enh_luma[2] / 64.0f, pProcRes->ProcResV12.enh_luma[3] / 64.0f,
935 pProcRes->ProcResV12.enh_luma[4] / 64.0f, pProcRes->ProcResV12.enh_luma[5] / 64.0f,
936 pProcRes->ProcResV12.enh_luma[6] / 64.0f, pProcRes->ProcResV12.enh_luma[7] / 64.0f);
937 }
938 LOGD_ADEHAZE("%s enhance_value_reg:0x%x enhance_chroma_reg:0x%x\n", __func__,
939 pProcRes->ProcResV12.enhance_value, pProcRes->ProcResV12.enhance_chroma);
940 }
941
942 LOG1_ADEHAZE("EIXT: %s \n", __func__);
943 }
944
GetHistParamsV12(CalibDbDehazeV12_t * pCalibV12,RkAiqAdehazeProcResult_t * pProcRes,dehaze_stats_v12_t * pStats,bool stats_true,float CtrlValue)945 void GetHistParamsV12(CalibDbDehazeV12_t* pCalibV12, RkAiqAdehazeProcResult_t* pProcRes,
946 dehaze_stats_v12_t* pStats, bool stats_true, float CtrlValue) {
947 LOG1_ADEHAZE("ENTER: %s \n", __func__);
948 int lo = 0, hi = 0;
949 float ratio = GetInterpRatioV12(pCalibV12->hist_setting.HistData.CtrlData, lo, hi, CtrlValue,
950 DHAZ_CTRL_DATA_STEP_MAX);
951
952 pProcRes->ProcResV12.hist_gratio =
953 ClipValueV12(ratio * (pCalibV12->hist_setting.HistData.hist_gratio[hi] -
954 pCalibV12->hist_setting.HistData.hist_gratio[lo]) +
955 pCalibV12->hist_setting.HistData.hist_gratio[lo],
956 5, 3);
957 pProcRes->ProcResV12.hist_th_off =
958 ClipValueV12(ratio * (pCalibV12->hist_setting.HistData.hist_th_off[hi] -
959 pCalibV12->hist_setting.HistData.hist_th_off[lo]) +
960 pCalibV12->hist_setting.HistData.hist_th_off[lo],
961 8, 0);
962 pProcRes->ProcResV12.hist_k =
963 ClipValueV12(ratio * (pCalibV12->hist_setting.HistData.hist_k[hi] -
964 pCalibV12->hist_setting.HistData.hist_k[lo]) +
965 pCalibV12->hist_setting.HistData.hist_k[lo],
966 3, 2);
967 pProcRes->ProcResV12.hist_min =
968 ClipValueV12(ratio * (pCalibV12->hist_setting.HistData.hist_min[hi] -
969 pCalibV12->hist_setting.HistData.hist_min[lo]) +
970 pCalibV12->hist_setting.HistData.hist_min[lo],
971 1, 8);
972 pProcRes->ProcResV12.cfg_gratio =
973 ClipValueV12(ratio * (pCalibV12->hist_setting.HistData.cfg_gratio[hi] -
974 pCalibV12->hist_setting.HistData.cfg_gratio[lo]) +
975 pCalibV12->hist_setting.HistData.cfg_gratio[lo],
976 5, 8);
977 pProcRes->ProcResV12.hist_scale =
978 ClipValueV12(ratio * (pCalibV12->hist_setting.HistData.hist_scale[hi] -
979 pCalibV12->hist_setting.HistData.hist_scale[lo]) +
980 pCalibV12->hist_setting.HistData.hist_scale[lo],
981 5, 8);
982 pProcRes->ProcResV12.hpara_en =
983 pCalibV12->hist_setting.hist_para_en ? FUNCTION_ENABLE : FUNCTION_DISABLE;
984 // clip hpara_en
985 pProcRes->ProcResV12.hpara_en = pProcRes->ProcResV12.dc_en
986 ? pProcRes->ProcResV12.hpara_en
987 : FUNCTION_ENABLE; // dc en �رգ�hpara���迪
988
989 XCamReturn ret = XCAM_RETURN_NO_ERROR;
990 if (pCalibV12->hist_setting.hist_wr.mode == HIST_WR_MANUAL) {
991 mManual_curve_t Curve;
992 DehazeHistWrTableInterpV12(&pCalibV12->hist_setting.hist_wr, &Curve, CtrlValue);
993 ret = TransferHistWr2Res(pProcRes, &Curve);
994
995 if (ret == XCAM_RETURN_NO_ERROR)
996 pProcRes->ProcResV12.soft_wr_en = FUNCTION_ENABLE;
997 else
998 pProcRes->ProcResV12.soft_wr_en = FUNCTION_DISABLE;
999 } else if (pCalibV12->hist_setting.hist_wr.mode == HIST_WR_AUTO) {
1000 pProcRes->ProcResV12.soft_wr_en = FUNCTION_DISABLE;
1001 } else if (pCalibV12->hist_setting.hist_wr.mode == HIST_WR_SEMIAUTO) {
1002 mhist_wr_semiauto_t semi_auto_curve;
1003 ratio = GetInterpRatioV12(pCalibV12->hist_setting.hist_wr.semiauto_curve.CtrlData, lo, hi,
1004 CtrlValue, DHAZ_CTRL_DATA_STEP_MAX);
1005 semi_auto_curve.clim0 = ratio * (pCalibV12->hist_setting.hist_wr.semiauto_curve.clim0[hi] -
1006 pCalibV12->hist_setting.hist_wr.semiauto_curve.clim0[lo]) +
1007 pCalibV12->hist_setting.hist_wr.semiauto_curve.clim0[lo];
1008 semi_auto_curve.clim1 = ratio * (pCalibV12->hist_setting.hist_wr.semiauto_curve.clim1[hi] -
1009 pCalibV12->hist_setting.hist_wr.semiauto_curve.clim1[lo]) +
1010 pCalibV12->hist_setting.hist_wr.semiauto_curve.clim1[lo];
1011 semi_auto_curve.dark_th =
1012 ratio * (pCalibV12->hist_setting.hist_wr.semiauto_curve.dark_th[hi] -
1013 pCalibV12->hist_setting.hist_wr.semiauto_curve.dark_th[lo]) +
1014 pCalibV12->hist_setting.hist_wr.semiauto_curve.dark_th[lo];
1015 ret = TransferHistWrSemiAtuos2Res(pProcRes, &semi_auto_curve, pStats, stats_true);
1016
1017 if (ret == XCAM_RETURN_NO_ERROR)
1018 pProcRes->ProcResV12.soft_wr_en = FUNCTION_ENABLE;
1019 else
1020 pProcRes->ProcResV12.soft_wr_en = FUNCTION_DISABLE;
1021 }
1022
1023 if (pProcRes->ProcResV12.hist_en) {
1024 LOGV_ADEHAZE(
1025 "%s: stats_true:%d dhaz_adp_air_base:%d dhaz_adp_wt:%d dhaz_adp_gratio:%d "
1026 "dhaz_adp_tmax:%d "
1027 "dhaz_pic_sumh:%d \n",
1028 __FUNCTION__, stats_true, pStats->dhaz_adp_air_base, pStats->dhaz_adp_wt,
1029 pStats->dhaz_adp_gratio, pStats->dhaz_adp_tmax, pStats->dhaz_pic_sumh);
1030 LOGV_ADEHAZE(
1031 "%s h_rgb_iir[0~1]:0x%x 0x%x 0x%x "
1032 "0x%x 0x%x 0x%x 0x%x\n",
1033 __func__, pStats->h_rgb_iir[0], pStats->h_rgb_iir[1], pStats->h_rgb_iir[2],
1034 pStats->h_rgb_iir[3], pStats->h_rgb_iir[4], pStats->h_rgb_iir[5], pStats->h_rgb_iir[6]);
1035 LOGD_ADEHAZE(
1036 "%s cfg_alpha:%f CtrlValue:%f hist_para_en:%d hist_gratio:%f hist_th_off:%f hist_k:%f "
1037 "hist_min:%f hist_scale:%f cfg_gratio:%f\n",
1038 __func__, pProcRes->ProcResV12.cfg_alpha / 255.0f, CtrlValue,
1039 pProcRes->ProcResV12.hpara_en, pProcRes->ProcResV12.hist_gratio / 255.0f,
1040 pProcRes->ProcResV12.hist_th_off / 1.0f, pProcRes->ProcResV12.hist_k / 4.0f,
1041 pProcRes->ProcResV12.hist_min / 256.0f, pProcRes->ProcResV12.hist_scale / 256.0f,
1042 pProcRes->ProcResV12.cfg_gratio / 256.0f);
1043 LOGD_ADEHAZE(
1044 "%s cfg_alpha_reg:0x%x hist_gratio_reg:0x%x hist_th_off_reg:0x%x hist_k_reg:0x%x "
1045 "hist_min_reg:0x%x hist_scale_reg:0x%x cfg_gratio_reg:0x%x\n",
1046 __func__, pProcRes->ProcResV12.cfg_alpha, pProcRes->ProcResV12.hist_gratio,
1047 pProcRes->ProcResV12.hist_th_off, pProcRes->ProcResV12.hist_k,
1048 pProcRes->ProcResV12.hist_min, pProcRes->ProcResV12.hist_scale,
1049 pProcRes->ProcResV12.cfg_gratio);
1050 LOGD_ADEHAZE("%s soft_wr_en:%d hist_wr.mode:%d\n", __func__,
1051 pProcRes->ProcResV12.soft_wr_en, pCalibV12->hist_setting.hist_wr.mode);
1052 if (pProcRes->ProcResV12.soft_wr_en) {
1053 LOGD_ADEHAZE(
1054 "%s hist_wr[0~9]:0x%x 0x%x 0x%x "
1055 "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1056 __func__, pProcRes->ProcResV12.hist_wr[0], pProcRes->ProcResV12.hist_wr[1],
1057 pProcRes->ProcResV12.hist_wr[2], pProcRes->ProcResV12.hist_wr[3],
1058 pProcRes->ProcResV12.hist_wr[4], pProcRes->ProcResV12.hist_wr[5],
1059 pProcRes->ProcResV12.hist_wr[6], pProcRes->ProcResV12.hist_wr[7],
1060 pProcRes->ProcResV12.hist_wr[8], pProcRes->ProcResV12.hist_wr[9]);
1061 }
1062 }
1063
1064 LOG1_ADEHAZE("EIXT: %s \n", __func__);
1065 }
1066
GetDehazeLocalGainSettingV12(RkAiqAdehazeProcResult_t * pProcRes,float * sigma)1067 XCamReturn GetDehazeLocalGainSettingV12(RkAiqAdehazeProcResult_t* pProcRes, float* sigma) {
1068 LOG1_ADEHAZE("ENTER: %s \n", __func__);
1069 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1070
1071 // get sigma_idx
1072 for (int i = 0; i < DHAZ_V12_SIGMA_IDX_NUM; i++)
1073 pProcRes->ProcResV12.sigma_idx[i] = (i + 1) * YNR_CURVE_STEP;
1074
1075 // get sigma_lut
1076 float sigam_total = 0.0f;
1077 for (int i = 0; i < DHAZ_V12_SIGMA_IDX_NUM; i++) sigam_total += sigma[i];
1078
1079 if (sigam_total < FLT_EPSILON) {
1080 for (int i = 0; i < DHAZ_V12_SIGMA_IDX_NUM; i++) pProcRes->ProcResV12.sigma_lut[i] = 0x200;
1081 } else {
1082 int tmp = 0;
1083 for (int i = 0; i < DHAZ_V12_SIGMA_LUT_NUM; i++) {
1084 tmp = LIMIT_VALUE(8.0f * sigma[i], BIT_10_MAX, BIT_MIN);
1085 pProcRes->ProcResV12.sigma_lut[i] = tmp;
1086 }
1087 }
1088
1089 LOGV_ADEHAZE("%s(%d) ynr sigma(0~5): %f %f %f %f %f %f\n", __func__, __LINE__, sigma[0],
1090 sigma[1], sigma[2], sigma[3], sigma[4], sigma[5]);
1091 LOGV_ADEHAZE("%s(%d) dehaze local gain IDX(0~5): 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", __func__,
1092 __LINE__, pProcRes->ProcResV12.sigma_idx[0], pProcRes->ProcResV12.sigma_idx[1],
1093 pProcRes->ProcResV12.sigma_idx[2], pProcRes->ProcResV12.sigma_idx[3],
1094 pProcRes->ProcResV12.sigma_idx[4], pProcRes->ProcResV12.sigma_idx[5]);
1095 LOGV_ADEHAZE("%s(%d) dehaze local gain LUT(0~5): 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", __func__,
1096 __LINE__, pProcRes->ProcResV12.sigma_lut[0], pProcRes->ProcResV12.sigma_lut[1],
1097 pProcRes->ProcResV12.sigma_lut[2], pProcRes->ProcResV12.sigma_lut[3],
1098 pProcRes->ProcResV12.sigma_lut[4], pProcRes->ProcResV12.sigma_lut[5]);
1099
1100 LOG1_ADEHAZE("EIXT: %s \n", __func__);
1101 return ret;
1102 }
1103
1104 #ifdef RKAIQ_ENABLE_CAMGROUP
AdehazeGetCurrDataGroup(AdehazeHandle_t * pAdehazeCtx,rk_aiq_singlecam_3a_result_t * pCamgrpParams)1105 XCamReturn AdehazeGetCurrDataGroup(AdehazeHandle_t* pAdehazeCtx,
1106 rk_aiq_singlecam_3a_result_t* pCamgrpParams) {
1107 LOG1_ADEHAZE("%s:enter!\n", __FUNCTION__);
1108 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1109
1110 // get ynr res
1111 for (int i = 0; i < YNR_V22_ISO_CURVE_POINT_NUM; i++)
1112 pAdehazeCtx->YnrProcResV22_sigma[i] = pCamgrpParams->aynr_sigma._aynr_sigma_v22[i];
1113
1114 if (pCamgrpParams) {
1115 // get EnvLv
1116 if (pCamgrpParams->aec._aePreRes) {
1117 RkAiqAlgoPreResAe* pAEPreRes =
1118 (RkAiqAlgoPreResAe*)pCamgrpParams->aec._aePreRes->map(pCamgrpParams->aec._aePreRes);
1119
1120 if (pAEPreRes) {
1121 switch (pAdehazeCtx->FrameNumber) {
1122 case LINEAR_NUM:
1123 pAdehazeCtx->CurrDataV12.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[0];
1124 break;
1125 case HDR_2X_NUM:
1126 pAdehazeCtx->CurrDataV12.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[1];
1127 break;
1128 case HDR_3X_NUM:
1129 pAdehazeCtx->CurrDataV12.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[1];
1130 break;
1131 default:
1132 LOGE_ADEHAZE("%s: Wrong frame number in HDR mode!!!\n", __FUNCTION__);
1133 break;
1134 }
1135
1136 // Normalize the current envLv for AEC
1137 pAdehazeCtx->CurrDataV12.EnvLv =
1138 (pAdehazeCtx->CurrDataV12.EnvLv - MIN_ENV_LV) / (MAX_ENV_LV - MIN_ENV_LV);
1139 pAdehazeCtx->CurrDataV12.EnvLv =
1140 LIMIT_VALUE(pAdehazeCtx->CurrDataV12.EnvLv, ENVLVMAX, ENVLVMIN);
1141 } else {
1142 pAdehazeCtx->CurrDataV12.EnvLv = ENVLVMIN;
1143 LOGW_ADEHAZE("%s:_aePreRes Res is NULL!\n", __FUNCTION__);
1144 }
1145 } else {
1146 pAdehazeCtx->CurrDataV12.EnvLv = ENVLVMIN;
1147 LOGW_ADEHAZE("%s:_aePreRes Res is NULL!\n", __FUNCTION__);
1148 }
1149
1150 // get iso
1151 if (pAdehazeCtx->FrameNumber == LINEAR_NUM) {
1152 pAdehazeCtx->CurrDataV12.ISO =
1153 pCamgrpParams->aec._effAecExpInfo.LinearExp.exp_real_params.analog_gain *
1154 pCamgrpParams->aec._effAecExpInfo.LinearExp.exp_real_params.digital_gain *
1155 pCamgrpParams->aec._effAecExpInfo.LinearExp.exp_real_params.isp_dgain * ISOMIN;
1156 // ablcV32_proc_res
1157 if (pCamgrpParams->ablc._blcConfig_v32) {
1158 if (pCamgrpParams->ablc._blcConfig_v32->blc_ob_enable) {
1159 if (pCamgrpParams->ablc._blcConfig_v32->isp_ob_predgain >= ISP_PREDGAIN_DEFAULT)
1160 pAdehazeCtx->CurrDataV12.ISO *=
1161 pCamgrpParams->ablc._blcConfig_v32->isp_ob_predgain;
1162 else
1163 LOGE_ADEHAZE("%s:BLC ob is ON, and predgain is %f!\n", __FUNCTION__,
1164 pCamgrpParams->ablc._blcConfig_v32->isp_ob_predgain);
1165 }
1166 } else {
1167 LOGW_ADEHAZE("%s: ABLC Res is NULL!\n", __FUNCTION__);
1168 }
1169 } else if (pAdehazeCtx->FrameNumber == HDR_2X_NUM ||
1170 pAdehazeCtx->FrameNumber == HDR_3X_NUM) {
1171 pAdehazeCtx->CurrDataV12.ISO =
1172 pCamgrpParams->aec._effAecExpInfo.HdrExp[1].exp_real_params.analog_gain *
1173 pCamgrpParams->aec._effAecExpInfo.HdrExp[1].exp_real_params.digital_gain *
1174 pCamgrpParams->aec._effAecExpInfo.HdrExp[1].exp_real_params.isp_dgain * ISOMIN;
1175 }
1176 } else {
1177 pAdehazeCtx->CurrDataV12.EnvLv = ENVLVMIN;
1178 pAdehazeCtx->CurrDataV12.ISO = ISOMIN;
1179 LOGW_ADEHAZE("%s: camgroupParmasArray[0] Res is NULL!\n", __FUNCTION__);
1180 }
1181
1182 LOG1_ADEHAZE("%s:exit!\n", __FUNCTION__);
1183 return ret;
1184 }
1185 #endif
AdehazeGetCurrData(AdehazeHandle_t * pAdehazeCtx,RkAiqAlgoProcAdhaz * pProcPara)1186 XCamReturn AdehazeGetCurrData(AdehazeHandle_t* pAdehazeCtx, RkAiqAlgoProcAdhaz* pProcPara) {
1187 LOG1_ADEHAZE("%s:enter!\n", __FUNCTION__);
1188 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1189
1190 // get ynr res
1191 for (int i = 0; i < YNR_V22_ISO_CURVE_POINT_NUM; i++)
1192 pAdehazeCtx->YnrProcResV22_sigma[i] = pProcPara->sigma_v22[i];
1193
1194 // get EnvLv
1195 XCamVideoBuffer* xCamAePreRes = pProcPara->com.u.proc.res_comb->ae_pre_res;
1196 if (xCamAePreRes) {
1197 RkAiqAlgoPreResAe* pAEPreRes = (RkAiqAlgoPreResAe*)xCamAePreRes->map(xCamAePreRes);
1198
1199 if (pAEPreRes) {
1200 switch (pAdehazeCtx->FrameNumber) {
1201 case LINEAR_NUM:
1202 pAdehazeCtx->CurrDataV12.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[0];
1203 break;
1204 case HDR_2X_NUM:
1205 pAdehazeCtx->CurrDataV12.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[1];
1206 break;
1207 case HDR_3X_NUM:
1208 pAdehazeCtx->CurrDataV12.EnvLv = pAEPreRes->ae_pre_res_rk.GlobalEnvLv[1];
1209 break;
1210 default:
1211 LOGE_ADEHAZE("%s: Wrong frame number in HDR mode!!!\n", __FUNCTION__);
1212 break;
1213 }
1214 // Normalize the current envLv for AEC
1215 pAdehazeCtx->CurrDataV12.EnvLv =
1216 (pAdehazeCtx->CurrDataV12.EnvLv - MIN_ENV_LV) / (MAX_ENV_LV - MIN_ENV_LV);
1217 pAdehazeCtx->CurrDataV12.EnvLv =
1218 LIMIT_VALUE(pAdehazeCtx->CurrDataV12.EnvLv, ENVLVMAX, ENVLVMIN);
1219
1220 } else {
1221 pAdehazeCtx->CurrDataV12.EnvLv = ENVLVMIN;
1222 LOGW_ADEHAZE("%s:PreResBuf is NULL!\n", __FUNCTION__);
1223 }
1224 } else {
1225 pAdehazeCtx->CurrDataV12.EnvLv = ENVLVMIN;
1226 LOGW_ADEHAZE("%s:PreResBuf is NULL!\n", __FUNCTION__);
1227 }
1228
1229 // get ISO
1230 if (pProcPara->com.u.proc.curExp) {
1231 if (pAdehazeCtx->FrameNumber == LINEAR_NUM) {
1232 pAdehazeCtx->CurrDataV12.ISO =
1233 pProcPara->com.u.proc.curExp->LinearExp.exp_real_params.analog_gain *
1234 pProcPara->com.u.proc.curExp->LinearExp.exp_real_params.digital_gain *
1235 pProcPara->com.u.proc.curExp->LinearExp.exp_real_params.isp_dgain * ISOMIN;
1236
1237 if (pProcPara->OBResV12.blc_ob_enable &&
1238 pProcPara->OBResV12.isp_ob_predgain < ISP_PREDGAIN_DEFAULT) {
1239 LOGE_ADEHAZE("%s: ob_enable ON , and ob_predgain[%f]<1.0f!!!\n", __FUNCTION__,
1240 pProcPara->OBResV12.isp_ob_predgain);
1241 }
1242 if (pProcPara->OBResV12.blc_ob_enable &&
1243 pProcPara->OBResV12.isp_ob_predgain >= ISP_PREDGAIN_DEFAULT)
1244 pAdehazeCtx->CurrDataV12.ISO *= pProcPara->OBResV12.isp_ob_predgain;
1245 } else if (pAdehazeCtx->FrameNumber == HDR_2X_NUM ||
1246 pAdehazeCtx->FrameNumber == HDR_3X_NUM) {
1247 pAdehazeCtx->CurrDataV12.ISO =
1248 pProcPara->com.u.proc.curExp->HdrExp[1].exp_real_params.analog_gain *
1249 pProcPara->com.u.proc.curExp->HdrExp[1].exp_real_params.digital_gain *
1250 pProcPara->com.u.proc.curExp->HdrExp[1].exp_real_params.isp_dgain * ISOMIN;
1251 }
1252 } else {
1253 pAdehazeCtx->CurrDataV12.ISO = ISOMIN;
1254 LOGW_ADEHAZE("%s:AE cur expo is NULL!\n", __FUNCTION__);
1255 }
1256
1257 LOG1_ADEHAZE("%s:exit!\n", __FUNCTION__);
1258 return ret;
1259 }
1260
AdehazeInit(AdehazeHandle_t ** pAdehazeCtx,CamCalibDbV2Context_t * pCalib)1261 XCamReturn AdehazeInit(AdehazeHandle_t** pAdehazeCtx, CamCalibDbV2Context_t* pCalib) {
1262 LOG1_ADEHAZE("ENTER: %s \n", __func__);
1263 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1264 AdehazeHandle_t* handle = (AdehazeHandle_t*)calloc(1, sizeof(AdehazeHandle_t));
1265
1266 CalibDbV2_dehaze_v12_t* calibv2_adehaze_calib_V12 =
1267 (CalibDbV2_dehaze_v12_t*)(CALIBDBV2_GET_MODULE_PTR(pCalib, adehaze_calib));
1268 memcpy(&handle->AdehazeAtrrV12.stAuto, calibv2_adehaze_calib_V12,
1269 sizeof(CalibDbV2_dehaze_v12_t));
1270 handle->AdehazeAtrrV12.mode = DEHAZE_API_AUTO;
1271 handle->AdehazeAtrrV12.Info.MDehazeStrth = DEHAZE_DEFAULT_LEVEL;
1272 handle->AdehazeAtrrV12.Info.MEnhanceStrth = ENHANCE_DEFAULT_LEVEL;
1273 handle->AdehazeAtrrV12.Info.MEnhanceChromeStrth = ENHANCE_DEFAULT_LEVEL;
1274 handle->ifReCalcStAuto = true;
1275 handle->ifReCalcStManual = false;
1276 handle->isCapture = false;
1277 handle->is_multi_isp_mode = false;
1278
1279 *pAdehazeCtx = handle;
1280 LOG1_ADEHAZE("EXIT: %s \n", __func__);
1281 return (ret);
1282 }
1283
AdehazeRelease(AdehazeHandle_t * pAdehazeCtx)1284 XCamReturn AdehazeRelease(AdehazeHandle_t* pAdehazeCtx) {
1285 LOG1_ADEHAZE("ENTER: %s \n", __func__);
1286 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1287 if (pAdehazeCtx) free(pAdehazeCtx);
1288 LOG1_ADEHAZE("EXIT: %s \n", __func__);
1289 return (ret);
1290 }
1291
AdehazeProcess(AdehazeHandle_t * pAdehazeCtx,dehaze_stats_v12_t * pStats,bool stats_true,RkAiqAdehazeProcResult_t * pAdehzeProcRes)1292 XCamReturn AdehazeProcess(AdehazeHandle_t* pAdehazeCtx, dehaze_stats_v12_t* pStats, bool stats_true,
1293 RkAiqAdehazeProcResult_t* pAdehzeProcRes) {
1294 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1295 LOG1_ADEHAZE("ENTER: %s \n", __func__);
1296 LOGD_ADEHAZE(" %s: Dehaze module en:%d Dehaze en:%d, Enhance en:%d, Hist en:%d\n", __func__,
1297 pAdehzeProcRes->enable,
1298 (pAdehzeProcRes->ProcResV12.dc_en & FUNCTION_ENABLE) &&
1299 (!(pAdehzeProcRes->ProcResV12.enhance_en & FUNCTION_ENABLE)),
1300 (pAdehzeProcRes->ProcResV12.dc_en & FUNCTION_ENABLE) &&
1301 (pAdehzeProcRes->ProcResV12.enhance_en & FUNCTION_ENABLE),
1302 pAdehzeProcRes->ProcResV12.hist_en);
1303
1304 if (pAdehazeCtx->AdehazeAtrrV12.mode == DEHAZE_API_AUTO) {
1305 // cfg setting
1306 pAdehzeProcRes->ProcResV12.cfg_alpha =
1307 LIMIT_VALUE(SHIFT8BIT(pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.cfg_alpha),
1308 BIT_8_MAX, BIT_MIN);
1309
1310 float CtrlValue = pAdehazeCtx->CurrDataV12.EnvLv;
1311 if (pAdehazeCtx->CurrDataV12.CtrlDataType == CTRLDATATYPE_ISO)
1312 CtrlValue = pAdehazeCtx->CurrDataV12.ISO;
1313
1314 // dehaze setting
1315 if (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.dehaze_setting.en ||
1316 pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.enhance_setting.en ||
1317 (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.hist_setting.en &&
1318 !pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.hist_setting.hist_para_en))
1319 GetDehazeParamsV12(&pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara, pAdehzeProcRes,
1320 pAdehazeCtx->width, pAdehazeCtx->height,
1321 pAdehazeCtx->AdehazeAtrrV12.Info.MDehazeStrth, CtrlValue);
1322
1323 // fix register
1324 pAdehzeProcRes->ProcResV12.round_en = FUNCTION_ENABLE;
1325
1326 // enhance setting
1327 if (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.enhance_setting.en)
1328 GetEnhanceParamsV12(&pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara,
1329 pAdehzeProcRes, pAdehazeCtx->AdehazeAtrrV12.Info.MEnhanceStrth,
1330 pAdehazeCtx->AdehazeAtrrV12.Info.MEnhanceChromeStrth, CtrlValue);
1331
1332 // hist setting
1333 if (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.hist_setting.en)
1334 GetHistParamsV12(&pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara, pAdehzeProcRes,
1335 pStats, stats_true, CtrlValue);
1336 } else if (pAdehazeCtx->AdehazeAtrrV12.mode == DEHAZE_API_MANUAL) {
1337 // cfg setting
1338 pAdehzeProcRes->ProcResV12.cfg_alpha = LIMIT_VALUE(
1339 SHIFT8BIT(pAdehazeCtx->AdehazeAtrrV12.stManual.cfg_alpha), BIT_8_MAX, BIT_MIN);
1340
1341 // fix register
1342 pAdehzeProcRes->ProcResV12.round_en = FUNCTION_ENABLE;
1343
1344 // dehaze setting
1345 if (pAdehazeCtx->AdehazeAtrrV12.stManual.dehaze_setting.en ||
1346 pAdehazeCtx->AdehazeAtrrV12.stManual.enhance_setting.en ||
1347 (pAdehazeCtx->AdehazeAtrrV12.stManual.hist_setting.en &&
1348 !pAdehazeCtx->AdehazeAtrrV12.stManual.hist_setting.hist_para_en))
1349 stManuGetDehazeParamsV12(&pAdehazeCtx->AdehazeAtrrV12.stManual, pAdehzeProcRes,
1350 pAdehazeCtx->width, pAdehazeCtx->height,
1351 pAdehazeCtx->AdehazeAtrrV12.Info.MDehazeStrth);
1352
1353 // enhance setting
1354 if (pAdehazeCtx->AdehazeAtrrV12.stManual.enhance_setting.en)
1355 stManuGetEnhanceParamsV12(&pAdehazeCtx->AdehazeAtrrV12.stManual, pAdehzeProcRes,
1356 pAdehazeCtx->AdehazeAtrrV12.Info.MEnhanceStrth,
1357 pAdehazeCtx->AdehazeAtrrV12.Info.MEnhanceChromeStrth);
1358
1359 // hist setting
1360 if (pAdehazeCtx->AdehazeAtrrV12.stManual.hist_setting.en)
1361 stManuGetHistParamsV12(&pAdehazeCtx->AdehazeAtrrV12.stManual, pAdehzeProcRes,
1362 pStats, stats_true);
1363 } else
1364 LOGE_ADEHAZE("%s:Wrong Adehaze API mode!!! \n", __func__);
1365
1366 // get local gain setting
1367 ret = GetDehazeLocalGainSettingV12(pAdehzeProcRes, pAdehazeCtx->YnrProcResV22_sigma);
1368
1369 // store pre data
1370 pAdehazeCtx->PreDataV12.EnvLv = pAdehazeCtx->CurrDataV12.EnvLv;
1371 pAdehazeCtx->PreDataV12.ISO = pAdehazeCtx->CurrDataV12.ISO;
1372 pAdehazeCtx->PreDataV12.ApiMode = pAdehazeCtx->CurrDataV12.ApiMode;
1373
1374 LOG1_ADEHAZE("EXIT: %s \n", __func__);
1375 return ret;
1376 }
1377
AdehazeByPassProcessing(AdehazeHandle_t * pAdehazeCtx)1378 bool AdehazeByPassProcessing(AdehazeHandle_t* pAdehazeCtx) {
1379 LOG1_ADEHAZE("ENTER: %s \n", __func__);
1380 bool byPassProc = true;
1381
1382 pAdehazeCtx->CurrDataV12.CtrlDataType =
1383 pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.CtrlDataType;
1384
1385 if (pAdehazeCtx->FrameID <= INIT_CALC_PARAMS_NUM)
1386 byPassProc = false;
1387 else if (pAdehazeCtx->AdehazeAtrrV12.mode != pAdehazeCtx->PreDataV12.ApiMode)
1388 byPassProc = false;
1389 else if (pAdehazeCtx->AdehazeAtrrV12.mode == DEHAZE_API_MANUAL) {
1390 byPassProc = !pAdehazeCtx->ifReCalcStManual;
1391 } else if (pAdehazeCtx->AdehazeAtrrV12.mode == DEHAZE_API_AUTO) {
1392 float diff = 0.0f;
1393 if (pAdehazeCtx->CurrDataV12.CtrlDataType == CTRLDATATYPE_ENVLV) {
1394 diff = pAdehazeCtx->PreDataV12.EnvLv - pAdehazeCtx->CurrDataV12.EnvLv;
1395 if (pAdehazeCtx->PreDataV12.EnvLv <= FLT_EPSILON) {
1396 diff = pAdehazeCtx->CurrDataV12.EnvLv;
1397 if (diff <= FLT_EPSILON)
1398 byPassProc = true;
1399 else
1400 byPassProc = false;
1401 } else {
1402 diff /= pAdehazeCtx->PreDataV12.EnvLv;
1403 if (diff >= pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.ByPassThr ||
1404 diff <= -pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.ByPassThr)
1405 byPassProc = false;
1406 else
1407 byPassProc = true;
1408 }
1409 } else if (pAdehazeCtx->CurrDataV12.CtrlDataType == CTRLDATATYPE_ISO) {
1410 diff = pAdehazeCtx->PreDataV12.ISO - pAdehazeCtx->CurrDataV12.ISO;
1411 diff /= pAdehazeCtx->PreDataV12.ISO;
1412 if (diff >= pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.ByPassThr ||
1413 diff <= -pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.ByPassThr)
1414 byPassProc = false;
1415 else
1416 byPassProc = true;
1417 }
1418 byPassProc = byPassProc && !pAdehazeCtx->ifReCalcStAuto;
1419 }
1420
1421 LOGD_ADEHAZE(
1422 "%s:FrameID:%d DehazeApiMode:%d ifReCalcStAuto:%d ifReCalcStManual:%d CtrlDataType:%d "
1423 "EnvLv:%f ISO:%f byPassProc:%d\n",
1424 __func__, pAdehazeCtx->FrameID, pAdehazeCtx->AdehazeAtrrV12.mode,
1425 pAdehazeCtx->ifReCalcStAuto, pAdehazeCtx->ifReCalcStManual,
1426 pAdehazeCtx->CurrDataV12.CtrlDataType, pAdehazeCtx->CurrDataV12.EnvLv,
1427 pAdehazeCtx->CurrDataV12.ISO, byPassProc);
1428
1429 LOG1_ADEHAZE("EXIT: %s \n", __func__);
1430 return byPassProc;
1431 }
1432
1433 /******************************************************************************
1434 * DehazeEnableSetting()
1435 *
1436 *****************************************************************************/
DehazeEnableSetting(AdehazeHandle_t * pAdehazeCtx,RkAiqAdehazeProcResult_t * pAdehzeProcRes)1437 bool DehazeEnableSetting(AdehazeHandle_t* pAdehazeCtx, RkAiqAdehazeProcResult_t* pAdehzeProcRes) {
1438 LOG1_ADEHAZE("%s:enter!\n", __FUNCTION__);
1439
1440 if (pAdehazeCtx->AdehazeAtrrV12.mode == DEHAZE_API_AUTO) {
1441 pAdehzeProcRes->enable = pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.Enable;
1442
1443 if (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.Enable) {
1444 if (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.dehaze_setting.en &&
1445 pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.enhance_setting.en) {
1446 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_ENABLE;
1447 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_ENABLE;
1448 } else if (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.dehaze_setting.en &&
1449 !pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.enhance_setting.en) {
1450 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_ENABLE;
1451 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_DISABLE;
1452 } else if (!pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.dehaze_setting.en &&
1453 pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.enhance_setting.en) {
1454 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_ENABLE;
1455 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_ENABLE;
1456 } else {
1457 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_DISABLE;
1458 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_DISABLE;
1459 }
1460
1461 if (pAdehazeCtx->AdehazeAtrrV12.stAuto.DehazeTuningPara.hist_setting.en)
1462 pAdehzeProcRes->ProcResV12.hist_en = FUNCTION_ENABLE;
1463 else
1464 pAdehzeProcRes->ProcResV12.hist_en = FUNCTION_DISABLE;
1465 }
1466 } else if (pAdehazeCtx->AdehazeAtrrV12.mode == DEHAZE_API_MANUAL) {
1467 pAdehzeProcRes->enable = pAdehazeCtx->AdehazeAtrrV12.stManual.Enable;
1468
1469 if (pAdehazeCtx->AdehazeAtrrV12.stManual.Enable) {
1470 if (pAdehazeCtx->AdehazeAtrrV12.stManual.dehaze_setting.en &&
1471 pAdehazeCtx->AdehazeAtrrV12.stManual.enhance_setting.en) {
1472 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_ENABLE;
1473 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_ENABLE;
1474 } else if (pAdehazeCtx->AdehazeAtrrV12.stManual.dehaze_setting.en &&
1475 !pAdehazeCtx->AdehazeAtrrV12.stManual.enhance_setting.en) {
1476 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_ENABLE;
1477 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_DISABLE;
1478 } else if (!pAdehazeCtx->AdehazeAtrrV12.stManual.dehaze_setting.en &&
1479 pAdehazeCtx->AdehazeAtrrV12.stManual.enhance_setting.en) {
1480 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_ENABLE;
1481 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_ENABLE;
1482 } else {
1483 pAdehzeProcRes->ProcResV12.dc_en = FUNCTION_DISABLE;
1484 pAdehzeProcRes->ProcResV12.enhance_en = FUNCTION_DISABLE;
1485 }
1486
1487 if (pAdehazeCtx->AdehazeAtrrV12.stManual.hist_setting.en)
1488 pAdehzeProcRes->ProcResV12.hist_en = FUNCTION_ENABLE;
1489 else
1490 pAdehzeProcRes->ProcResV12.hist_en = FUNCTION_DISABLE;
1491 }
1492 } else {
1493 LOGE_ADEHAZE("%s: Dehaze api in WRONG MODE!!!, dehaze by pass!!!\n", __FUNCTION__);
1494 pAdehzeProcRes->enable = false;
1495 }
1496
1497 return pAdehzeProcRes->enable;
1498 LOG1_ADEHAZE("%s:exit!\n", __FUNCTION__);
1499 }
1500