1 /*
2 * Copyright (c) 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 "RkAiqResourceTranslatorV32.h"
17
18 #include "common/rkisp32-config.h"
19 #include "isp20/Isp20Evts.h"
20 #include "isp20/Isp20StatsBuffer.h"
21
22 //#define AE_STATS_DEBUG
23 #define MAX_10BITS (1 << 10) - 1
24 #define MAX_12BITS (1 << 12) - 1
25 #define MAX_29BITS (1 << 29) - 1
26 #define MAX_32BITS 0xffffffff
27
28 namespace RkCam {
29
RkAiqResourceTranslatorV32()30 RkAiqResourceTranslatorV32::RkAiqResourceTranslatorV32() {}
31
translateAecStats(const SmartPtr<VideoBuffer> & from,SmartPtr<RkAiqAecStatsProxy> & to)32 XCamReturn RkAiqResourceTranslatorV32::translateAecStats(const SmartPtr<VideoBuffer>& from,
33 SmartPtr<RkAiqAecStatsProxy>& to) {
34 XCamReturn ret = XCAM_RETURN_NO_ERROR;
35
36 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
37 // 0) blc awb cfg
38
39 struct isp32_isp_meas_cfg* isp_params = &_ispParams.meas;
40 uint8_t AeSwapMode, AeSelMode, AfUseAeHW;
41 AeSwapMode = isp_params->rawae0.rawae_sel;
42 AeSelMode = isp_params->rawae3.rawae_sel;
43 AfUseAeHW = isp_params->rawaf.ae_mode;
44 unsigned int meas_type = 0;
45
46 // ae_stats = (ae_ori_stats_u12/10 - ob_offset_u9 - bls1_val_u12) * awb1_gain_u16 * range_ratio
47 struct isp32_bls_cfg* bls_cfg = &_ispParams.bls_cfg;
48 struct isp32_awb_gain_cfg* awb_gain_cfg = &_ispParams.awb_gain_cfg;
49 struct isp2x_bls_fixed_val bls1_val; // bls1_val = blc1_ori_val * awb * range_ratio
50
51 u16 isp_ob_offset_rb, isp_ob_offset_g, isp_ob_predgain;
52 u16 awb1_gain_r, awb1_gain_gr, awb1_gain_gb, awb1_gain_b;
53 u32 pixel_num = 0;
54 u8 rawhist_mode = 0;
55 u8 index0, index1, index2 = 0;
56 bool is_hdr = (getWorkingMode() > 0) ? true : false;
57
58 isp_ob_offset_rb = MAX(bls_cfg->isp_ob_offset >> 2, 0);
59 isp_ob_offset_g = bls_cfg->isp_ob_offset;
60 isp_ob_predgain = MAX(bls_cfg->isp_ob_predgain >> 8, 1);
61
62 if (bls_cfg->bls1_en && !is_hdr) {
63 bls1_val.r = (bls_cfg->bls1_val.r / isp_ob_predgain) >> 2;
64 bls1_val.gr = bls_cfg->bls1_val.gr / isp_ob_predgain;
65 bls1_val.gb = bls_cfg->bls1_val.gb / isp_ob_predgain;
66 bls1_val.b = (bls_cfg->bls1_val.b / isp_ob_predgain) >> 2;
67 } else {
68 bls1_val.r = 0;
69 bls1_val.gr = 0;
70 bls1_val.gb = 0;
71 bls1_val.b = 0;
72 }
73 //awb1_gain have adapted to the range of bls1_lvl
74 awb1_gain_r = MAX(256, awb_gain_cfg->awb1_gain_r);
75 awb1_gain_gr = MAX(256, awb_gain_cfg->awb1_gain_gr);
76 awb1_gain_gb = MAX(256, awb_gain_cfg->awb1_gain_gb);
77 awb1_gain_b = MAX(256, awb_gain_cfg->awb1_gain_b);
78
79 #ifdef AE_STATS_DEBUG
80 LOGE("bls1[%d-%d-%d-%d]", bls1_val.r, bls1_val.gr, bls1_val.gb, bls1_val.b);
81 LOGE("isp_ob_offset_rb, isp_ob_offset_g, isp_ob_predgain [%d-%d-%d]",
82 isp_ob_offset_rb, isp_ob_offset_g, isp_ob_predgain);
83 LOGE("awb1_gain[%d-%d-%d-%d]", awb1_gain_r, awb1_gain_gr, awb1_gain_gb, awb1_gain_b);
84 #endif
85
86 u16 bls_r, bls_g, bls_b;
87 bls_r = ((isp_ob_offset_rb + bls1_val.r) * awb1_gain_r + 128) / 256;
88 bls_g = ((isp_ob_offset_g + bls1_val.gr) * awb1_gain_gr + 128) / 256;
89 bls_b = ((isp_ob_offset_rb + bls1_val.b) * awb1_gain_b + 128) / 256;
90
91 #endif
92
93 #if defined(ISP_HW_V32)
94
95 Isp20StatsBuffer* buf = from.get_cast_ptr<Isp20StatsBuffer>();
96 struct rkisp32_isp_stat_buffer* stats;
97 SmartPtr<RkAiqAecStats> statsInt = to->data();
98
99 stats = (struct rkisp32_isp_stat_buffer*)(buf->get_v4l2_userptr());
100 if (stats == NULL) {
101 LOGE("fail to get stats ,ignore\n");
102 return XCAM_RETURN_BYPASS;
103 }
104 LOGI_ANALYZER("camId: %d, stats: frame_id: %d, meas_type; 0x%x", mCamPhyId, stats->frame_id,
105 stats->meas_type);
106
107 SmartPtr<RkAiqIrisParamsProxy> irisParams = buf->get_iris_params();
108
109 // ae stats v3.2
110 statsInt->frame_id = stats->frame_id;
111
112 switch (AeSwapMode) {
113 case AEC_RAWSWAP_MODE_S_LITE:
114 meas_type = ((stats->meas_type >> 7) & (0x01)) & ((stats->meas_type >> 11) & (0x01));
115 index0 = 0;
116 index1 = 1;
117 index2 = 2;
118 rawhist_mode = isp_params->rawhist0.mode;
119 break;
120 case AEC_RAWSWAP_MODE_M_LITE:
121 meas_type = ((stats->meas_type >> 8) & (0x01)) & ((stats->meas_type >> 12) & (0x01));
122 index0 = 1;
123 index1 = 0;
124 index2 = 2;
125 rawhist_mode = isp_params->rawhist1.mode;
126 break;
127 default:
128 LOGE("wrong AeSwapMode=%d\n", AeSwapMode);
129 return XCAM_RETURN_ERROR_PARAM;
130 break;
131 }
132
133 statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;
134 if (!statsInt->aec_stats_valid) return XCAM_RETURN_BYPASS;
135
136 //AE-LITE (RAWAE0)
137 if(is_hdr || AeSwapMode == AEC_RAWSWAP_MODE_S_LITE) {
138 for (int i = 0; i < ISP3X_RAWAELITE_MEAN_NUM; i++) {
139
140 statsInt->aec_stats.ae_data.chn[index0].rawae_lite.channelr_xy[i] = CLIP(
141 (int)(stats->params.rawae0.data[i].channelr_xy * awb1_gain_r / 256 - bls_r), 0, MAX_10BITS);
142 statsInt->aec_stats.ae_data.chn[index0].rawae_lite.channelg_xy[i] = CLIP(
143 (int)(stats->params.rawae0.data[i].channelg_xy * awb1_gain_gr / 256 - bls_g), 0, MAX_12BITS);
144 statsInt->aec_stats.ae_data.chn[index0].rawae_lite.channelb_xy[i] = CLIP(
145 (int)(stats->params.rawae0.data[i].channelb_xy * awb1_gain_b / 256 - bls_b), 0, MAX_10BITS);
146 }
147 }
148
149 //AE-BIG (RAWAE1)
150 if(is_hdr || AeSwapMode == AEC_RAWSWAP_MODE_M_LITE) {
151
152 for (int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
153
154 statsInt->aec_stats.ae_data.chn[index1].rawae_big.channelr_xy[i] = CLIP(
155 (int)(stats->params.rawae1_0.data[i].channelr_xy * awb1_gain_r / 256 - bls_r), 0, MAX_10BITS);
156 statsInt->aec_stats.ae_data.chn[index1].rawae_big.channelg_xy[i] = CLIP(
157 (int)(stats->params.rawae1_0.data[i].channelg_xy * awb1_gain_gr / 256 - bls_g), 0, MAX_12BITS);
158 statsInt->aec_stats.ae_data.chn[index1].rawae_big.channelb_xy[i] = CLIP(
159 (int)(stats->params.rawae1_0.data[i].channelb_xy * awb1_gain_b / 256 - bls_b), 0, MAX_10BITS);
160 }
161
162 for (int i = 0; i < ISP3X_RAWAEBIG_SUBWIN_NUM; i++) {
163 pixel_num = isp_params->rawae1.subwin[i].h_size * isp_params->rawae1.subwin[i].v_size;
164 statsInt->aec_stats.ae_data.chn[index1].rawae_big.wndx_sumr[i] = CLIP(
165 (s64)((u64)stats->params.rawae1_1.sumr[i] * awb1_gain_r / 256 - (pixel_num >> 2) * bls_r), 0, MAX_29BITS);
166 statsInt->aec_stats.ae_data.chn[index1].rawae_big.wndx_sumg[i] = CLIP(
167 (s64)((u64)stats->params.rawae1_1.sumg[i] * awb1_gain_gr / 256 - (pixel_num >> 1) * bls_g), 0, MAX_32BITS);
168 statsInt->aec_stats.ae_data.chn[index1].rawae_big.wndx_sumb[i] = CLIP(
169 (s64)((u64)stats->params.rawae1_1.sumb[i] * awb1_gain_b / 256 - (pixel_num >> 2) * bls_b), 0, MAX_29BITS);
170 }
171 }
172
173 //HIST 0/1
174
175 if (bls_cfg->bls1_en && !is_hdr) {
176
177 memset(statsInt->aec_stats.ae_data.chn[index0].rawhist_lite.bins, 0,
178 ISP3X_HIST_BIN_N_MAX * sizeof(u32));
179 memset(statsInt->aec_stats.ae_data.chn[index1].rawhist_big.bins, 0,
180 ISP3X_HIST_BIN_N_MAX * sizeof(u32));
181
182 s16 bls1, bls;
183 u16 ob, awb1_gain, div_part, round_part;
184 int tmp;
185
186 switch (rawhist_mode) {
187 case 2:
188 ob = isp_ob_offset_rb >> 2;
189 bls1 = bls1_val.r >> 2;
190 awb1_gain = awb1_gain_r;
191 bls = (ob + bls1) * awb1_gain;
192 div_part = 256;
193 round_part = 128;
194 break;
195 case 3:
196 ob = isp_ob_offset_g >> 4;
197 bls1 = bls1_val.gr >> 4;
198 awb1_gain = awb1_gain_gr;
199 bls = (ob + bls1) * awb1_gain;
200 div_part = 256;
201 round_part = 128;
202 break;
203 case 4:
204 ob = isp_ob_offset_rb >> 2;
205 bls1 = bls1_val.b >> 2;
206 awb1_gain = awb1_gain_b;
207 bls = (ob + bls1) * awb1_gain;
208 div_part = 256;
209 round_part = 128;
210 break;
211 case 5:
212 default:
213 ob = (u16)((isp_ob_offset_g >> 4) * 587 + (isp_ob_offset_rb >> 2) * 299 + (isp_ob_offset_rb >> 2) * 114 + 500) / 1000;
214 bls1 = (s16)((bls1_val.gr >> 4) * 587 + (bls1_val.r >> 2) * 299 + (bls1_val.b >> 2) * 114 + 500) / 1000;
215 awb1_gain = 100;
216 bls = (ob + bls1) * awb1_gain;
217 div_part = 7655 / awb1_gain_r + 15027 / awb1_gain_gr + 2919 / awb1_gain_b;
218 round_part = div_part / 2;
219 break;
220 }
221 uint64_t SumHistPix = 0;
222 float HistMean = 0.0f;
223
224 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
225
226
227 tmp = (i - ob - bls1 > 0) ? (i * awb1_gain - bls + round_part) / div_part : 0;
228 tmp = (tmp > ISP3X_HIST_BIN_N_MAX - 1) ? (ISP3X_HIST_BIN_N_MAX - 1) : tmp;
229
230 statsInt->aec_stats.ae_data.chn[index0].rawhist_lite.bins[tmp] +=
231 stats->params.rawhist0.hist_bin[i];
232 statsInt->aec_stats.ae_data.chn[index1].rawhist_big.bins[tmp] +=
233 stats->params.rawhist1.hist_bin[i];
234
235 SumHistPix += stats->params.rawhist1.hist_bin[i];
236 }
237
238 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
239 HistMean += (float)(stats->params.rawhist1.hist_bin[i] * (i + 1)) / (float)SumHistPix ;
240 }
241 // NOTE: tmp use yuvae mean
242 statsInt->aec_stats.ae_data.yuvae.mean[index1] = (uint8_t)HistMean;
243
244 } else {
245
246 if(is_hdr || AeSwapMode == AEC_RAWSWAP_MODE_S_LITE) {
247 memcpy(statsInt->aec_stats.ae_data.chn[index0].rawhist_lite.bins,
248 stats->params.rawhist0.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
249
250 uint64_t SumHistPix = 0;
251 float HistMean = 0.0f;
252
253 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++)
254 SumHistPix += stats->params.rawhist0.hist_bin[i];
255
256 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
257 HistMean += (float)(stats->params.rawhist0.hist_bin[i] * (i + 1)) / (float)SumHistPix;
258 }
259
260 // NOTE: tmp use yuvae mean
261 statsInt->aec_stats.ae_data.yuvae.mean[index0] = (uint8_t)HistMean;
262 }
263
264 if(is_hdr || AeSwapMode == AEC_RAWSWAP_MODE_M_LITE) {
265 memcpy(statsInt->aec_stats.ae_data.chn[index1].rawhist_big.bins,
266 stats->params.rawhist1.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
267
268 uint64_t SumHistPix = 0;
269 float HistMean = 0.0f;
270
271 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++)
272 SumHistPix += stats->params.rawhist1.hist_bin[i];
273
274 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
275 HistMean += (float)(stats->params.rawhist1.hist_bin[i] * (i + 1)) / (float)SumHistPix;
276 }
277
278 // NOTE: tmp use yuvae mean
279 statsInt->aec_stats.ae_data.yuvae.mean[index1] = (uint8_t)HistMean;
280 }
281 }
282
283
284 //AE-BIG (RAWAE3)
285
286 statsInt->af_prior = (AfUseAeHW == 0) ? false : true;
287
288 if (!AfUseAeHW) {
289 switch (AeSelMode) {
290 case AEC_RAWSEL_MODE_CHN_0:
291 case AEC_RAWSEL_MODE_CHN_1:
292
293 for (int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
294 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelr_xy[i] = CLIP(
295 (int)(stats->params.rawae3_0.data[i].channelr_xy * awb1_gain_r / 256 - bls_r), 0, MAX_10BITS);
296 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelg_xy[i] = CLIP(
297 (int)(stats->params.rawae3_0.data[i].channelg_xy * awb1_gain_gr / 256 - bls_g), 0, MAX_12BITS);
298 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelb_xy[i] = CLIP(
299 (int)(stats->params.rawae3_0.data[i].channelb_xy * awb1_gain_b / 256 - bls_b), 0, MAX_10BITS);
300 }
301 for (int i = 0; i < ISP3X_RAWAEBIG_SUBWIN_NUM; i++) {
302
303 pixel_num = isp_params->rawae3.subwin[i].h_size * isp_params->rawae3.subwin[i].v_size;
304 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumr[i] = CLIP(
305 (s64)((u64)stats->params.rawae3_1.sumr[i] * awb1_gain_r / 256 - (pixel_num >> 2) * bls_r), 0, MAX_29BITS);
306 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumg[i] = CLIP(
307 (s64)((u64)stats->params.rawae3_1.sumg[i] * awb1_gain_gr / 256 - (pixel_num >> 1) * bls_g), 0, MAX_32BITS);
308 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumb[i] = CLIP(
309 (s64)((u64)stats->params.rawae3_1.sumb[i] * awb1_gain_b / 256 - (pixel_num >> 2) * bls_b), 0, MAX_29BITS);
310 }
311
312 if (bls_cfg->bls1_en && !is_hdr) {
313 memset(statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins, 0,
314 ISP3X_HIST_BIN_N_MAX * sizeof(u32));
315
316 u16 ob;
317 s16 bls1, bls;
318 int tmp;
319 u16 awb1_gain, div_part, round_part;
320
321 switch (isp_params->rawhist3.mode) {
322 case 2:
323 ob = isp_ob_offset_rb >> 2;
324 bls1 = bls1_val.r >> 2;
325 awb1_gain = awb1_gain_r;
326 bls = (ob + bls1) * awb1_gain;
327 round_part = 128;
328 div_part = 256;
329 break;
330 case 3:
331 ob = isp_ob_offset_g >> 4;
332 bls1 = bls1_val.gr >> 4;
333 awb1_gain = awb1_gain_gr;
334 bls = (ob + bls1) * awb1_gain;
335 round_part = 128;
336 div_part = 256;
337 break;
338 case 4:
339 ob = isp_ob_offset_rb >> 2;
340 bls1 = bls1_val.b >> 2;
341 awb1_gain = awb1_gain_b;
342 bls = (ob + bls1) * awb1_gain;
343 round_part = 128;
344 div_part = 256;
345 break;
346 case 5:
347 default:
348 ob = (u16)((isp_ob_offset_g >> 4) * 587 + (isp_ob_offset_rb >> 2) * 299 + (isp_ob_offset_rb >> 2) * 114 + 500) / 1000;
349 bls1 = (s16)((bls1_val.gr >> 4) * 587 + (bls1_val.r >> 2) * 299 + (bls1_val.b >> 2) * 114 + 500) / 1000;
350 awb1_gain = 100;
351 bls = (ob + bls1) * awb1_gain;
352 div_part = 7655 / awb1_gain_r + 15027 / awb1_gain_gr + 2919 / awb1_gain_b;
353 round_part = div_part / 2;
354 break;
355 }
356
357
358 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
359 tmp = (i - ob - bls1 > 0) ? (i * awb1_gain - bls + round_part) / div_part : 0;
360 tmp = (tmp > ISP3X_HIST_BIN_N_MAX - 1) ? (ISP3X_HIST_BIN_N_MAX - 1) : tmp;
361
362 statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins[tmp] +=
363 stats->params.rawhist3.hist_bin[i];
364 }
365 } else {
366 memcpy(statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins,
367 stats->params.rawhist3.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
368 }
369 break;
370 case AEC_RAWSEL_MODE_TMO:
371 #if 0
372 for (int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
373 statsInt->aec_stats.ae_data.extra.rawae_big.channelr_xy[i] =
374 stats->params.rawae3_0.data[i].channelr_xy;
375 statsInt->aec_stats.ae_data.extra.rawae_big.channelg_xy[i] =
376 stats->params.rawae3_0.data[i].channelg_xy;
377 statsInt->aec_stats.ae_data.extra.rawae_big.channelb_xy[i] =
378 stats->params.rawae3_0.data[i].channelb_xy;
379 }
380 for (int i = 0; i < ISP3X_RAWAEBIG_SUBWIN_NUM; i++) {
381 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumr[i] =
382 stats->params.rawae3_1.sumr[i];
383 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumg[i] =
384 stats->params.rawae3_1.sumg[i];
385 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumb[i] =
386 stats->params.rawae3_1.sumb[i];
387 }
388 memcpy(statsInt->aec_stats.ae_data.extra.rawhist_big.bins,
389 stats->params.rawhist3.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
390 #endif
391 break;
392
393 default:
394 LOGE("wrong AeSelMode=%d\n", AeSelMode);
395 return XCAM_RETURN_ERROR_PARAM;
396 }
397 }
398
399 #ifdef AE_STATS_DEBUG
400 if (AeSwapMode != 0) {
401 for (int i = 0; i < 15; i++) {
402 for (int j = 0; j < 15; j++) {
403 printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
404 statsInt->aec_stats.ae_data.chn[0].rawae_big.channelr_xy[i * 15 + j],
405 statsInt->aec_stats.ae_data.chn[0].rawae_big.channelg_xy[i * 15 + j],
406 statsInt->aec_stats.ae_data.chn[0].rawae_big.channelb_xy[i * 15 + j]);
407 }
408 }
409 printf("====================sub-win-result======================\n");
410
411 for (int i = 0; i < 4; i++)
412 printf("chn0_subwin[%d]:sumr 0x%08" PRIx64", sumg 0x%08" PRIx64", sumb 0x%08" PRIx64"\n", i,
413 statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumr[i],
414 statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumg[i],
415 statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumb[i]);
416
417 printf("====================hist_result========================\n");
418
419 for (int i = 0; i < 256; i++)
420 printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins[i]);
421
422 } else {
423 for (int i = 0; i < 5; i++) {
424 for (int j = 0; j < 5; j++) {
425 printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
426 statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelr_xy[i * 5 + j],
427 statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelg_xy[i * 5 + j],
428 statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelb_xy[i * 5 + j]);
429 }
430 }
431 printf("====================hist_result========================\n");
432 for (int i = 0; i < 256; i++)
433 printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins[i]);
434 }
435
436 #endif
437
438 /*
439 * unsigned long chn0_mean = 0, chn1_mean = 0;
440 * for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
441 * chn0_mean += stats->params.rawae1.data[i].channelg_xy;
442 * chn1_mean += stats->params.rawae3.data[i].channelg_xy;
443 * }
444 *
445 *
446 * printf("frame[%d]: chn[0-1]_g_mean_xy: %ld-%ld\n",
447 * stats->frame_id, chn0_mean/ISP3X_RAWAEBIG_MEAN_NUM,
448 * chn1_mean/ISP3X_RAWAEBIG_MEAN_NUM);
449 */
450
451 // expsoure params
452 if (_expParams.ptr()) {
453 statsInt->aec_stats.ae_exp = _expParams->data()->aecExpInfo;
454 /*printf("frame[%d],gain=%d,time=%d\n", stats->frame_id,
455 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
456 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time);*/
457
458 /*
459 * printf("%s: L: [0x%x-0x%x], M: [0x%x-0x%x], S: [0x%x-0x%x]\n",
460 * __func__,
461 * expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
462 * expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
463 * expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
464 * expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
465 * expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time,
466 * expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global);
467 */
468 }
469
470 // iris params
471 if (irisParams.ptr()) {
472 float sof_time = (float)irisParams->data()->sofTime / 1000000000.0f;
473 float start_time = (float)irisParams->data()->PIris.StartTim.tv_sec +
474 (float)irisParams->data()->PIris.StartTim.tv_usec / 1000000.0f;
475 float end_time = (float)irisParams->data()->PIris.EndTim.tv_sec +
476 (float)irisParams->data()->PIris.EndTim.tv_usec / 1000000.0f;
477 float frm_intval = 1 / (statsInt->aec_stats.ae_exp.pixel_clock_freq_mhz * 1000000.0f /
478 (float)statsInt->aec_stats.ae_exp.line_length_pixels /
479 (float)statsInt->aec_stats.ae_exp.frame_length_lines);
480
481 /*printf("%s: step=%d,last-step=%d,start-tim=%f,end-tim=%f,sof_tim=%f\n",
482 __func__,
483 statsInt->aec_stats.ae_exp.Iris.PIris.step,
484 irisParams->data()->PIris.laststep,start_time,end_time,sof_time);
485 */
486
487 if (sof_time < end_time + frm_intval)
488 statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.laststep;
489 else
490 statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.step;
491 }
492
493 to->set_sequence(stats->frame_id);
494 #endif
495
496 #if defined(ISP_HW_V32_LITE)
497
498 Isp20StatsBuffer* buf = from.get_cast_ptr<Isp20StatsBuffer>();
499 struct rkisp32_lite_stat_buffer* stats;
500 SmartPtr<RkAiqAecStats> statsInt = to->data();
501
502 stats = (struct rkisp32_lite_stat_buffer*)(buf->get_v4l2_userptr());
503 if (stats == NULL) {
504 LOGE("fail to get stats ,ignore\n");
505 return XCAM_RETURN_BYPASS;
506 }
507 LOGI_ANALYZER("camId: %d, stats: frame_id: %d, meas_type; 0x%x", mCamPhyId, stats->frame_id,
508 stats->meas_type);
509
510 SmartPtr<RkAiqIrisParamsProxy> irisParams = buf->get_iris_params();
511
512 // ae stats v3.2
513 statsInt->frame_id = stats->frame_id;
514
515 switch (AeSwapMode) {
516 case AEC_RAWSWAP_MODE_S_LITE:
517 meas_type = ((stats->meas_type >> 7) & (0x01)) & ((stats->meas_type >> 11) & (0x01));
518 index0 = 0;
519 index1 = 1;
520 index2 = 2;
521 rawhist_mode = isp_params->rawhist0.mode;
522 break;
523 case AEC_RAWSWAP_MODE_M_LITE:
524 meas_type = ((stats->meas_type >> 8) & (0x01)) & ((stats->meas_type >> 12) & (0x01));
525 index0 = 1;
526 index1 = 0;
527 index2 = 2;
528 rawhist_mode = isp_params->rawhist0.mode;
529 break;
530 default:
531 LOGE("wrong AeSwapMode=%d\n", AeSwapMode);
532 return XCAM_RETURN_ERROR_PARAM;
533 break;
534 }
535
536 statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;
537 if (!statsInt->aec_stats_valid) return XCAM_RETURN_BYPASS;
538
539 statsInt->af_prior = (isp_params->rawaf.ae_sel == 0) ? true : false; /*for isp32-lite, ae_sel=0 use BIG, ae_sel=1 use LITE*/
540
541 if(is_hdr && statsInt->af_prior) {
542 if(AeSelMode != AEC_RAWSEL_MODE_CHN_1) {
543 LOGE("wrong AeSelMode=%d\n", AeSelMode);
544 return XCAM_RETURN_ERROR_PARAM;
545 }
546 } else if(!is_hdr && statsInt->af_prior) {
547 if(AeSelMode != AEC_RAWSEL_MODE_CHN_0) {
548 LOGE("wrong AeSelMode=%d\n", AeSelMode);
549 return XCAM_RETURN_ERROR_PARAM;
550 }
551 }
552
553 //AE-LITE (RAWAE0)
554 if(!statsInt->af_prior) {
555 if(is_hdr || AeSwapMode == AEC_RAWSWAP_MODE_S_LITE) {
556 for (int i = 0; i < ISP3X_RAWAELITE_MEAN_NUM; i++) {
557
558 statsInt->aec_stats.ae_data.chn[index0].rawae_lite.channelr_xy[i] = CLIP(
559 (int)(stats->params.rawae0.data[i].channelr_xy * awb1_gain_r / 256 - bls_r), 0, MAX_10BITS);
560 statsInt->aec_stats.ae_data.chn[index0].rawae_lite.channelg_xy[i] = CLIP(
561 (int)(stats->params.rawae0.data[i].channelg_xy * awb1_gain_gr / 256 - bls_g), 0, MAX_12BITS);
562 statsInt->aec_stats.ae_data.chn[index0].rawae_lite.channelb_xy[i] = CLIP(
563 (int)(stats->params.rawae0.data[i].channelb_xy * awb1_gain_b / 256 - bls_b), 0, MAX_10BITS);
564 }
565 }
566 }
567
568
569 //HIST-LITE (RAWHIST0)
570 if (bls_cfg->bls1_en && !is_hdr) {
571
572 memset(statsInt->aec_stats.ae_data.chn[index0].rawhist_lite.bins, 0,
573 ISP3X_HIST_BIN_N_MAX * sizeof(u32));
574
575 s16 bls1, bls;
576 u16 ob, awb1_gain, div_part, round_part;
577 int tmp;
578
579 switch (rawhist_mode) {
580 case 2:
581 ob = isp_ob_offset_rb >> 2;
582 bls1 = bls1_val.r >> 2;
583 awb1_gain = awb1_gain_r;
584 bls = (ob + bls1) * awb1_gain;
585 div_part = 256;
586 round_part = 128;
587 break;
588 case 3:
589 ob = isp_ob_offset_g >> 4;
590 bls1 = bls1_val.gr >> 4;
591 awb1_gain = awb1_gain_gr;
592 bls = (ob + bls1) * awb1_gain;
593 div_part = 256;
594 round_part = 128;
595 break;
596 case 4:
597 ob = isp_ob_offset_rb >> 2;
598 bls1 = bls1_val.b >> 2;
599 awb1_gain = awb1_gain_b;
600 bls = (ob + bls1) * awb1_gain;
601 div_part = 256;
602 round_part = 128;
603 break;
604 case 5:
605 default:
606 ob = (u16)((isp_ob_offset_g >> 4) * 587 + (isp_ob_offset_rb >> 2) * 299 + (isp_ob_offset_rb >> 2) * 114 + 500) / 1000;
607 bls1 = (s16)((bls1_val.gr >> 4) * 587 + (bls1_val.r >> 2) * 299 + (bls1_val.b >> 2) * 114 + 500) / 1000;
608 awb1_gain = 100;
609 bls = (ob + bls1) * awb1_gain;
610 div_part = 7655 / awb1_gain_r + 15027 / awb1_gain_gr + 2919 / awb1_gain_b;
611 round_part = div_part / 2;
612 break;
613 }
614
615 int oneBinWidth = 256 / ISP32L_HIST_LITE_BIN_N_MAX;
616 uint64_t SumHistPix = 0;
617 float HistMean = 0.0f;
618
619 for (int i = 0; i < ISP32L_HIST_LITE_BIN_N_MAX; i++) {
620
621 tmp = oneBinWidth * (i + 0.5);
622 tmp = (tmp - ob - bls1 > 0) ? (tmp * awb1_gain - bls + round_part) / div_part : 0;
623 tmp = (tmp > oneBinWidth * (ISP32L_HIST_LITE_BIN_N_MAX - 0.5)) ?
624 oneBinWidth * (ISP32L_HIST_LITE_BIN_N_MAX - 0.5) : tmp;
625
626 tmp = tmp / oneBinWidth;
627
628 statsInt->aec_stats.ae_data.chn[index0].rawhist_lite.bins[tmp] +=
629 stats->params.rawhist0.hist_bin[i];
630 SumHistPix += stats->params.rawhist0.hist_bin[i];
631 }
632
633 for (int i = 0; i < ISP32L_HIST_LITE_BIN_N_MAX; i++) {
634 HistMean += (float)(stats->params.rawhist0.hist_bin[i] * (i + 1) * oneBinWidth) / (float)SumHistPix ;
635 }
636 // NOTE: tmp use yuvae mean
637 statsInt->aec_stats.ae_data.yuvae.mean[index0] = (uint8_t)HistMean;
638 } else {
639
640 if(is_hdr || AeSwapMode == AEC_RAWSWAP_MODE_S_LITE) {
641 memcpy(statsInt->aec_stats.ae_data.chn[index0].rawhist_lite.bins,
642 stats->params.rawhist0.hist_bin, ISP32L_HIST_LITE_BIN_N_MAX * sizeof(u32));
643
644 int oneBinWidth = 256 / ISP32L_HIST_LITE_BIN_N_MAX;
645 uint64_t SumHistPix = 0;
646 float HistMean = 0.0f;
647
648 for (int i = 0; i < ISP32L_HIST_LITE_BIN_N_MAX; i++)
649 SumHistPix += stats->params.rawhist0.hist_bin[i];
650
651 for (int i = 0; i < ISP32L_HIST_LITE_BIN_N_MAX; i++) {
652 HistMean += (float)(stats->params.rawhist0.hist_bin[i] * (i + 1) * oneBinWidth) / (float)SumHistPix;
653 }
654
655 // NOTE: tmp use yuvae mean
656 statsInt->aec_stats.ae_data.yuvae.mean[index0] = (uint8_t)HistMean;
657 }
658
659 }
660
661 // AE/HIST-BIG (RAWAE3/RAWHIST3)
662 switch (AeSelMode) {
663 case AEC_RAWSEL_MODE_CHN_0:
664 case AEC_RAWSEL_MODE_CHN_1:
665
666 //RAWAE3 15x15 block
667 for (int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
668 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelr_xy[i] = CLIP(
669 (int)(stats->params.rawae3.data[i].channelr_xy * awb1_gain_r / 256 - bls_r), 0, MAX_10BITS);
670 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelg_xy[i] = CLIP(
671 (int)(stats->params.rawae3.data[i].channelg_xy * awb1_gain_gr / 256 - bls_g), 0, MAX_12BITS);
672 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelb_xy[i] = CLIP(
673 (int)(stats->params.rawae3.data[i].channelb_xy * awb1_gain_b / 256 - bls_b), 0, MAX_10BITS);
674 }
675
676 //RAWAE3 independent block, only one for isp32-lite
677 pixel_num = MAX(1, isp_params->rawae3.subwin[0].h_size * isp_params->rawae3.subwin[0].v_size);
678
679 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumr[0] = CLIP(
680 (s64)((u64)stats->params.rawae3.sumr * awb1_gain_r / 256 - (pixel_num >> 2) * bls_r), 0, MAX_29BITS);
681 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumg[0] = CLIP(
682 (s64)((u64)stats->params.rawae3.sumg * awb1_gain_gr / 256 - (pixel_num >> 1) * bls_g), 0, MAX_32BITS);
683 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumb[0] = CLIP(
684 (s64)((u64)stats->params.rawae3.sumb * awb1_gain_b / 256 - (pixel_num >> 2) * bls_b), 0, MAX_29BITS);
685
686 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_channelr[0] =
687 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumr[0] / pixel_num;
688
689 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_channelg[0] =
690 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumg[0] / pixel_num;
691
692 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_channelb[0] =
693 statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumb[0] / pixel_num;
694
695 //RAWHIST 3
696 if (bls_cfg->bls1_en && !is_hdr) {
697 memset(statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins, 0,
698 ISP3X_HIST_BIN_N_MAX * sizeof(u32));
699
700 u16 ob;
701 s16 bls1, bls;
702 int tmp;
703 u16 awb1_gain, div_part, round_part;
704
705 switch (isp_params->rawhist3.mode) {
706 case 2:
707 ob = isp_ob_offset_rb >> 2;
708 bls1 = bls1_val.r >> 2;
709 awb1_gain = awb1_gain_r;
710 bls = (ob + bls1) * awb1_gain;
711 round_part = 128;
712 div_part = 256;
713 break;
714 case 3:
715 ob = isp_ob_offset_g >> 4;
716 bls1 = bls1_val.gr >> 4;
717 awb1_gain = awb1_gain_gr;
718 bls = (ob + bls1) * awb1_gain;
719 round_part = 128;
720 div_part = 256;
721 break;
722 case 4:
723 ob = isp_ob_offset_rb >> 2;
724 bls1 = bls1_val.b >> 2;
725 awb1_gain = awb1_gain_b;
726 bls = (ob + bls1) * awb1_gain;
727 round_part = 128;
728 div_part = 256;
729 break;
730 case 5:
731 default:
732 ob = (u16)((isp_ob_offset_g >> 4) * 587 + (isp_ob_offset_rb >> 2) * 299 + (isp_ob_offset_rb >> 2) * 114 + 500) / 1000;
733 bls1 = (s16)((bls1_val.gr >> 4) * 587 + (bls1_val.r >> 2) * 299 + (bls1_val.b >> 2) * 114 + 500) / 1000;
734 awb1_gain = 100;
735 bls = (ob + bls1) * awb1_gain;
736 div_part = 7655 / awb1_gain_r + 15027 / awb1_gain_gr + 2919 / awb1_gain_b;
737 round_part = div_part / 2;
738 break;
739 }
740
741 uint64_t SumHistPix = 0;
742 float HistMean = 0.0f;
743
744 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
745 tmp = (i - ob - bls1 > 0) ? (i * awb1_gain - bls + round_part) / div_part : 0;
746 tmp = (tmp > ISP3X_HIST_BIN_N_MAX - 1) ? (ISP3X_HIST_BIN_N_MAX - 1) : tmp;
747
748 statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins[tmp] +=
749 stats->params.rawhist3.hist_bin[i];
750 SumHistPix += stats->params.rawhist3.hist_bin[i];
751 }
752
753 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
754 HistMean += (float)(stats->params.rawhist3.hist_bin[i] * (i + 1)) / (float)SumHistPix ;
755 }
756 // NOTE: tmp use yuvae mean
757 statsInt->aec_stats.ae_data.yuvae.mean[AeSelMode] = (uint8_t)HistMean;
758 } else {
759 memcpy(statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins,
760 stats->params.rawhist3.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
761
762 uint64_t SumHistPix = 0;
763 float HistMean = 0.0f;
764
765 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++)
766 SumHistPix += stats->params.rawhist3.hist_bin[i];
767
768 for (int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
769 HistMean += (float)(stats->params.rawhist3.hist_bin[i] * (i + 1)) / (float)SumHistPix;
770 }
771
772 // NOTE: tmp use yuvae mean
773 statsInt->aec_stats.ae_data.yuvae.mean[AeSelMode] = (uint8_t)HistMean;
774 }
775 break;
776 case AEC_RAWSEL_MODE_TMO:
777 for (int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
778 statsInt->aec_stats.ae_data.extra.rawae_big.channelr_xy[i] =
779 stats->params.rawae3.data[i].channelr_xy;
780 statsInt->aec_stats.ae_data.extra.rawae_big.channelg_xy[i] =
781 stats->params.rawae3.data[i].channelg_xy;
782 statsInt->aec_stats.ae_data.extra.rawae_big.channelb_xy[i] =
783 stats->params.rawae3.data[i].channelb_xy;
784 }
785
786 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumr[0] =
787 stats->params.rawae3.sumr;
788 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumg[0] =
789 stats->params.rawae3.sumg;
790 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumb[0] =
791 stats->params.rawae3.sumb;
792
793 pixel_num = MAX(1, isp_params->rawae3.subwin[0].h_size * isp_params->rawae3.subwin[0].v_size);
794
795 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_channelr[0] =
796 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumr[0] / pixel_num;
797
798 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_channelg[0] =
799 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumg[0] / pixel_num;
800
801 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_channelb[0] =
802 statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumb[0] / pixel_num;
803
804 memcpy(statsInt->aec_stats.ae_data.extra.rawhist_big.bins,
805 stats->params.rawhist3.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
806 break;
807
808 default:
809 LOGE("wrong AeSelMode=%d\n", AeSelMode);
810 return XCAM_RETURN_ERROR_PARAM;
811 }
812
813 #ifdef AE_STATS_DEBUG
814 if(is_hdr) {
815 if(AeSelMode != 1) {
816 for (int i = 0; i < 5; i++) {
817 for (int j = 0; j < 5; j++) {
818 printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
819 statsInt->aec_stats.ae_data.chn[1].rawae_lite.channelr_xy[i * 5 + j],
820 statsInt->aec_stats.ae_data.chn[1].rawae_lite.channelg_xy[i * 5 + j],
821 statsInt->aec_stats.ae_data.chn[1].rawae_lite.channelb_xy[i * 5 + j]);
822 }
823 }
824 printf("====================hist_result========================\n");
825 for (int i = 0; i < ISP32L_HIST_LITE_BIN_N_MAX; i++)
826 printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[1].rawhist_lite.bins[i]);
827 } else {
828
829 for (int i = 0; i < 15; i++) {
830 for (int j = 0; j < 15; j++) {
831 printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
832 statsInt->aec_stats.ae_data.chn[1].rawae_big.channelr_xy[i * 15 + j],
833 statsInt->aec_stats.ae_data.chn[1].rawae_big.channelg_xy[i * 15 + j],
834 statsInt->aec_stats.ae_data.chn[1].rawae_big.channelb_xy[i * 15 + j]);
835 }
836 }
837 printf("====================sub-win-result======================\n");
838
839 printf("chn0_subwin:sumr 0x%08" PRIx64", sumg 0x%08" PRIx64", sumb 0x%08" PRIx64"\n",
840 statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumr[0],
841 statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumg[0],
842 statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumb[0]);
843
844 printf("====================hist_result========================\n");
845
846 for (int i = 0; i < 256; i++)
847 printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins[i]);
848 }
849 } else {
850 if (AeSelMode == 0) {
851 for (int i = 0; i < 15; i++) {
852 for (int j = 0; j < 15; j++) {
853 printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
854 statsInt->aec_stats.ae_data.chn[0].rawae_big.channelr_xy[i * 15 + j],
855 statsInt->aec_stats.ae_data.chn[0].rawae_big.channelg_xy[i * 15 + j],
856 statsInt->aec_stats.ae_data.chn[0].rawae_big.channelb_xy[i * 15 + j]);
857 }
858 }
859 printf("====================sub-win-result======================\n");
860
861 printf("chn0_subwin:sumr 0x%08" PRIx64", sumg 0x%08" PRIx64", sumb 0x%08" PRIx64"\n",
862 statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumr[0],
863 statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumg[0],
864 statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumb[0]);
865
866 printf("====================hist_result========================\n");
867
868 for (int i = 0; i < 256; i++)
869 printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins[i]);
870
871 } else {
872 for (int i = 0; i < 5; i++) {
873 for (int j = 0; j < 5; j++) {
874 printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
875 statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelr_xy[i * 5 + j],
876 statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelg_xy[i * 5 + j],
877 statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelb_xy[i * 5 + j]);
878 }
879 }
880 printf("====================hist_result========================\n");
881 for (int i = 0; i < ISP32L_HIST_LITE_BIN_N_MAX; i++)
882 printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins[i]);
883 }
884 }
885
886 #endif
887
888 /*
889 * unsigned long chn0_mean = 0, chn1_mean = 0;
890 * for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
891 * chn0_mean += stats->params.rawae1.data[i].channelg_xy;
892 * chn1_mean += stats->params.rawae3.data[i].channelg_xy;
893 * }
894 *
895 *
896 * printf("frame[%d]: chn[0-1]_g_mean_xy: %ld-%ld\n",
897 * stats->frame_id, chn0_mean/ISP3X_RAWAEBIG_MEAN_NUM,
898 * chn1_mean/ISP3X_RAWAEBIG_MEAN_NUM);
899 */
900
901 // expsoure params
902 if (_expParams.ptr()) {
903 statsInt->aec_stats.ae_exp = _expParams->data()->aecExpInfo;
904 /*printf("frame[%d],gain=%d,time=%d\n", stats->frame_id,
905 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
906 expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time);*/
907
908 /*
909 * printf("%s: L: [0x%x-0x%x], M: [0x%x-0x%x], S: [0x%x-0x%x]\n",
910 * __func__,
911 * expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
912 * expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
913 * expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
914 * expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
915 * expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time,
916 * expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global);
917 */
918 }
919
920 // iris params
921 if (irisParams.ptr()) {
922 float sof_time = (float)irisParams->data()->sofTime / 1000000000.0f;
923 float start_time = (float)irisParams->data()->PIris.StartTim.tv_sec +
924 (float)irisParams->data()->PIris.StartTim.tv_usec / 1000000.0f;
925 float end_time = (float)irisParams->data()->PIris.EndTim.tv_sec +
926 (float)irisParams->data()->PIris.EndTim.tv_usec / 1000000.0f;
927 float frm_intval = 1 / (statsInt->aec_stats.ae_exp.pixel_clock_freq_mhz * 1000000.0f /
928 (float)statsInt->aec_stats.ae_exp.line_length_pixels /
929 (float)statsInt->aec_stats.ae_exp.frame_length_lines);
930
931 /*printf("%s: step=%d,last-step=%d,start-tim=%f,end-tim=%f,sof_tim=%f\n",
932 __func__,
933 statsInt->aec_stats.ae_exp.Iris.PIris.step,
934 irisParams->data()->PIris.laststep,start_time,end_time,sof_time);
935 */
936
937 if (sof_time < end_time + frm_intval)
938 statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.laststep;
939 else
940 statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.step;
941 }
942
943 to->set_sequence(stats->frame_id);
944 #endif
945
946 return ret;
947 }
948
translateAwbStats(const SmartPtr<VideoBuffer> & from,SmartPtr<RkAiqAwbStatsProxy> & to)949 XCamReturn RkAiqResourceTranslatorV32::translateAwbStats(const SmartPtr<VideoBuffer>& from,
950 SmartPtr<RkAiqAwbStatsProxy>& to) {
951 XCamReturn ret = XCAM_RETURN_NO_ERROR;
952 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
953 Isp20StatsBuffer* buf =
954 from.get_cast_ptr<Isp20StatsBuffer>();
955 #if defined(ISP_HW_V32)
956 struct rkisp32_isp_stat_buffer *stats;
957 stats = (struct rkisp32_isp_stat_buffer*)(buf->get_v4l2_userptr());
958 #elif defined(ISP_HW_V32_LITE)
959 struct rkisp32_lite_stat_buffer *stats;
960 stats = (struct rkisp32_lite_stat_buffer*)(buf->get_v4l2_userptr());
961 #endif
962
963 SmartPtr<RkAiqAwbStats> statsInt = to->data();
964
965 if(stats == NULL) {
966 LOGE("fail to get stats ,ignore\n");
967 return XCAM_RETURN_BYPASS;
968 }
969 LOGI_ANALYZER("awb stats: camId:%d, frame_id: %d, meas_type; 0x%x",
970 mCamPhyId, stats->frame_id, stats->meas_type);
971
972 statsInt->awb_stats_valid = stats->meas_type >> 5 & 1;
973 if (!statsInt->awb_stats_valid) {
974 LOGE_ANALYZER("AWB stats invalid, ignore");
975 return XCAM_RETURN_BYPASS;
976 }
977
978 if (stats->params.info2ddr.owner == RKISP_INFO2DRR_OWNER_AWB) {
979 statsInt->awb_stats_v32.dbginfo_fd = stats->params.info2ddr.buf_fd;
980 } else {
981 statsInt->awb_stats_v32.dbginfo_fd = -1;
982 }
983 statsInt->awb_stats_v32.awb_cfg_effect_v32.blkMeasureMode = _ispParams.awb_cfg_v32.blkMeasureMode;
984 statsInt->awb_stats_v32.awb_cfg_effect_v32.lightNum = _ispParams.awb_cfg_v32.lightNum;
985 statsInt->awb_stats_v32.awb_cfg_effect_v32.groupIllIndxCurrent = _ispParams.awb_cfg_v32.groupIllIndxCurrent;
986 memcpy(statsInt->awb_stats_v32.awb_cfg_effect_v32.IllIndxSetCurrent, _ispParams.awb_cfg_v32.IllIndxSetCurrent,
987 sizeof(statsInt->awb_stats_v32.awb_cfg_effect_v32.IllIndxSetCurrent));
988 memcpy(statsInt->awb_stats_v32.awb_cfg_effect_v32.timeSign, _ispParams.awb_cfg_v32.timeSign,
989 sizeof(statsInt->awb_stats_v32.awb_cfg_effect_v32.timeSign));
990 statsInt->awb_cfg_effect_valid = true;
991 statsInt->frame_id = stats->frame_id;
992 for(int i = 0; i < statsInt->awb_stats_v32.awb_cfg_effect_v32.lightNum; i++) {
993 statsInt->awb_stats_v32.light[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].RgainValue =
994 stats->params.rawawb.sum[i].rgain_nor;
995 statsInt->awb_stats_v32.light[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].BgainValue =
996 stats->params.rawawb.sum[i].bgain_nor;
997 statsInt->awb_stats_v32.light[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].WpNo =
998 stats->params.rawawb.sum[i].wp_num_nor;
999 statsInt->awb_stats_v32.light[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].RgainValue =
1000 stats->params.rawawb.sum[i].rgain_big;
1001 statsInt->awb_stats_v32.light[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].BgainValue =
1002 stats->params.rawawb.sum[i].bgain_big;
1003 statsInt->awb_stats_v32.light[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].WpNo =
1004 stats->params.rawawb.sum[i].wp_num_big;
1005 statsInt->awb_stats_v32.WpNo2[i] = stats->params.rawawb.sum[i].wp_num2;
1006 }
1007 memset(&statsInt->awb_stats_v32.sumBlkRGB, 0, sizeof(statsInt->awb_stats_v32.sumBlkRGB));
1008 #if defined(ISP_HW_V32)
1009 for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
1010 statsInt->awb_stats_v32.blockResult[i].Rvalue = stats->params.rawawb.ramdata[i].r;
1011 statsInt->awb_stats_v32.blockResult[i].Gvalue = stats->params.rawawb.ramdata[i].g;
1012 statsInt->awb_stats_v32.blockResult[i].Bvalue = stats->params.rawawb.ramdata[i].b;
1013 statsInt->awb_stats_v32.blockResult[i].WpNo = stats->params.rawawb.ramdata[i].wp;
1014 statsInt->awb_stats_v32.sumBlkRGB.Rvalue += statsInt->awb_stats_v32.blockResult[i].Rvalue ;
1015 statsInt->awb_stats_v32.sumBlkRGB.Gvalue += statsInt->awb_stats_v32.blockResult[i].Gvalue;
1016 statsInt->awb_stats_v32.sumBlkRGB.Bvalue += statsInt->awb_stats_v32.blockResult[i].Bvalue;
1017 }
1018
1019 #elif defined(ISP_HW_V32_LITE)
1020 for(int i = 0; i < ISP32L_RAWAWB_RAMDATA_RGB_NUM; i++) {
1021 statsInt->awb_stats_v32.blockResult[i].Rvalue = stats->params.rawawb.ramdata_r[i];
1022 statsInt->awb_stats_v32.blockResult[i].Gvalue = stats->params.rawawb.ramdata_g[i];
1023 statsInt->awb_stats_v32.blockResult[i].Bvalue = stats->params.rawawb.ramdata_b[i];
1024 if(i % 2 == 0) {
1025 statsInt->awb_stats_v32.blockResult[i].WpNo = stats->params.rawawb.ramdata_wpnum0[i / 2];
1026 } else {
1027 statsInt->awb_stats_v32.blockResult[i].WpNo = stats->params.rawawb.ramdata_wpnum1[i / 2];
1028 }
1029 statsInt->awb_stats_v32.sumBlkRGB.Rvalue += statsInt->awb_stats_v32.blockResult[i].Rvalue ;
1030 statsInt->awb_stats_v32.sumBlkRGB.Gvalue += statsInt->awb_stats_v32.blockResult[i].Gvalue;
1031 statsInt->awb_stats_v32.sumBlkRGB.Bvalue += statsInt->awb_stats_v32.blockResult[i].Bvalue;
1032 }
1033 #endif
1034 for(int i = 0; i < RK_AIQ_AWB_WP_HIST_BIN_NUM; i++) {
1035 statsInt->awb_stats_v32.WpNoHist[i] = stats->params.rawawb.yhist_bin[i];
1036 // move the shift code here to make WpNoHist merged by several cameras easily
1037 if( stats->params.rawawb.yhist_bin[i] & 0x8000 ) {
1038 statsInt->awb_stats_v32.WpNoHist[i] = stats->params.rawawb.yhist_bin[i] & 0x7FFF;
1039 statsInt->awb_stats_v32.WpNoHist[i] *= (1 << 3);
1040 }
1041 }
1042
1043 for(int i = 0; i < RK_AIQ_AWB_STAT_WP_RANGE_NUM_V201; i++) {
1044 statsInt->awb_stats_v32.excWpRangeResult[i].RgainValue = stats->params.rawawb.sum_exc[i].rgain_exc;
1045 statsInt->awb_stats_v32.excWpRangeResult[i].BgainValue = stats->params.rawawb.sum_exc[i].bgain_exc;
1046 statsInt->awb_stats_v32.excWpRangeResult[i].WpNo = stats->params.rawawb.sum_exc[i].wp_num_exc;
1047
1048 }
1049
1050 to->set_sequence(stats->frame_id);
1051 #endif
1052 return ret;
1053 }
1054
1055
1056
translateAfStats(const SmartPtr<VideoBuffer> & from,SmartPtr<RkAiqAfStatsProxy> & to)1057 XCamReturn RkAiqResourceTranslatorV32::translateAfStats(const SmartPtr<VideoBuffer>& from,
1058 SmartPtr<RkAiqAfStatsProxy>& to) {
1059
1060 struct isp32_rawaf_luma_data {
1061 u32 channelg_xy: 12;
1062 u32 highlit_cnt: 16;
1063 u32 dummy: 4;
1064 } __attribute__ ((packed));
1065
1066 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1067 #if defined(ISP_HW_V32)
1068 Isp20StatsBuffer* buf =
1069 from.get_cast_ptr<Isp20StatsBuffer>();
1070 struct rkisp32_isp_stat_buffer *stats;
1071 SmartPtr<RkAiqAfStats> statsInt = to->data();
1072
1073 stats = (struct rkisp32_isp_stat_buffer*)(buf->get_v4l2_userptr());
1074 if(stats == NULL) {
1075 LOGE_AF("fail to get stats, ignore");
1076 return XCAM_RETURN_BYPASS;
1077 }
1078 LOGI_ANALYZER("stats: frame_id: %d, meas_type; 0x%x",
1079 stats->frame_id, stats->meas_type);
1080
1081 statsInt->af_stats_valid =
1082 (stats->meas_type >> 6) & (0x01) ? true : false;
1083 if (!statsInt->af_stats_valid)
1084 return XCAM_RETURN_BYPASS;
1085
1086 SmartPtr<RkAiqAfInfoProxy> afParams = buf->get_af_params();
1087 struct isp32_bls_cfg* bls_cfg = &_ispParams.bls_cfg;
1088 u8 from_awb = _ispParams.meas.rawaf.from_awb;
1089 u8 from_ynr = _ispParams.meas.rawaf.from_ynr;
1090 bool is_hdr = (getWorkingMode() > 0) ? true : false;
1091 int temp_luma, comp_bls = 0;
1092 u16 max_val = (1 << 12) - 1;
1093
1094 if (bls_cfg->bls1_en && !is_hdr && !from_awb && !from_ynr) {
1095 comp_bls = (bls_cfg->bls1_val.gr + bls_cfg->bls1_val.gb) / 2 - bls_cfg->isp_ob_offset;
1096 comp_bls = MAX(comp_bls, 0);
1097 }
1098
1099 #if 0
1100 struct isp32_awb_gain_cfg* awb_gain_cfg = &_ispParams.awb_gain_cfg;
1101
1102 LOGE("bls0[%d-%d]", bls_cfg->fixed_val.gr, bls_cfg->fixed_val.gb);
1103 LOGE("bls1[%d-%d]", bls_cfg->bls1_val.gr, bls_cfg->bls1_val.gb);
1104 LOGE("isp_ob_offset, isp_ob_max, isp_ob_predgain [%d-%d-%d]",
1105 bls_cfg->isp_ob_offset, bls_cfg->isp_ob_max, bls_cfg->isp_ob_predgain);
1106 LOGE("awb0_gain[%d-%d], awb1_gain[%d-%d]",
1107 awb_gain_cfg->gain0_green_b, awb_gain_cfg->gain0_green_r,
1108 awb_gain_cfg->gain1_green_b, awb_gain_cfg->gain1_green_r);
1109 LOGE("comp_bls %d", comp_bls);
1110 #endif
1111
1112 memset(&statsInt->af_stats_v3x, 0, sizeof(rk_aiq_isp_af_stats_v3x_t));
1113 statsInt->frame_id = stats->frame_id;
1114
1115 //af
1116 {
1117 statsInt->af_stats_v3x.comp_bls = comp_bls >> 2;
1118 statsInt->af_stats_v3x.wndb_luma = stats->params.rawaf.afm_lum_b;
1119 statsInt->af_stats_v3x.wndb_sharpness = stats->params.rawaf.afm_sum_b;
1120 statsInt->af_stats_v3x.winb_highlit_cnt = stats->params.rawaf.highlit_cnt_winb;
1121 for (int i = 0; i < RKAIQ_RAWAF_SUMDATA_NUM; i++) {
1122 statsInt->af_stats_v3x.wnda_fv_v1[i] = stats->params.rawaf.ramdata[i].v1;
1123 statsInt->af_stats_v3x.wnda_fv_v2[i] = stats->params.rawaf.ramdata[i].v2;
1124 statsInt->af_stats_v3x.wnda_fv_h1[i] = stats->params.rawaf.ramdata[i].h1;
1125 statsInt->af_stats_v3x.wnda_fv_h2[i] = stats->params.rawaf.ramdata[i].h2;
1126 }
1127
1128 struct isp32_rawaf_luma_data *luma = (struct isp32_rawaf_luma_data *)&stats->params.rawae3_0.data[0];
1129 for (int i = 0; i < RKAIQ_RAWAF_SUMDATA_NUM; i++) {
1130 temp_luma = (luma[i].channelg_xy - comp_bls) * max_val / (max_val - comp_bls);
1131 statsInt->af_stats_v3x.wnda_luma[i] = MAX(temp_luma, 0);
1132 statsInt->af_stats_v3x.wina_highlit_cnt[i] = luma[i].highlit_cnt;
1133 }
1134
1135 if(afParams.ptr()) {
1136 statsInt->af_stats_v3x.focusCode = afParams->data()->focusCode;
1137 statsInt->af_stats_v3x.zoomCode = afParams->data()->zoomCode;
1138 statsInt->af_stats_v3x.focus_endtim = afParams->data()->focusEndTim;
1139 statsInt->af_stats_v3x.focus_starttim = afParams->data()->focusStartTim;
1140 statsInt->af_stats_v3x.zoom_endtim = afParams->data()->zoomEndTim;
1141 statsInt->af_stats_v3x.zoom_starttim = afParams->data()->zoomStartTim;
1142 statsInt->af_stats_v3x.sof_tim = afParams->data()->sofTime;
1143 statsInt->af_stats_v3x.focusCorrection = afParams->data()->focusCorrection;
1144 statsInt->af_stats_v3x.zoomCorrection = afParams->data()->zoomCorrection;
1145 statsInt->af_stats_v3x.angleZ = afParams->data()->angleZ;
1146 }
1147
1148 if (_expParams.ptr())
1149 statsInt->aecExpInfo = _expParams->data()->aecExpInfo;
1150 }
1151
1152 #endif
1153
1154 #if defined(ISP_HW_V32_LITE)
1155 Isp20StatsBuffer* buf =
1156 from.get_cast_ptr<Isp20StatsBuffer>();
1157 struct rkisp32_lite_stat_buffer *stats_lite;
1158 SmartPtr<RkAiqAfStats> statsInt = to->data();
1159
1160 stats_lite = (struct rkisp32_lite_stat_buffer*)(buf->get_v4l2_userptr());
1161 if(stats_lite == NULL) {
1162 LOGE_AF("fail to get stats, ignore");
1163 return XCAM_RETURN_BYPASS;
1164 }
1165 LOGD_AF("stats_lite: frame_id: %d, meas_type; 0x%x",
1166 stats_lite->frame_id, stats_lite->meas_type);
1167
1168 statsInt->af_stats_valid =
1169 (stats_lite->meas_type >> 6) & (0x01) ? true : false;
1170 if (!statsInt->af_stats_valid)
1171 return XCAM_RETURN_BYPASS;
1172
1173 SmartPtr<RkAiqAfInfoProxy> afParams = buf->get_af_params();
1174 struct isp32_bls_cfg* bls_cfg = &_ispParams.bls_cfg;
1175 u8 from_awb = _ispParams.meas.rawaf.from_awb;
1176 u8 from_ynr = _ispParams.meas.rawaf.from_ynr;
1177 bool is_hdr = (getWorkingMode() > 0) ? true : false;
1178 int temp_luma, comp_bls = 0;
1179 u16 max_val = (1 << 12) - 1;
1180
1181 if (bls_cfg->bls1_en && !is_hdr && !from_awb && !from_ynr) {
1182 comp_bls = (bls_cfg->bls1_val.gr + bls_cfg->bls1_val.gb) / 2 - bls_cfg->isp_ob_offset;
1183 comp_bls = MAX(comp_bls, 0);
1184 }
1185
1186 memset(&statsInt->af_stats_v3x, 0, sizeof(rk_aiq_isp_af_stats_v3x_t));
1187 statsInt->frame_id = stats_lite->frame_id;
1188
1189 //af
1190 {
1191 statsInt->af_stats_v3x.comp_bls = comp_bls >> 2;
1192 statsInt->af_stats_v3x.wndb_luma = stats_lite->params.rawaf.afm_lum_b;
1193 statsInt->af_stats_v3x.wndb_sharpness = stats_lite->params.rawaf.afm_sum_b;
1194 statsInt->af_stats_v3x.winb_highlit_cnt = stats_lite->params.rawaf.highlit_cnt_winb;
1195 for (int i = 0; i < ISP32L_RAWAF_WND_DATA; i++) {
1196 statsInt->af_stats_v3x.wnda_fv_v1[i] = stats_lite->params.rawaf.ramdata.viir_wnd_data[i];
1197 statsInt->af_stats_v3x.wnda_fv_h1[i] = stats_lite->params.rawaf.ramdata.hiir_wnd_data[i];
1198 statsInt->af_stats_v3x.wnda_fv_v2[i] = statsInt->af_stats_v3x.wnda_fv_v1[i];
1199 statsInt->af_stats_v3x.wnda_fv_h2[i] = statsInt->af_stats_v3x.wnda_fv_h1[i];
1200 }
1201
1202 for (int i = 0; i < ISP32L_RAWAF_WND_DATA; i++) {
1203 temp_luma = (stats_lite->params.rawae0.data[i].channelg_xy - comp_bls) * max_val / (max_val - comp_bls);
1204 statsInt->af_stats_v3x.wnda_luma[i] = MAX(temp_luma, 0);
1205 statsInt->af_stats_v3x.wina_highlit_cnt[i] =
1206 ((stats_lite->params.rawae0.data[i].channelr_xy & 0x3FF) << 10) | (stats_lite->params.rawae0.data[i].channelb_xy & 0x3FF);
1207 }
1208
1209 if(afParams.ptr()) {
1210 statsInt->af_stats_v3x.focusCode = afParams->data()->focusCode;
1211 statsInt->af_stats_v3x.zoomCode = afParams->data()->zoomCode;
1212 statsInt->af_stats_v3x.focus_endtim = afParams->data()->focusEndTim;
1213 statsInt->af_stats_v3x.focus_starttim = afParams->data()->focusStartTim;
1214 statsInt->af_stats_v3x.zoom_endtim = afParams->data()->zoomEndTim;
1215 statsInt->af_stats_v3x.zoom_starttim = afParams->data()->zoomStartTim;
1216 statsInt->af_stats_v3x.sof_tim = afParams->data()->sofTime;
1217 statsInt->af_stats_v3x.focusCorrection = afParams->data()->focusCorrection;
1218 statsInt->af_stats_v3x.zoomCorrection = afParams->data()->zoomCorrection;
1219 statsInt->af_stats_v3x.angleZ = afParams->data()->angleZ;
1220 }
1221
1222 if (_expParams.ptr())
1223 statsInt->aecExpInfo = _expParams->data()->aecExpInfo;
1224 }
1225
1226 #endif
1227
1228 return ret;
1229
1230 }
1231
1232 #if RKAIQ_HAVE_DEHAZE_V12
translateAdehazeStats(const SmartPtr<VideoBuffer> & from,SmartPtr<RkAiqAdehazeStatsProxy> & to)1233 XCamReturn RkAiqResourceTranslatorV32::translateAdehazeStats(const SmartPtr<VideoBuffer>& from,
1234 SmartPtr<RkAiqAdehazeStatsProxy>& to) {
1235 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1236
1237 #if defined(ISP_HW_V32)
1238 Isp20StatsBuffer* buf = from.get_cast_ptr<Isp20StatsBuffer>();
1239 struct rkisp32_isp_stat_buffer* stats;
1240 SmartPtr<RkAiqAdehazeStats> statsInt = to->data();
1241
1242 stats = (struct rkisp32_isp_stat_buffer*)(buf->get_v4l2_userptr());
1243 if (stats == NULL) {
1244 LOGE("fail to get stats ,ignore\n");
1245 return XCAM_RETURN_BYPASS;
1246 }
1247 LOGI_ANALYZER("stats: frame_id: %d, meas_type; 0x%x", stats->frame_id, stats->meas_type);
1248
1249 // dehaze
1250 statsInt->adehaze_stats_valid = stats->meas_type >> 17 & 1;
1251 if (!statsInt->adehaze_stats_valid) return XCAM_RETURN_BYPASS;
1252
1253 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_air_base =
1254 stats->params.dhaz.dhaz_adp_air_base;
1255 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_wt = stats->params.dhaz.dhaz_adp_wt;
1256 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_gratio = stats->params.dhaz.dhaz_adp_gratio;
1257 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_wt = stats->params.dhaz.dhaz_adp_wt;
1258 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_pic_sumh = stats->params.dhaz.dhaz_pic_sumh;
1259 for (int i = 0; i < ISP3X_DHAZ_HIST_IIR_NUM; i++)
1260 statsInt->adehaze_stats.dehaze_stats_v12.h_rgb_iir[i] = stats->params.dhaz.h_rgb_iir[i];
1261 #endif
1262
1263 #if defined(ISP_HW_V32_LITE)
1264 Isp20StatsBuffer* buf = from.get_cast_ptr<Isp20StatsBuffer>();
1265 struct rkisp32_lite_stat_buffer* stats;
1266 SmartPtr<RkAiqAdehazeStats> statsInt = to->data();
1267
1268 stats = (struct rkisp32_lite_stat_buffer*)(buf->get_v4l2_userptr());
1269 if (stats == NULL) {
1270 LOGE("fail to get stats ,ignore\n");
1271 return XCAM_RETURN_BYPASS;
1272 }
1273 LOGI_ANALYZER("stats: frame_id: %d, meas_type; 0x%x", stats->frame_id, stats->meas_type);
1274
1275 // dehaze
1276 statsInt->adehaze_stats_valid = stats->meas_type >> 17 & 1;
1277 if (!statsInt->adehaze_stats_valid) return XCAM_RETURN_BYPASS;
1278
1279 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_air_base =
1280 stats->params.dhaz.dhaz_adp_air_base;
1281 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_wt = stats->params.dhaz.dhaz_adp_wt;
1282 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_gratio = stats->params.dhaz.dhaz_adp_gratio;
1283 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_adp_wt = stats->params.dhaz.dhaz_adp_wt;
1284 statsInt->adehaze_stats.dehaze_stats_v12.dhaz_pic_sumh = stats->params.dhaz.dhaz_pic_sumh;
1285 for (int i = 0; i < ISP3X_DHAZ_HIST_IIR_NUM; i++)
1286 statsInt->adehaze_stats.dehaze_stats_v12.h_rgb_iir[i] = stats->params.dhaz.h_rgb_iir[i];
1287
1288 #endif
1289
1290 return ret;
1291 }
1292 #endif
1293
1294 } // namespace RkCam
1295