/*
 * RkAiqConfigTranslatorV3x.cpp
 *
 *  Copyright (c) 2019 Rockchip Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include "isp20/Isp20Evts.h"
#include "isp20/Isp20StatsBuffer.h"
#include "common/rkisp2-config.h"
#include "common/rkisp21-config.h"
#include "common/rkisp3-config.h"
#include "RkAiqResourceTranslatorV3x.h"
//#define AE_STATS_DEBUG

namespace RkCam {

RkAiqResourceTranslatorV3x::RkAiqResourceTranslatorV3x() : mIsMultiIsp(false) {}

RkAiqResourceTranslatorV3x& RkAiqResourceTranslatorV3x::SetMultiIspMode(bool isMultiIsp) {
    mIsMultiIsp = isMultiIsp;
    return *this;
}

RkAiqResourceTranslatorV3x& RkAiqResourceTranslatorV3x::SetPicInfo(RkAiqResourceTranslatorV3x::Rectangle& pic_rect) {
    pic_rect_ = pic_rect;
    return *this;
}

RkAiqResourceTranslatorV3x& RkAiqResourceTranslatorV3x::SetLeftIspRect(RkAiqResourceTranslatorV3x::Rectangle& left_isp_rect) {
    left_isp_rect_ = left_isp_rect;
    return *this;
}

RkAiqResourceTranslatorV3x& RkAiqResourceTranslatorV3x::SetRightIspRect(
    RkAiqResourceTranslatorV3x::Rectangle& right_isp_rect) {
    right_isp_rect_ = right_isp_rect;
    return *this;
}

RkAiqResourceTranslatorV3x& RkAiqResourceTranslatorV3x::SetPicInfo(RkAiqResourceTranslatorV3x::Rectangle&& pic_rect) {
    pic_rect_ = std::move(pic_rect);
    return *this;
}

RkAiqResourceTranslatorV3x& RkAiqResourceTranslatorV3x::SetLeftIspRect(RkAiqResourceTranslatorV3x::Rectangle&& left_isp_rect) {
    left_isp_rect_ = std::move(left_isp_rect);
    return *this;
}

RkAiqResourceTranslatorV3x& RkAiqResourceTranslatorV3x::SetRightIspRect(
    RkAiqResourceTranslatorV3x::Rectangle&& right_isp_rect) {
    right_isp_rect_ = std::move(right_isp_rect);
    return *this;
}

const bool RkAiqResourceTranslatorV3x::IsMultiIspMode() const {
    return mIsMultiIsp;
}

const RkAiqResourceTranslatorV3x::Rectangle& RkAiqResourceTranslatorV3x::GetPicInfo() const {
    return pic_rect_;
}

const RkAiqResourceTranslatorV3x::Rectangle& RkAiqResourceTranslatorV3x::GetLeftIspRect() const {
    return left_isp_rect_;
}

const RkAiqResourceTranslatorV3x::Rectangle& RkAiqResourceTranslatorV3x::GetRightIspRect() const {
    return right_isp_rect_;
}

void JudgeWinLocation(
    struct isp2x_window* ori_win,
    WinSplitMode& mode,
    RkAiqResourceTranslatorV3x::Rectangle left_isp_rect_,
    RkAiqResourceTranslatorV3x::Rectangle right_isp_rect_
) {

    if (ori_win->h_offs + ori_win->h_size <= left_isp_rect_.w) {
        mode = LEFT_MODE;
    } else if(ori_win->h_offs >= right_isp_rect_.x) {
        mode = RIGHT_MODE;
    } else {
        if ((ori_win->h_offs + ori_win->h_size / 2) <= left_isp_rect_.w
                && right_isp_rect_.x <= (ori_win->h_offs + ori_win->h_size / 2)) {
            mode = LEFT_AND_RIGHT_MODE;
        }
        else {

            if ((ori_win->h_offs + ori_win->h_size / 2) < right_isp_rect_.x) {

                u16 h_size_tmp1 = left_isp_rect_.w - ori_win->h_offs;
                u16 h_size_tmp2 = (right_isp_rect_.x - ori_win->h_offs) * 2;

                if (abs(ori_win->h_size - h_size_tmp1) < abs(ori_win->h_size - h_size_tmp2))
                    mode = LEFT_MODE;
                else
                    mode = LEFT_AND_RIGHT_MODE;
            }
            else {

                u16 h_size_tmp1 = ori_win->h_offs + ori_win->h_size - right_isp_rect_.x;
                u16 h_size_tmp2 = (ori_win->h_offs + ori_win->h_size - left_isp_rect_.w) * 2;

                if (abs(ori_win->h_size - h_size_tmp1) < abs(ori_win->h_size - h_size_tmp2))
                    mode = RIGHT_MODE;
                else
                    mode = LEFT_AND_RIGHT_MODE;
            }
        }
    }
}

void MergeAecWinLiteStats(
    rawaelite_stat_t *merge_stats,
    struct isp2x_rawaelite_stat *left_stats,
    struct isp2x_rawaelite_stat *right_stats,
    WinSplitMode mode,
    struct isp2x_bls_fixed_val bls1_val,
    float* bls_ratio
) {
    u8 wnd_num = sqrt(ISP3X_RAWAELITE_MEAN_NUM);

    for(int i = 0; i < wnd_num; i++) {
        for(int j = 0; j < wnd_num; j++) {

            // step1 copy stats
            switch(mode) {
            case LEFT_MODE:
                merge_stats->channelr_xy[i * wnd_num + j] = left_stats->data[i * wnd_num + j].channelr_xy;
                merge_stats->channelg_xy[i * wnd_num + j] = left_stats->data[i * wnd_num + j].channelg_xy;
                merge_stats->channelb_xy[i * wnd_num + j] = left_stats->data[i * wnd_num + j].channelb_xy;
                break;
            case RIGHT_MODE:
                merge_stats->channelr_xy[i * wnd_num + j] = right_stats->data[i * wnd_num + j].channelr_xy;
                merge_stats->channelg_xy[i * wnd_num + j] = right_stats->data[i * wnd_num + j].channelg_xy;
                merge_stats->channelb_xy[i * wnd_num + j] = right_stats->data[i * wnd_num + j].channelb_xy;
                break;
            case LEFT_AND_RIGHT_MODE:

                if(j < wnd_num / 2) {
                    merge_stats->channelr_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + j * 2].channelr_xy + left_stats->data[i * wnd_num + j * 2 + 1].channelr_xy) / 2;
                    merge_stats->channelg_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + j * 2].channelg_xy + left_stats->data[i * wnd_num + j * 2 + 1].channelg_xy) / 2;
                    merge_stats->channelb_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + j * 2].channelb_xy + left_stats->data[i * wnd_num + j * 2 + 1].channelb_xy) / 2;
                } else if(j > wnd_num / 2) {
                    merge_stats->channelr_xy[i * wnd_num + j] = (right_stats->data[i * wnd_num + j * 2 - wnd_num].channelr_xy + right_stats->data[i * wnd_num + j * 2 - wnd_num + 1].channelr_xy) / 2;
                    merge_stats->channelg_xy[i * wnd_num + j] = (right_stats->data[i * wnd_num + j * 2 - wnd_num].channelg_xy + right_stats->data[i * wnd_num + j * 2 - wnd_num + 1].channelg_xy) / 2;
                    merge_stats->channelb_xy[i * wnd_num + j] = (right_stats->data[i * wnd_num + j * 2 - wnd_num].channelb_xy + right_stats->data[i * wnd_num + j * 2 - wnd_num + 1].channelb_xy) / 2;
                } else {
                    merge_stats->channelr_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + wnd_num - 1].channelr_xy + right_stats->data[i * wnd_num + 0].channelr_xy) / 2;
                    merge_stats->channelg_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + wnd_num - 1].channelg_xy + right_stats->data[i * wnd_num + 0].channelg_xy) / 2;
                    merge_stats->channelb_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + wnd_num - 1].channelb_xy + right_stats->data[i * wnd_num + 0].channelb_xy) / 2;
                }
                break;
            default:
                break;
            }

            // step2 subtract bls1
            merge_stats->channelr_xy[i * wnd_num + j] = (u16)((merge_stats->channelr_xy[i * wnd_num + j] - bls1_val.r) * bls_ratio[0]);
            merge_stats->channelg_xy[i * wnd_num + j] = (u16)((merge_stats->channelg_xy[i * wnd_num + j] - bls1_val.gr) * bls_ratio[1]);
            merge_stats->channelb_xy[i * wnd_num + j] = (u16)((merge_stats->channelb_xy[i * wnd_num + j] - bls1_val.b) * bls_ratio[2]);

        }
    }
}
void MergeAecWinBigStats(
    rawaebig_stat_t *merge_stats,
    struct isp2x_rawaebig_stat *left_stats,
    struct isp2x_rawaebig_stat *right_stats,
    WinSplitMode mode,
    struct isp2x_bls_fixed_val bls1_val,
    float* bls_ratio
) {
    u8 wnd_num = sqrt(ISP3X_RAWAEBIG_MEAN_NUM);
    for(int i = 0; i < wnd_num; i++) {
        for(int j = 0; j < wnd_num; j++) {

            // step1 copy stats
            switch(mode) {
            case LEFT_MODE:
                merge_stats->channelr_xy[i * wnd_num + j] = left_stats->data[i * wnd_num + j].channelr_xy;
                merge_stats->channelg_xy[i * wnd_num + j] = left_stats->data[i * wnd_num + j].channelg_xy;
                merge_stats->channelb_xy[i * wnd_num + j] = left_stats->data[i * wnd_num + j].channelb_xy;
                break;
            case RIGHT_MODE:
                merge_stats->channelr_xy[i * wnd_num + j] = right_stats->data[i * wnd_num + j].channelr_xy;
                merge_stats->channelg_xy[i * wnd_num + j] = right_stats->data[i * wnd_num + j].channelg_xy;
                merge_stats->channelb_xy[i * wnd_num + j] = right_stats->data[i * wnd_num + j].channelb_xy;
                break;
            case LEFT_AND_RIGHT_MODE:
                if(j < wnd_num / 2) {
                    merge_stats->channelr_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + j * 2].channelr_xy + left_stats->data[i * wnd_num + j * 2 + 1].channelr_xy) / 2;
                    merge_stats->channelg_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + j * 2].channelg_xy + left_stats->data[i * wnd_num + j * 2 + 1].channelg_xy) / 2;
                    merge_stats->channelb_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + j * 2].channelb_xy + left_stats->data[i * wnd_num + j * 2 + 1].channelb_xy) / 2;
                } else if(j > wnd_num / 2) {
                    merge_stats->channelr_xy[i * wnd_num + j] = (right_stats->data[i * wnd_num + j * 2 - wnd_num].channelr_xy + right_stats->data[i * wnd_num + j * 2 - wnd_num + 1].channelr_xy) / 2;
                    merge_stats->channelg_xy[i * wnd_num + j] = (right_stats->data[i * wnd_num + j * 2 - wnd_num].channelg_xy + right_stats->data[i * wnd_num + j * 2 - wnd_num + 1].channelg_xy) / 2;
                    merge_stats->channelb_xy[i * wnd_num + j] = (right_stats->data[i * wnd_num + j * 2 - wnd_num].channelb_xy + right_stats->data[i * wnd_num + j * 2 - wnd_num + 1].channelb_xy) / 2;
                } else {
                    merge_stats->channelr_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + wnd_num - 1].channelr_xy + right_stats->data[i * wnd_num + 0].channelr_xy) / 2;
                    merge_stats->channelg_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + wnd_num - 1].channelg_xy + right_stats->data[i * wnd_num + 0].channelg_xy) / 2;
                    merge_stats->channelb_xy[i * wnd_num + j] = (left_stats->data[i * wnd_num + wnd_num - 1].channelb_xy + right_stats->data[i * wnd_num + 0].channelb_xy) / 2;
                }
                break;
            default:
                break;
            }

            // step2 subtract bls1
            merge_stats->channelr_xy[i * wnd_num + j] = (u16)((merge_stats->channelr_xy[i * wnd_num + j] - bls1_val.r) * bls_ratio[0]);
            merge_stats->channelg_xy[i * wnd_num + j] = (u16)((merge_stats->channelg_xy[i * wnd_num + j] - bls1_val.gr) * bls_ratio[1]);
            merge_stats->channelb_xy[i * wnd_num + j] = (u16)((merge_stats->channelb_xy[i * wnd_num + j] - bls1_val.b) * bls_ratio[2]);

        }
    }

}
void MergeAecSubWinStats(
    rawaebig_stat_t *merge_stats,
    struct isp2x_rawaebig_stat *left_stats,
    struct isp2x_rawaebig_stat *right_stats,
    u8 *left_en,
    u8 *right_en,
    struct isp2x_bls_fixed_val bls1_val,
    float* bls_ratio,
    u32* pixel_num
) {
    for(int i = 0; i < ISP3X_RAWAEBIG_SUBWIN_NUM; i++) {
        // step1 copy stats
        merge_stats->wndx_sumr[i] = ((left_en[i]) ? left_stats->sumr[i] : 0) + ((right_en[i]) ? right_stats->sumr[i] : 0);
        merge_stats->wndx_sumg[i] = ((left_en[i]) ? left_stats->sumg[i] : 0) + ((right_en[i]) ? right_stats->sumg[i] : 0);
        merge_stats->wndx_sumb[i] = ((left_en[i]) ? left_stats->sumb[i] : 0) + ((right_en[i]) ? right_stats->sumb[i] : 0);

        // step2 subtract bls1
        if(left_en[i] == 1 || right_en[i] == 1) {
            merge_stats->wndx_sumr[i] = (u32)((merge_stats->wndx_sumr[i] - (pixel_num[i] >> 2) * bls1_val.r) * bls_ratio[0]);
            merge_stats->wndx_sumg[i] = (u32)((merge_stats->wndx_sumg[i] - (pixel_num[i] >> 1) * bls1_val.gr) * bls_ratio[1]);
            merge_stats->wndx_sumb[i] = (u32)((merge_stats->wndx_sumb[i] - (pixel_num[i] >> 2) * bls1_val.b) * bls_ratio[2]);
        }
    }
}
void MergeAecHistBinStats(
    u32 *merge_stats,
    u32 *left_stats,
    u32 *right_stats,
    WinSplitMode mode,
    s16   bls1_val,
    float bls_ratio
) {
    int tmp;
    memset(merge_stats, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));

    switch(mode) {
    case LEFT_MODE:
        for(int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
            tmp = (i - bls1_val >= 0) ? (i - bls1_val) * bls_ratio + 0.5 : 0;
            if(tmp > ISP3X_HIST_BIN_N_MAX - 1)
                tmp = ISP3X_HIST_BIN_N_MAX - 1;
            merge_stats[tmp] += left_stats[i];
        }
        break;
    case RIGHT_MODE:
        for(int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
            tmp = (i - bls1_val >= 0) ? (i - bls1_val) * bls_ratio + 0.5 : 0;
            if(tmp > ISP3X_HIST_BIN_N_MAX - 1)
                tmp = ISP3X_HIST_BIN_N_MAX - 1;
            merge_stats[tmp] += right_stats[i];
        }
        break;
    case LEFT_AND_RIGHT_MODE:
        for(int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
            tmp = (i - bls1_val >= 0) ? (i - bls1_val) * bls_ratio + 0.5 : 0;
            if(tmp > ISP3X_HIST_BIN_N_MAX - 1)
                tmp = ISP3X_HIST_BIN_N_MAX - 1;
            merge_stats[tmp] += left_stats[i] + right_stats[i];
        }
        break;
    }

}

void MergeAwbWinStats(
    rk_aiq_awb_stat_wp_res_light_v201_t *merge_stats,
    struct isp3x_rawawb_meas_stat *left_stats,
    struct isp3x_rawawb_meas_stat *right_stats,
    int lightNum,
    WinSplitMode mode
) {
    switch(mode) {
    case LEFT_MODE:
        for(int i = 0; i < lightNum; i++) {
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].RgainValue = left_stats->ro_rawawb_sum_rgain_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].BgainValue = left_stats->ro_rawawb_sum_bgain_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].WpNo = left_stats->ro_rawawb_wp_num_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].RgainValue = left_stats->ro_rawawb_sum_rgain_big[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].BgainValue = left_stats->ro_rawawb_sum_bgain_big[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].WpNo = left_stats->ro_rawawb_wp_num_big[i];
        }
        break;
    case RIGHT_MODE:
        for(int i = 0; i < lightNum; i++) {
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].RgainValue = right_stats->ro_rawawb_sum_rgain_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].BgainValue = right_stats->ro_rawawb_sum_bgain_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].WpNo = right_stats->ro_rawawb_wp_num_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].RgainValue = right_stats->ro_rawawb_sum_rgain_big[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].BgainValue = right_stats->ro_rawawb_sum_bgain_big[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].WpNo = right_stats->ro_rawawb_wp_num_big[i];
        }
        break;
    case LEFT_AND_RIGHT_MODE:
        for(int i = 0; i < lightNum; i++) {
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].RgainValue =
                left_stats->ro_rawawb_sum_rgain_nor[i] + right_stats->ro_rawawb_sum_rgain_nor[i] ;
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].BgainValue =
                left_stats->ro_rawawb_sum_bgain_nor[i] +  right_stats->ro_rawawb_sum_bgain_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].WpNo =
                left_stats->ro_rawawb_wp_num_nor[i] +  right_stats->ro_rawawb_wp_num_nor[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].RgainValue =
                left_stats->ro_rawawb_sum_rgain_big[i] +  right_stats->ro_rawawb_sum_rgain_big[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].BgainValue =
                left_stats->ro_rawawb_sum_bgain_big[i] +  right_stats->ro_rawawb_sum_bgain_big[i];
            merge_stats[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].WpNo =
                left_stats->ro_rawawb_wp_num_big[i] +  right_stats->ro_rawawb_wp_num_big[i];
        }
        break;
    default:
        break;
    }
}

void AwbStatOverflowCheckandFixed(struct isp2x_window* win, rk_aiq_awb_blk_stat_mode_v201_t blkMeasureMode, bool blkStatisticsWithLumaWeightEn, rk_aiq_awb_xy_type_v201_t xyRangeTypeForWpHist,
                                  int lightNum, struct isp3x_rawawb_meas_stat *stats)
{
    int w, h;
    w = win->h_size;
    h = win->v_size;
    float factor1 = (float)((1 << (RK_AIQ_AWB_WP_WEIGHT_BIS_V201 + 1)) - 1) / ((1 << RK_AIQ_AWB_WP_WEIGHT_BIS_V201) - 1);
    if(w * h > RK_AIQ_AWB_STAT_MAX_AREA) {
        LOGD_AWB("%s ramdata and ro_wp_num2 is fixed", __FUNCTION__);
        for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
            stats->ramdata[i].wp = (float)stats->ramdata[i].wp * factor1 + 0.5 ;
            stats->ramdata[i].r = (float)stats->ramdata[i].r * factor1 + 0.5 ;
            stats->ramdata[i].g = (float)stats->ramdata[i].g * factor1 + 0.5 ;
            stats->ramdata[i].b = (float)stats->ramdata[i].b * factor1 + 0.5 ;
        }
        if(xyRangeTypeForWpHist == RK_AIQ_AWB_XY_TYPE_BIG_V201) {
            for(int i = 0; i < lightNum; i++) {
                stats->ro_wp_num2[i] = stats->ro_rawawb_wp_num_big[i] >> RK_AIQ_WP_GAIN_FRAC_BIS;
            }
        } else {
            for(int i = 0; i < lightNum; i++) {
                stats->ro_wp_num2[i] = stats->ro_rawawb_wp_num_nor[i] >> RK_AIQ_WP_GAIN_FRAC_BIS;
            }
        }
    } else {
        if(RK_AIQ_AWB_BLK_STAT_MODE_REALWP_V201 == blkMeasureMode && blkStatisticsWithLumaWeightEn) {
            for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
                stats->ramdata[i].wp = (float)stats->ramdata[i].wp * factor1 + 0.5 ;
                stats->ramdata[i].r = (float)stats->ramdata[i].r * factor1 + 0.5 ;
                stats->ramdata[i].g = (float)stats->ramdata[i].g * factor1 + 0.5 ;
                stats->ramdata[i].b = (float)stats->ramdata[i].b * factor1 + 0.5 ;
            }
        }
    }
}

void MergeAwbBlkStats(
    struct isp2x_window* ori_win,
    struct isp2x_window* left_win,
    struct isp2x_window* right_win,
    rk_aiq_awb_stat_blk_res_v201_t *merge_stats,
    struct isp3x_rawawb_meas_stat *left_stats,
    struct isp3x_rawawb_meas_stat *right_stats,
    WinSplitMode mode
) {
    u8 wnd_num = sqrt(RK_AIQ_AWB_GRID_NUM_TOTAL);

    switch(mode) {
    case LEFT_MODE:
        for(int i = 0; i < wnd_num; i++) {
            for(int j = 0; j < wnd_num; j++) {
                merge_stats[i * wnd_num + j].Rvalue = left_stats->ramdata[i * wnd_num + j].r;
                merge_stats[i * wnd_num + j].Gvalue = left_stats->ramdata[i * wnd_num + j].g;
                merge_stats[i * wnd_num + j].Bvalue = left_stats->ramdata[i * wnd_num + j].b;
                merge_stats[i * wnd_num + j].WpNo = left_stats->ramdata[i * wnd_num + j].wp;
            }
        }
        break;
    case RIGHT_MODE:
        for(int i = 0; i < wnd_num; i++) {
            for(int j = 0; j < wnd_num; j++) {
                merge_stats[i * wnd_num + j].Rvalue = right_stats->ramdata[i * wnd_num + j].r;
                merge_stats[i * wnd_num + j].Gvalue = right_stats->ramdata[i * wnd_num + j].g;
                merge_stats[i * wnd_num + j].Bvalue = right_stats->ramdata[i * wnd_num + j].b;
                merge_stats[i * wnd_num + j].WpNo = right_stats->ramdata[i * wnd_num + j].wp;
            }
        }
        break;
    case LEFT_AND_RIGHT_MODE:
        for(int i = 0; i < wnd_num; i++) {
            for(int j = 0; j < wnd_num; j++) {
                if(j < wnd_num / 2) {
                    merge_stats[i * wnd_num + j].Rvalue = left_stats->ramdata[i * wnd_num + j * 2].r + left_stats->ramdata[i * wnd_num + j * 2 + 1].r;
                    merge_stats[i * wnd_num + j].Gvalue = left_stats->ramdata[i * wnd_num + j * 2].g + left_stats->ramdata[i * wnd_num + j * 2 + 1].g;
                    merge_stats[i * wnd_num + j].Bvalue = left_stats->ramdata[i * wnd_num + j * 2].b +  left_stats->ramdata[i * wnd_num + j * 2 + 1].b;
                    merge_stats[i * wnd_num + j].WpNo = left_stats->ramdata[i * wnd_num + j * 2].wp + left_stats->ramdata[i * wnd_num + j * 2 + 1].wp;
                } else if(j > wnd_num / 2) {
                    merge_stats[i * wnd_num + j].Rvalue = right_stats->ramdata[i * wnd_num + j * 2 - wnd_num].r + right_stats->ramdata[i * wnd_num + j * 2 - wnd_num + 1].r;
                    merge_stats[i * wnd_num + j].Gvalue = right_stats->ramdata[i * wnd_num + j * 2 - wnd_num].g + right_stats->ramdata[i * wnd_num + j * 2 - wnd_num + 1].g;
                    merge_stats[i * wnd_num + j].Bvalue = right_stats->ramdata[i * wnd_num + j * 2 - wnd_num].b + right_stats->ramdata[i * wnd_num + j * 2 - wnd_num + 1].b;
                    merge_stats[i * wnd_num + j].WpNo = right_stats->ramdata[i * wnd_num + j * 2 - wnd_num].wp + right_stats->ramdata[i * wnd_num + j * 2 - wnd_num + 1].wp;
                } else {
                    merge_stats[i * wnd_num + j].Rvalue = left_stats->ramdata[i * wnd_num + wnd_num - 1].r + right_stats->ramdata[i * wnd_num + 0].r;
                    merge_stats[i * wnd_num + j].Gvalue = left_stats->ramdata[i * wnd_num + wnd_num - 1].g + right_stats->ramdata[i * wnd_num + 0].g;
                    merge_stats[i * wnd_num + j].Bvalue = left_stats->ramdata[i * wnd_num + wnd_num - 1].b + right_stats->ramdata[i * wnd_num + 0].b;
                    merge_stats[i * wnd_num + j].WpNo = left_stats->ramdata[i * wnd_num + wnd_num - 1].wp + right_stats->ramdata[i * wnd_num + 0].wp;
                }
            }
        }
        break;
    default:
        break;
    }

}

void MergeAwbHistBinStats(
    unsigned int *merge_stats,
    u16 *left_stats,
    u16 *right_stats,
    WinSplitMode mode
) {
    u32 tmp1, tmp2;
    switch(mode) {
    case LEFT_MODE:
        for(int i = 0; i < RK_AIQ_AWB_WP_HIST_BIN_NUM; i++) {
            tmp1 = left_stats[i];
            if(left_stats[i] & 0x8000) {
                tmp1 = left_stats[i] & 0x7FFF;
                tmp1 *=    (1 << 3);
            }
            merge_stats[i] = tmp1;
        }
        break;
    case RIGHT_MODE:
        for(int i = 0; i < RK_AIQ_AWB_WP_HIST_BIN_NUM; i++) {
            tmp2 = right_stats[i];
            if(right_stats[i] & 0x8000) {
                tmp2 = right_stats[i] & 0x7FFF;
                tmp2 *=    (1 << 3);
            }
            merge_stats[i] = tmp2;
        }

        break;
    case LEFT_AND_RIGHT_MODE:
        for(int i = 0; i < RK_AIQ_AWB_WP_HIST_BIN_NUM; i++) {
            tmp1 = left_stats[i];
            if(left_stats[i] & 0x8000) {
                tmp1 = left_stats[i] & 0x7FFF;
                tmp1 *=    (1 << 3);
            }
            tmp2 = right_stats[i];
            if(right_stats[i] & 0x8000) {
                tmp2 = right_stats[i] & 0x7FFF;
                tmp2 *=    (1 << 3);
            }
            merge_stats[i] = tmp1 + tmp2;

        }
        break;
    }
}

#if defined(ISP_HW_V30)

void MergeAwbMultiWinStats(
    rk_aiq_isp_awb_stats_v3x_t *merge_stats,
    struct isp3x_rawawb_meas_stat *left_stats,
    struct isp3x_rawawb_meas_stat *right_stats
) {
    for(int i = 0; i < RK_AIQ_AWB_MULTIWINDOW_NUM_V201; i++) {

        merge_stats->multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].RgainValue =
            left_stats->ro_sum_r_nor_multiwindow[i] + right_stats->ro_sum_r_nor_multiwindow[i];
        merge_stats->multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].BgainValue =
            left_stats->ro_sum_b_nor_multiwindow[i] + right_stats->ro_sum_b_nor_multiwindow[i];
        merge_stats->multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].WpNo =
            left_stats->ro_wp_nm_nor_multiwindow[i] + right_stats->ro_wp_nm_nor_multiwindow[i];
        merge_stats->multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].RgainValue =
            left_stats->ro_sum_r_big_multiwindow[i] + right_stats->ro_sum_r_big_multiwindow[i];
        merge_stats->multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].BgainValue =
            left_stats->ro_sum_b_big_multiwindow[i] + right_stats->ro_sum_b_big_multiwindow[i];
        merge_stats->multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].WpNo =
            left_stats->ro_wp_nm_big_multiwindow[i] + right_stats->ro_wp_nm_big_multiwindow[i];

    }
}

void MergeAwbExcWpStats(
    rk_aiq_awb_stat_wp_res_v201_t*merge_stats,
    isp3x_rawawb_meas_stat *left_stats,
    isp3x_rawawb_meas_stat *right_stats,
    WinSplitMode mode
) {
    switch(mode) {
    case LEFT_MODE:
        for(int i = 0; i < RK_AIQ_AWB_STAT_WP_RANGE_NUM_V201; i++) {
            merge_stats[i].RgainValue = left_stats->ro_sum_r_exc[i];
            merge_stats[i].RgainValue = left_stats->ro_sum_b_exc[i];
            merge_stats[i].RgainValue = left_stats->ro_wp_nm_exc[i];
        }
        break;
    case RIGHT_MODE:
        for(int i = 0; i < RK_AIQ_AWB_STAT_WP_RANGE_NUM_V201; i++) {
            merge_stats[i].RgainValue = right_stats->ro_sum_r_exc[i];
            merge_stats[i].RgainValue = right_stats->ro_sum_b_exc[i];
            merge_stats[i].RgainValue = right_stats->ro_wp_nm_exc[i];
        }
        break;
    case LEFT_AND_RIGHT_MODE:
        for(int i = 0; i < RK_AIQ_AWB_STAT_WP_RANGE_NUM_V201; i++) {
            merge_stats[i].RgainValue = left_stats->ro_sum_r_exc[i] + right_stats->ro_sum_r_exc[i];
            merge_stats[i].RgainValue = left_stats->ro_sum_b_exc[i] + right_stats->ro_sum_b_exc[i];
            merge_stats[i].RgainValue = left_stats->ro_wp_nm_exc[i] + right_stats->ro_sum_b_exc[i];
        }
        break;
    }
}
#endif

XCamReturn
RkAiqResourceTranslatorV3x::translateMultiAecStats(const SmartPtr<VideoBuffer>& from, SmartPtr<RkAiqAecStatsProxy>& to)
{

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();

    SmartPtr<RkAiqAecStats> statsInt = to->data();

    struct rkisp3x_isp_stat_buffer *left_stats;
    struct rkisp3x_isp_stat_buffer *right_stats;

    left_stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if(left_stats == NULL) {
        LOGE("fail to get left stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    right_stats = left_stats + 1;
    if(right_stats == NULL) {
        LOGE("fail to get right stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    if(left_stats->frame_id != right_stats->frame_id || left_stats->meas_type != right_stats->meas_type)
        LOGE_ANALYZER("status params(frmid or meas_type) of left isp and right isp are different");
    else
        LOGD_ANALYZER("camId: %d, stats: frame_id: %d,  meas_type; 0x%x", mCamPhyId, left_stats->frame_id, left_stats->meas_type);

    SmartPtr<RkAiqIrisParamsProxy> irisParams = buf->get_iris_params();
    SmartPtr<RkAiqExpParamsProxy> expParams = nullptr;
    rkisp_effect_params_v20 ispParams = {0};
    if (buf->getEffectiveExpParams(left_stats->frame_id, expParams) < 0)
        LOGE("fail to get expParams");
    if (buf->getEffectiveIspParams(left_stats->frame_id, ispParams) < 0) {
        LOGE("fail to get ispParams ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    //ae stats v3.x

    statsInt->frame_id = left_stats->frame_id;

    /*rawae stats*/
    uint8_t AeSwapMode, AeSelMode, AfUseAeBig;
    AeSwapMode = ispParams.isp_params_v3x[0].meas.rawae0.rawae_sel;
    AeSelMode = ispParams.isp_params_v3x[0].meas.rawae3.rawae_sel;
    AfUseAeBig = ispParams.isp_params_v3x[0].meas.rawaf.ae_mode;
    unsigned int meas_type = 0;

    WinSplitMode AeWinSplitMode[4] = {LEFT_AND_RIGHT_MODE}; //0:rawae0 1:rawae1 2:rawae2 3:rawae3
    WinSplitMode HistWinSplitMode[4] = {LEFT_AND_RIGHT_MODE}; //0:rawhist0 1:rawhist1 2:rawhist2 3:rawhist3

    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawae0.win, AeWinSplitMode[0], left_isp_rect_, right_isp_rect_);
    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawae1.win, AeWinSplitMode[1], left_isp_rect_, right_isp_rect_);
    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawae2.win, AeWinSplitMode[2], left_isp_rect_, right_isp_rect_);
    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawae3.win, AeWinSplitMode[3], left_isp_rect_, right_isp_rect_);

    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawhist0.win, HistWinSplitMode[0], left_isp_rect_, right_isp_rect_);
    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawhist1.win, HistWinSplitMode[1], left_isp_rect_, right_isp_rect_);
    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawhist2.win, HistWinSplitMode[2], left_isp_rect_, right_isp_rect_);
    JudgeWinLocation(&ispParams.isp_params_v3x[0].meas.rawhist3.win, HistWinSplitMode[3], left_isp_rect_, right_isp_rect_);

    struct isp21_bls_cfg *bls_cfg = &ispParams.isp_params_v3x[0].others.bls_cfg;
    struct isp2x_bls_fixed_val bls1_val; //bls1_val = blc1_ori_val * awb * range_ratio
    float bls_ratio[3] = {1, 1, 1};
    u32 pixel_num[ISP3X_RAWAEBIG_SUBWIN_NUM] = {0};

    if(bls_cfg->bls1_en) {

        bls1_val.r = bls_cfg->bls1_val.r >> 2;
        bls1_val.gr = bls_cfg->bls1_val.gr;
        bls1_val.gb = bls_cfg->bls1_val.gb;
        bls1_val.b = bls_cfg->bls1_val.b >> 2;

        bls_ratio[0] = (float)((1 << 12) - 1) / ((1 << 12) - 1 - bls_cfg->bls1_val.r);
        bls_ratio[1] = (float)((1 << 12) - 1) / ((1 << 12) - 1 - bls_cfg->bls1_val.gr);
        bls_ratio[2] = (float)((1 << 12) - 1) / ((1 << 12) - 1 - bls_cfg->bls1_val.b);

    } else {

        bls1_val.r = 0;
        bls1_val.gr = 0;
        bls1_val.gb = 0;
        bls1_val.b = 0;

    }

#ifdef AE_STATS_DEBUG
    LOGE("bls1[%d-%d-%d-%d]", bls1_val.r, bls1_val.gr, bls1_val.gb, bls1_val.b);
    LOGE("bls_ratio[%f-%f-%f]", bls_ratio[0], bls_ratio[1], bls_ratio[2]);
#endif

    s16   hist_bls1;
    float hist_bls_ratio;

    switch(AeSwapMode)
    {
    case AEC_RAWSWAP_MODE_S_LITE:

        switch(ispParams.isp_params_v3x[0].meas.rawhist0.mode) {
        case 2:
            hist_bls1 = (bls1_val.r >> 2);
            hist_bls_ratio = bls_ratio[0];
            break;
        case 3:
            hist_bls1 = (bls1_val.gr >> 4);
            hist_bls_ratio = bls_ratio[1];
            break;
        case 4:
            hist_bls1 = (bls1_val.b >> 2);
            hist_bls_ratio = bls_ratio[2];
            break;
        case 5:
        default:
            hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
            hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
            break;
        }

        meas_type = ((left_stats->meas_type >> 7) & (0x01)) & ((left_stats->meas_type >> 11) & (0x01));
        statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;

        //chn 0 => rawae0 rawhist0
        MergeAecWinLiteStats(&statsInt->aec_stats.ae_data.chn[0].rawae_lite, &left_stats->params.rawae0, &right_stats->params.rawae0, AeWinSplitMode[0], bls1_val, bls_ratio);
        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins, left_stats->params.rawhist0.hist_bin,
                             right_stats->params.rawhist0.hist_bin, HistWinSplitMode[0], hist_bls1, hist_bls_ratio);

        //chn 1 => rawae1 rawhist1
        MergeAecWinBigStats(&statsInt->aec_stats.ae_data.chn[1].rawae_big, &left_stats->params.rawae1, &right_stats->params.rawae1, AeWinSplitMode[1], bls1_val, bls_ratio);
        pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[0].v_size;
        pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[1].v_size;
        pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[2].v_size;
        pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[3].v_size;
        MergeAecSubWinStats(&statsInt->aec_stats.ae_data.chn[1].rawae_big, &left_stats->params.rawae1, &right_stats->params.rawae1,
                            ispParams.isp_params_v3x[1].meas.rawae1.subwin_en, ispParams.isp_params_v3x[2].meas.rawae1.subwin_en,
                            bls1_val, bls_ratio, pixel_num);

        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins, left_stats->params.rawhist1.hist_bin,
                             right_stats->params.rawhist1.hist_bin, HistWinSplitMode[1], hist_bls1, hist_bls_ratio);


        //chn 2 => rawae2 rawhist2
        MergeAecWinBigStats(&statsInt->aec_stats.ae_data.chn[2].rawae_big, &left_stats->params.rawae2, &right_stats->params.rawae2, AeWinSplitMode[2], bls1_val, bls_ratio);
        pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[0].v_size;
        pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[1].v_size;
        pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[2].v_size;
        pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[3].v_size;

        MergeAecSubWinStats(&statsInt->aec_stats.ae_data.chn[2].rawae_big, &left_stats->params.rawae2, &right_stats->params.rawae2,
                            ispParams.isp_params_v3x[1].meas.rawae2.subwin_en, ispParams.isp_params_v3x[2].meas.rawae2.subwin_en,
                            bls1_val, bls_ratio, pixel_num);


        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[2].rawhist_big.bins, left_stats->params.rawhist2.hist_bin,
                             right_stats->params.rawhist2.hist_bin, HistWinSplitMode[2], hist_bls1, hist_bls_ratio);

        break;

    case AEC_RAWSWAP_MODE_M_LITE:
        switch(ispParams.isp_params_v3x[0].meas.rawhist1.mode) {
        case 2:
            hist_bls1 = (bls1_val.r >> 2);
            hist_bls_ratio = bls_ratio[0];
            break;
        case 3:
            hist_bls1 = (bls1_val.gr >> 4);
            hist_bls_ratio = bls_ratio[1];
            break;
        case 4:
            hist_bls1 = (bls1_val.b >> 2);
            hist_bls_ratio = bls_ratio[2];
            break;
        case 5:
        default:
            hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
            hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
            break;
        }

        meas_type = ((left_stats->meas_type >> 8) & (0x01)) & ((left_stats->meas_type >> 12) & (0x01));
        statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;

        //chn 0 => rawae1 rawhist1
        MergeAecWinBigStats(&statsInt->aec_stats.ae_data.chn[0].rawae_big, &left_stats->params.rawae1, &right_stats->params.rawae1, AeWinSplitMode[1], bls1_val, bls_ratio);

        pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[0].v_size;
        pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[1].v_size;
        pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[2].v_size;
        pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[3].v_size;

        MergeAecSubWinStats(&statsInt->aec_stats.ae_data.chn[0].rawae_big, &left_stats->params.rawae1, &right_stats->params.rawae1,
                            ispParams.isp_params_v3x[1].meas.rawae1.subwin_en, ispParams.isp_params_v3x[2].meas.rawae1.subwin_en,
                            bls1_val, bls_ratio, pixel_num);
        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins, left_stats->params.rawhist1.hist_bin,
                             right_stats->params.rawhist1.hist_bin, HistWinSplitMode[1], hist_bls1, hist_bls_ratio);

        //chn 1 => rawae0 rawhist0
        MergeAecWinLiteStats(&statsInt->aec_stats.ae_data.chn[1].rawae_lite, &left_stats->params.rawae0, &right_stats->params.rawae0, AeWinSplitMode[0], bls1_val, bls_ratio);
        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[1].rawhist_lite.bins, left_stats->params.rawhist0.hist_bin,
                             right_stats->params.rawhist0.hist_bin, HistWinSplitMode[0], hist_bls1, hist_bls_ratio);

        //chn 2 => rawae2 rawhist2
        MergeAecWinBigStats(&statsInt->aec_stats.ae_data.chn[2].rawae_big, &left_stats->params.rawae2, &right_stats->params.rawae2, AeWinSplitMode[2], bls1_val, bls_ratio);

        pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[0].v_size;
        pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[1].v_size;
        pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[2].v_size;
        pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[3].v_size;

        MergeAecSubWinStats(&statsInt->aec_stats.ae_data.chn[2].rawae_big, &left_stats->params.rawae2, &right_stats->params.rawae2,
                            ispParams.isp_params_v3x[1].meas.rawae2.subwin_en, ispParams.isp_params_v3x[2].meas.rawae2.subwin_en,
                            bls1_val, bls_ratio, pixel_num);
        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[2].rawhist_big.bins, left_stats->params.rawhist2.hist_bin,
                             right_stats->params.rawhist2.hist_bin, HistWinSplitMode[2], hist_bls1, hist_bls_ratio);

        break;

    case AEC_RAWSWAP_MODE_L_LITE:
        switch(ispParams.isp_params_v3x[0].meas.rawhist2.mode) {
        case 2:
            hist_bls1 = (bls1_val.r >> 2);
            hist_bls_ratio = bls_ratio[0];
            break;
        case 3:
            hist_bls1 = (bls1_val.gr >> 4);
            hist_bls_ratio = bls_ratio[1];
            break;
        case 4:
            hist_bls1 = (bls1_val.b >> 2);
            hist_bls_ratio = bls_ratio[2];
            break;
        case 5:
        default:
            hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
            hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
            break;
        }

        meas_type = ((left_stats->meas_type >> 9) & (0x01)) & ((left_stats->meas_type >> 13) & (0x01));
        statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;

        //chn 0 => rawae2 rawhist2
        MergeAecWinBigStats(&statsInt->aec_stats.ae_data.chn[0].rawae_big, &left_stats->params.rawae2, &right_stats->params.rawae2, AeWinSplitMode[2], bls1_val, bls_ratio);
        pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[0].v_size;
        pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[1].v_size;
        pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[2].v_size;
        pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae2.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae2.subwin[3].v_size;
        MergeAecSubWinStats(&statsInt->aec_stats.ae_data.chn[0].rawae_big, &left_stats->params.rawae2, &right_stats->params.rawae2,
                            ispParams.isp_params_v3x[1].meas.rawae2.subwin_en, ispParams.isp_params_v3x[2].meas.rawae2.subwin_en,
                            bls1_val, bls_ratio, pixel_num);
        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins, left_stats->params.rawhist2.hist_bin,
                             right_stats->params.rawhist2.hist_bin, HistWinSplitMode[2], hist_bls1, hist_bls_ratio);

        //chn 1 => rawae1 rawhist1
        MergeAecWinBigStats(&statsInt->aec_stats.ae_data.chn[1].rawae_big, &left_stats->params.rawae1, &right_stats->params.rawae1, AeWinSplitMode[1], bls1_val, bls_ratio);

        pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[0].v_size;
        pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[1].v_size;
        pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[2].v_size;
        pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae1.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae1.subwin[3].v_size;
        MergeAecSubWinStats(&statsInt->aec_stats.ae_data.chn[1].rawae_big, &left_stats->params.rawae1, &right_stats->params.rawae1,
                            ispParams.isp_params_v3x[1].meas.rawae1.subwin_en, ispParams.isp_params_v3x[2].meas.rawae1.subwin_en,
                            bls1_val, bls_ratio, pixel_num);
        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins, left_stats->params.rawhist1.hist_bin,
                             right_stats->params.rawhist1.hist_bin, HistWinSplitMode[1], hist_bls1, hist_bls_ratio);

        //chn 2 => rawae0 rawhist0
        MergeAecWinLiteStats(&statsInt->aec_stats.ae_data.chn[2].rawae_lite, &left_stats->params.rawae0, &right_stats->params.rawae0, AeWinSplitMode[0], bls1_val, bls_ratio);
        MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[2].rawhist_lite.bins, left_stats->params.rawhist0.hist_bin,
                             right_stats->params.rawhist0.hist_bin, HistWinSplitMode[0], hist_bls1, hist_bls_ratio);

        break;

    default:
        LOGE("wrong AeSwapMode=%d\n", AeSwapMode);
        return XCAM_RETURN_ERROR_PARAM;
        break;
    }

    statsInt->af_prior = (AfUseAeBig == 0) ? false : true;

    if(!AfUseAeBig) {
        switch(AeSelMode) {
        case AEC_RAWSEL_MODE_CHN_0:
        case AEC_RAWSEL_MODE_CHN_1:
        case AEC_RAWSEL_MODE_CHN_2:
            //chn 0 => rawae3 rawhist3
            switch(ispParams.isp_params_v3x[0].meas.rawhist3.mode) {
            case 2:
                hist_bls1 = (bls1_val.r >> 2);
                hist_bls_ratio = bls_ratio[0];
                break;
            case 3:
                hist_bls1 = (bls1_val.gr >> 4);
                hist_bls_ratio = bls_ratio[1];
                break;
            case 4:
                hist_bls1 = (bls1_val.b >> 2);
                hist_bls_ratio = bls_ratio[2];
                break;
            case 5:
            default:
                hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
                hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
                break;
            }

            MergeAecWinBigStats(&statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big, &left_stats->params.rawae3, &right_stats->params.rawae3, AeWinSplitMode[3], bls1_val, bls_ratio);
            pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[0].v_size;
            pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[1].v_size;
            pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[2].v_size;
            pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[3].v_size;
            MergeAecSubWinStats(&statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big, &left_stats->params.rawae3, &right_stats->params.rawae3,
                                ispParams.isp_params_v3x[1].meas.rawae3.subwin_en, ispParams.isp_params_v3x[2].meas.rawae3.subwin_en,
                                bls1_val, bls_ratio, pixel_num);

            MergeAecHistBinStats(statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins, left_stats->params.rawhist3.hist_bin,
                                 right_stats->params.rawhist3.hist_bin, HistWinSplitMode[3], hist_bls1, hist_bls_ratio);

            break;
        case AEC_RAWSEL_MODE_TMO:

            bls1_val.r = 0;
            bls1_val.gr = 0;
            bls1_val.gb = 0;
            bls1_val.b = 0;

            bls_ratio[0] = 1;
            bls_ratio[1] = 1;
            bls_ratio[2] = 1;

            //extra => rawae3 rawhist3
            MergeAecWinBigStats(&statsInt->aec_stats.ae_data.extra.rawae_big, &left_stats->params.rawae3, &right_stats->params.rawae3, AeWinSplitMode[3], bls1_val, bls_ratio);
            pixel_num[0] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[0].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[0].v_size;
            pixel_num[1] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[1].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[1].v_size;
            pixel_num[2] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[2].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[2].v_size;
            pixel_num[3] = ispParams.isp_params_v3x[0].meas.rawae3.subwin[3].h_size * ispParams.isp_params_v3x[0].meas.rawae3.subwin[3].v_size;
            MergeAecSubWinStats(&statsInt->aec_stats.ae_data.extra.rawae_big, &left_stats->params.rawae3, &right_stats->params.rawae3,
                                ispParams.isp_params_v3x[1].meas.rawae3.subwin_en, ispParams.isp_params_v3x[2].meas.rawae3.subwin_en,
                                bls1_val, bls_ratio, pixel_num);
            hist_bls1 = 0;
            hist_bls_ratio = 1;

            MergeAecHistBinStats(statsInt->aec_stats.ae_data.extra.rawhist_big.bins, left_stats->params.rawhist3.hist_bin,
                                 right_stats->params.rawhist3.hist_bin, HistWinSplitMode[3], hist_bls1, hist_bls_ratio);

            break;

        default:
            LOGE("wrong AeSelMode=%d\n", AeSelMode);
            return XCAM_RETURN_ERROR_PARAM;
        }
    }

#ifdef AE_STATS_DEBUG
    if(AeSwapMode != 0) {
        for(int i = 0; i < 15; i++) {
            for(int j = 0; j < 15; j++) {
                printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
                       statsInt->aec_stats.ae_data.chn[0].rawae_big.channelr_xy[i * 15 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_big.channelg_xy[i * 15 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_big.channelb_xy[i * 15 + j]);
            }
        }
        printf("====================sub-win-result======================\n");

        for(int i = 0; i < 4; i++)
            printf("chn0_subwin[%d]:sumr 0x%08lx, sumg 0x%08lx, sumb 0x%08lx\n", i,
                   statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumr[i],
                   statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumg[i],
                   statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumb[i]);

        printf("====================hist_result========================\n");
        for(int i = 0; i < 256; i++)
            printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins[i]);

    } else {
        for(int i = 0; i < 5; i++) {
            for(int j = 0; j < 5; j++) {
                printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
                       statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelr_xy[i * 5 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelg_xy[i * 5 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelb_xy[i * 5 + j]);
            }
        }

        printf("====================hist_result========================\n");
        for(int i = 0; i < 256; i++)
            printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins[i]);

    }
#endif

    //expsoure params
    if (expParams.ptr()) {

        statsInt->aec_stats.ae_exp = expParams->data()->aecExpInfo;

        /*
         * printf("%s: L: [0x%x-0x%x], M: [0x%x-0x%x], S: [0x%x-0x%x]\n",
         *        __func__,
         *        expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
         *        expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
         *        expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
         *        expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
         *        expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time,
         *        expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global);
         */
    }

    //iris params
    if (irisParams.ptr()) {

        float sof_time = (float)irisParams->data()->sofTime / 1000000000.0f;
        float start_time = (float)irisParams->data()->PIris.StartTim.tv_sec + (float)irisParams->data()->PIris.StartTim.tv_usec / 1000000.0f;
        float end_time = (float)irisParams->data()->PIris.EndTim.tv_sec + (float)irisParams->data()->PIris.EndTim.tv_usec / 1000000.0f;
        float frm_intval = 1 / (statsInt->aec_stats.ae_exp.pixel_clock_freq_mhz * 1000000.0f /
                                (float)statsInt->aec_stats.ae_exp.line_length_pixels / (float)statsInt->aec_stats.ae_exp.frame_length_lines);

        /*printf("%s: step=%d,last-step=%d,start-tim=%f,end-tim=%f,sof_tim=%f\n",
            __func__,
            statsInt->aec_stats.ae_exp.Iris.PIris.step,
            irisParams->data()->PIris.laststep,start_time,end_time,sof_time);
        */

        if(sof_time < end_time + frm_intval)
            statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.laststep;
        else
            statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.step;
    }

    to->set_sequence(left_stats->frame_id);

    return ret;

}

XCamReturn RkAiqResourceTranslatorV3x::translateMultiAwbStats(const SmartPtr<VideoBuffer>& from, SmartPtr<RkAiqAwbStatsProxy>& to)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();

    SmartPtr<RkAiqAwbStats> statsInt = to->data();

    struct rkisp3x_isp_stat_buffer *left_stats;
    struct rkisp3x_isp_stat_buffer *right_stats;

    left_stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if(left_stats == NULL) {
        LOGE("fail to get left stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    right_stats = left_stats + 1;
    if(right_stats == NULL) {
        LOGE("fail to get right stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    if(left_stats->frame_id != right_stats->frame_id || left_stats->meas_type != right_stats->meas_type)
        LOGE_ANALYZER("status params(frmid or meas_type) of left isp and right isp are different");
    else
        LOGI_ANALYZER("stats: frame_id: %d,  meas_type; 0x%x", left_stats->frame_id, left_stats->meas_type);


    statsInt->awb_stats_valid = left_stats->meas_type >> 5 & 1;
    if (!statsInt->awb_stats_valid) {
        LOGE_ANALYZER("AWB stats invalid, ignore");
        return XCAM_RETURN_BYPASS;
    }

    rkisp_effect_params_v20 ispParams = {0};
    if (buf->getEffectiveIspParams(left_stats->frame_id, ispParams) < 0) {
        LOGE("fail to get ispParams ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }
    rk_aiq_isp_blc_t *bls_cfg = &ispParams.blc_cfg.v0;
    statsInt->blc_cfg_effect = ispParams.blc_cfg.v0;
    //awb30
    statsInt->awb_stats_v3x.awb_cfg_effect_v201 = ispParams.awb_cfg_v3x;
    statsInt->awb_cfg_effect_valid = true;
    statsInt->frame_id = left_stats->frame_id;

    WinSplitMode AwbWinSplitMode = LEFT_AND_RIGHT_MODE;

    struct isp2x_window ori_win;
    ori_win.h_offs = ispParams.isp_params_v3x[0].meas.rawawb.sw_rawawb_h_offs;
    ori_win.h_size = ispParams.isp_params_v3x[0].meas.rawawb.sw_rawawb_h_size;
    ori_win.v_offs = ispParams.isp_params_v3x[0].meas.rawawb.sw_rawawb_v_offs;
    ori_win.v_size = ispParams.isp_params_v3x[0].meas.rawawb.sw_rawawb_v_size;

    JudgeWinLocation(&ori_win, AwbWinSplitMode, left_isp_rect_, right_isp_rect_);

    MergeAwbWinStats(statsInt->awb_stats_v3x.light, &left_stats->params.rawawb, &right_stats->params.rawawb,
                     statsInt->awb_stats_v3x.awb_cfg_effect_v201.lightNum, AwbWinSplitMode);

    struct isp2x_window left_win;
    left_win.h_offs = ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_h_offs;
    left_win.h_size = ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_h_size;
    left_win.v_offs = ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_v_offs;
    left_win.v_size = ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_v_size;

    struct isp2x_window right_win;
    right_win.h_offs = ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_h_offs;
    right_win.h_size = ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_h_size;
    right_win.v_offs = ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_v_offs;
    right_win.v_size = ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_v_size;

    // to fixed the bug in ic design that some egisters maybe overflow
    AwbStatOverflowCheckandFixed(&left_win,
                                 (rk_aiq_awb_blk_stat_mode_v201_t)ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_blk_measure_mode,
                                 ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_blk_with_luma_wei_en,
                                 (rk_aiq_awb_xy_type_v201_t)ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_wp_hist_xytype,
                                 ispParams.isp_params_v3x[1].meas.rawawb.sw_rawawb_light_num, &left_stats->params.rawawb);
    AwbStatOverflowCheckandFixed(&right_win,
                                 (rk_aiq_awb_blk_stat_mode_v201_t)ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_blk_measure_mode,
                                 ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_blk_with_luma_wei_en,
                                 (rk_aiq_awb_xy_type_v201_t)ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_wp_hist_xytype,
                                 ispParams.isp_params_v3x[2].meas.rawawb.sw_rawawb_light_num, &right_stats->params.rawawb);


    MergeAwbBlkStats(&ori_win, &left_win, &right_win, statsInt->awb_stats_v3x.blockResult, &left_stats->params.rawawb, &right_stats->params.rawawb, AwbWinSplitMode);

    MergeAwbHistBinStats(statsInt->awb_stats_v3x.WpNoHist, left_stats->params.rawawb.ro_yhist_bin, right_stats->params.rawawb.ro_yhist_bin, AwbWinSplitMode);

#if defined(ISP_HW_V30)
    switch(AwbWinSplitMode) {
    case LEFT_MODE:
        for(int i = 0; i < statsInt->awb_stats_v3x.awb_cfg_effect_v201.lightNum; i++)
            statsInt->awb_stats_v3x.WpNo2[i] = left_stats->params.rawawb.ro_wp_num2[i];
        break;
    case RIGHT_MODE:
        for(int i = 0; i < statsInt->awb_stats_v3x.awb_cfg_effect_v201.lightNum; i++)
            statsInt->awb_stats_v3x.WpNo2[i] = right_stats->params.rawawb.ro_wp_num2[i];
        break;
    case LEFT_AND_RIGHT_MODE:
        for(int i = 0; i < statsInt->awb_stats_v3x.awb_cfg_effect_v201.lightNum; i++)
            statsInt->awb_stats_v3x.WpNo2[i] = left_stats->params.rawawb.ro_wp_num2[i] + right_stats->params.rawawb.ro_wp_num2[i];
        break;
    default:
        break;
    }

    MergeAwbMultiWinStats(&statsInt->awb_stats_v3x, &left_stats->params.rawawb, &right_stats->params.rawawb);
    MergeAwbExcWpStats( statsInt->awb_stats_v3x.excWpRangeResult, &left_stats->params.rawawb, &right_stats->params.rawawb, AwbWinSplitMode);

#endif

    LOG1_AWB("bls_cfg %p", bls_cfg);
    if(bls_cfg) {
        LOG1_AWB("bls1_enalbe: %d, b r gb gr:[ %d %d %d %d]", bls_cfg->blc1_enable, bls_cfg->blc1_b,
                 bls_cfg->blc1_r, bls_cfg->blc1_gb, bls_cfg->blc1_gr);
    }
    if(bls_cfg && bls_cfg->blc1_enable && (bls_cfg->blc1_b > 0 || bls_cfg->blc1_r > 0 || bls_cfg->blc1_gb > 0 || bls_cfg->blc1_gr > 0)) {

        for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
            statsInt->awb_stats_v3x.blockResult[i].Rvalue -=  (statsInt->awb_stats_v3x.blockResult[i].WpNo * bls_cfg->blc1_r + 8) >> 4 ;
            statsInt->awb_stats_v3x.blockResult[i].Gvalue -=  (statsInt->awb_stats_v3x.blockResult[i].WpNo * (bls_cfg->blc1_gr + bls_cfg->blc1_gb) + 16) >> 5 ;
            statsInt->awb_stats_v3x.blockResult[i].Bvalue -= (statsInt->awb_stats_v3x.blockResult[i].WpNo * bls_cfg->blc1_b + 8) >> 4 ; ;
        }
    }

    //statsInt->awb_stats_valid = ISP2X_STAT_RAWAWB(left_stats->meas_type)? true:false;
    statsInt->awb_stats_valid = left_stats->meas_type >> 5 & 1;
    to->set_sequence(left_stats->frame_id);
    return ret;

}

XCamReturn
RkAiqResourceTranslatorV3x::translateMultiAdehazeStats(const SmartPtr<VideoBuffer>& from, SmartPtr<RkAiqAdehazeStatsProxy>& to)
{

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

#if 0
    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();

    SmartPtr<RkAiqAdehazeStats> statsInt = to->data();

    struct rkisp3x_isp_stat_buffer *left_stats;
    struct rkisp3x_isp_stat_buffer *right_stats;

    left_stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if(left_stats == NULL) {
        LOGE("fail to get left stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    right_stats = left_stats + 1;
    if(right_stats == NULL) {
        LOGE("fail to get right stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    if(left_stats->frame_id != right_stats->frame_id || left_stats->meas_type != right_stats->meas_type) {
        LOGE_ANALYZER("status params(frmid or meas_type) of left isp and right isp are different");
        return XCAM_RETURN_ERROR_PARAM;
    }
    else
        LOGI_ANALYZER("stats: frame_id: %d,  meas_type; 0x%x", left_stats->frame_id, left_stats->meas_type);

    //adehaze stats v3.x
    statsInt->adehaze_stats_valid = left_stats->meas_type >> 17 & 1;
    statsInt->frame_id = left_stats->frame_id;

    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_air_base = (left_stats->params.dhaz.dhaz_adp_air_base + right_stats->params.dhaz.dhaz_adp_air_base) / 2;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_wt = (left_stats->params.dhaz.dhaz_adp_wt + right_stats->params.dhaz.dhaz_adp_wt) / 2;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_gratio = (left_stats->params.dhaz.dhaz_adp_gratio + right_stats->params.dhaz.dhaz_adp_gratio) / 2;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_tmax = (left_stats->params.dhaz.dhaz_adp_tmax + right_stats->params.dhaz.dhaz_adp_tmax) / 2;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_pic_sumh_left = left_stats->params.dhaz.dhaz_adp_tmax;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_pic_sumh_right = right_stats->params.dhaz.dhaz_adp_tmax;

    unsigned int ro_pic_sumh_left = left_stats->params.dhaz.dhaz_pic_sumh;
    unsigned int ro_pic_sumh_right = right_stats->params.dhaz.dhaz_pic_sumh;
    unsigned int tmp = 0;
    for (int i = 0; i < ISP3X_DHAZ_HIST_IIR_NUM; i++) {
        tmp = (left_stats->params.dhaz.h_rgb_iir[i] * ro_pic_sumh_left + right_stats->params.dhaz.h_rgb_iir[i] * ro_pic_sumh_right)
              / (ro_pic_sumh_left + ro_pic_sumh_right);
        statsInt->adehaze_stats.dehaze_stats_v30.h_rgb_iir[i] = tmp > ISP3X_DHAZ_HIST_IIR_MAX ? ISP3X_DHAZ_HIST_IIR_MAX : tmp;
    }
#endif

    return ret;
}

XCamReturn
RkAiqResourceTranslatorV3x::translateAecStats (const SmartPtr<VideoBuffer> &from, SmartPtr<RkAiqAecStatsProxy> &to)
{

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();
    struct rkisp3x_isp_stat_buffer *stats;
    SmartPtr<RkAiqAecStats> statsInt = to->data();

    if (mIsMultiIsp) {
        return translateMultiAecStats(from, to);
    }

    stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if(stats == NULL) {
        LOGE("fail to get stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }
    LOGI_ANALYZER("camId: %d, stats: frame_id: %d,  meas_type; 0x%x",
                  mCamPhyId, stats->frame_id, stats->meas_type);

    SmartPtr<RkAiqIrisParamsProxy> irisParams = buf->get_iris_params();
    SmartPtr<RkAiqExpParamsProxy> expParams = nullptr;
    rkisp_effect_params_v20 ispParams = {0};
    if (buf->getEffectiveExpParams(stats->frame_id, expParams) < 0)
        LOGE("fail to get expParams");
    if (buf->getEffectiveIspParams(stats->frame_id, ispParams) < 0) {
        LOGE("fail to get ispParams ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    //ae stats v3.x

    statsInt->frame_id = stats->frame_id;

    /*rawae stats*/
    struct isp3x_isp_meas_cfg* isp_params = &ispParams.isp_params_v3x[0].meas;
    uint8_t AeSwapMode, AeSelMode, AfUseAeBig;
    AeSwapMode = isp_params->rawae0.rawae_sel;
    AeSelMode = isp_params->rawae3.rawae_sel;
    AfUseAeBig = isp_params->rawaf.ae_mode;
    unsigned int meas_type = 0;

    struct isp21_bls_cfg *bls_cfg = &ispParams.isp_params_v3x[0].others.bls_cfg;
    struct isp2x_bls_fixed_val bls1_val; //bls1_val = blc1_ori_val * awb * range_ratio
    float bls_ratio[3] = {1, 1, 1};
    u32 pixel_num = 0;

    if(bls_cfg->bls1_en) {

        bls1_val.r = bls_cfg->bls1_val.r >> 2;
        bls1_val.gr = bls_cfg->bls1_val.gr;
        bls1_val.gb = bls_cfg->bls1_val.gb;
        bls1_val.b = bls_cfg->bls1_val.b >> 2;

        bls_ratio[0] = (float)((1 << 12) - 1) / ((1 << 12) - 1 - bls_cfg->bls1_val.r);
        bls_ratio[1] = (float)((1 << 12) - 1) / ((1 << 12) - 1 - bls_cfg->bls1_val.gr);
        bls_ratio[2] = (float)((1 << 12) - 1) / ((1 << 12) - 1 - bls_cfg->bls1_val.b);

    } else {

        bls1_val.r = 0;
        bls1_val.gr = 0;
        bls1_val.gb = 0;
        bls1_val.b = 0;

    }

#ifdef AE_STATS_DEBUG
    LOGE("bls1[%d-%d-%d-%d]", bls1_val.r, bls1_val.gr, bls1_val.gb, bls1_val.b);
    LOGE("bls_ratio[%f-%f-%f]", bls_ratio[0], bls_ratio[1], bls_ratio[2]);
#endif

    switch(AeSwapMode) {
    case AEC_RAWSWAP_MODE_S_LITE:
        meas_type = ((stats->meas_type >> 7) & (0x01)) & ((stats->meas_type >> 11) & (0x01));
        statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;

        for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
            if(i < ISP3X_RAWAELITE_MEAN_NUM) {
                statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelr_xy[i] = (u16)((stats->params.rawae0.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelg_xy[i] = (u16)((stats->params.rawae0.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelb_xy[i] = (u16)((stats->params.rawae0.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);
            }
            statsInt->aec_stats.ae_data.chn[1].rawae_big.channelr_xy[i] = (u16)((stats->params.rawae1.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
            statsInt->aec_stats.ae_data.chn[1].rawae_big.channelg_xy[i] = (u16)((stats->params.rawae1.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
            statsInt->aec_stats.ae_data.chn[1].rawae_big.channelb_xy[i] = (u16)((stats->params.rawae1.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);
            statsInt->aec_stats.ae_data.chn[2].rawae_big.channelr_xy[i] = (u16)((stats->params.rawae2.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
            statsInt->aec_stats.ae_data.chn[2].rawae_big.channelg_xy[i] = (u16)((stats->params.rawae2.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
            statsInt->aec_stats.ae_data.chn[2].rawae_big.channelb_xy[i] = (u16)((stats->params.rawae2.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);

            if(i < ISP3X_RAWAEBIG_SUBWIN_NUM) {
                pixel_num = isp_params->rawae1.subwin[i].h_size * isp_params->rawae1.subwin[i].v_size;
                statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumr[i] = (u32)((stats->params.rawae1.sumr[i] - (pixel_num >> 2) * bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumg[i] = (u32)((stats->params.rawae1.sumg[i] - (pixel_num >> 1) * bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumb[i] = (u32)((stats->params.rawae1.sumb[i] - (pixel_num >> 2) * bls1_val.b) * bls_ratio[2]);
                pixel_num = isp_params->rawae2.subwin[i].h_size * isp_params->rawae2.subwin[i].v_size;
                statsInt->aec_stats.ae_data.chn[2].rawae_big.wndx_sumr[i] = (u32)((stats->params.rawae2.sumr[i] - (pixel_num >> 2) * bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[2].rawae_big.wndx_sumg[i] = (u32)((stats->params.rawae2.sumg[i] - (pixel_num >> 1) * bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[2].rawae_big.wndx_sumb[i] = (u32)((stats->params.rawae2.sumb[i] - (pixel_num >> 2) * bls1_val.b) * bls_ratio[2]);
            }
        }

        if(bls_cfg->bls1_en) {

            memset(statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memset(statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memset(statsInt->aec_stats.ae_data.chn[2].rawhist_lite.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            for(int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
                int tmp;
                switch(isp_params->rawhist0.mode) {
                case 2:
                    tmp = (i - (bls1_val.r >> 2) > 0) ? (i - (bls1_val.r >> 2)) * bls_ratio[0] + 0.5 : 0;
                    break;
                case 3:
                    tmp = (i - (bls1_val.gr >> 4) > 0) ? (i - (bls1_val.gr >> 4)) * bls_ratio[1] + 0.5 : 0;
                    break;
                case 4:
                    tmp = (i - (bls1_val.b >> 2) > 0) ? (i - (bls1_val.b >> 2)) * bls_ratio[2] + 0.5 : 0;
                    break;
                case 5:
                default:
                    s16 hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
                    float hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
                    tmp = (i - hist_bls1) ? (i - hist_bls1) * hist_bls_ratio + 0.5 : 0;
                    break;
                }
                if(tmp > ISP3X_HIST_BIN_N_MAX - 1)
                    tmp = ISP3X_HIST_BIN_N_MAX - 1;
                statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins[tmp] += stats->params.rawhist0.hist_bin[i];
                statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins[tmp] += stats->params.rawhist1.hist_bin[i];
                statsInt->aec_stats.ae_data.chn[2].rawhist_big.bins[tmp] += stats->params.rawhist2.hist_bin[i];
            }
        } else {
            memcpy(statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins, stats->params.rawhist0.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memcpy(statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins, stats->params.rawhist1.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memcpy(statsInt->aec_stats.ae_data.chn[2].rawhist_big.bins, stats->params.rawhist2.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
        }

        break;

    case AEC_RAWSWAP_MODE_M_LITE:
        meas_type = ((stats->meas_type >> 8) & (0x01)) & ((stats->meas_type >> 12) & (0x01));
        statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;

        for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
            if(i < ISP3X_RAWAELITE_MEAN_NUM) {
                statsInt->aec_stats.ae_data.chn[1].rawae_lite.channelr_xy[i] = (u16)((stats->params.rawae0.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[1].rawae_lite.channelg_xy[i] = (u16)((stats->params.rawae0.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[1].rawae_lite.channelb_xy[i] = (u16)((stats->params.rawae0.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);
            }
            statsInt->aec_stats.ae_data.chn[0].rawae_big.channelr_xy[i] = (u16)((stats->params.rawae1.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
            statsInt->aec_stats.ae_data.chn[0].rawae_big.channelg_xy[i] = (u16)((stats->params.rawae1.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
            statsInt->aec_stats.ae_data.chn[0].rawae_big.channelb_xy[i] = (u16)((stats->params.rawae1.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);
            statsInt->aec_stats.ae_data.chn[2].rawae_big.channelr_xy[i] = (u16)((stats->params.rawae2.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
            statsInt->aec_stats.ae_data.chn[2].rawae_big.channelg_xy[i] = (u16)((stats->params.rawae2.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
            statsInt->aec_stats.ae_data.chn[2].rawae_big.channelb_xy[i] = (u16)((stats->params.rawae2.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);

            if(i < ISP3X_RAWAEBIG_SUBWIN_NUM) {
                pixel_num = isp_params->rawae1.subwin[i].h_size * isp_params->rawae1.subwin[i].v_size;
                statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumr[i] = (u32)((stats->params.rawae1.sumr[i] - (pixel_num >> 2) * bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumg[i] = (u32)((stats->params.rawae1.sumg[i] - (pixel_num >> 1) * bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumb[i] = (u32)((stats->params.rawae1.sumb[i] - (pixel_num >> 2) * bls1_val.b) * bls_ratio[2]);

                pixel_num = isp_params->rawae2.subwin[i].h_size * isp_params->rawae2.subwin[i].v_size;
                statsInt->aec_stats.ae_data.chn[2].rawae_big.wndx_sumr[i] = (u32)((stats->params.rawae2.sumr[i] - (pixel_num >> 2) * bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[2].rawae_big.wndx_sumg[i] = (u32)((stats->params.rawae2.sumg[i] - (pixel_num >> 1) * bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[2].rawae_big.wndx_sumb[i] = (u32)((stats->params.rawae2.sumb[i] - (pixel_num >> 2) * bls1_val.b) * bls_ratio[2]);
            }
        }

        if(bls_cfg->bls1_en) {

            memset(statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memset(statsInt->aec_stats.ae_data.chn[1].rawhist_lite.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memset(statsInt->aec_stats.ae_data.chn[2].rawhist_big.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));

            for(int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
                int tmp;
                switch(isp_params->rawhist1.mode) {
                case 2:
                    tmp = (i - (bls1_val.r >> 2) > 0) ? (i - (bls1_val.r >> 2)) * bls_ratio[0] + 0.5 : 0;
                    break;
                case 3:
                    tmp = (i - (bls1_val.gr >> 4) > 0) ? (i - (bls1_val.gr >> 4)) * bls_ratio[1] + 0.5 : 0;
                    break;
                case 4:
                    tmp = (i - (bls1_val.b >> 2) > 0) ? (i - (bls1_val.b >> 2)) * bls_ratio[2] + 0.5 : 0;
                    break;
                case 5:
                default:
                    s16 hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
                    float hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
                    tmp = (i - hist_bls1) ? (i - hist_bls1) * hist_bls_ratio + 0.5 : 0;
                    break;
                }
                if(tmp > ISP3X_HIST_BIN_N_MAX - 1)
                    tmp = ISP3X_HIST_BIN_N_MAX - 1;
                statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins[tmp] += stats->params.rawhist1.hist_bin[i];
                statsInt->aec_stats.ae_data.chn[1].rawhist_lite.bins[tmp] += stats->params.rawhist0.hist_bin[i];
                statsInt->aec_stats.ae_data.chn[2].rawhist_big.bins[tmp] += stats->params.rawhist2.hist_bin[i];
            }
        } else {
            memcpy(statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins, stats->params.rawhist1.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memcpy(statsInt->aec_stats.ae_data.chn[1].rawhist_lite.bins, stats->params.rawhist0.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memcpy(statsInt->aec_stats.ae_data.chn[2].rawhist_big.bins, stats->params.rawhist2.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
        }

        break;

    case AEC_RAWSWAP_MODE_L_LITE:
        meas_type = ((stats->meas_type >> 9) & (0x01)) & ((stats->meas_type >> 13) & (0x01));
        statsInt->aec_stats_valid = (meas_type & 0x01) ? true : false;

        for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
            if(i < ISP3X_RAWAELITE_MEAN_NUM) {
                statsInt->aec_stats.ae_data.chn[2].rawae_lite.channelr_xy[i] = (u16)((stats->params.rawae0.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[2].rawae_lite.channelg_xy[i] = (u16)((stats->params.rawae0.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[2].rawae_lite.channelb_xy[i] = (u16)((stats->params.rawae0.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);
            }
            statsInt->aec_stats.ae_data.chn[0].rawae_big.channelr_xy[i] = (u16)((stats->params.rawae2.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
            statsInt->aec_stats.ae_data.chn[0].rawae_big.channelg_xy[i] = (u16)((stats->params.rawae2.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
            statsInt->aec_stats.ae_data.chn[0].rawae_big.channelb_xy[i] = (u16)((stats->params.rawae2.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);
            statsInt->aec_stats.ae_data.chn[1].rawae_big.channelr_xy[i] = (u16)((stats->params.rawae1.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
            statsInt->aec_stats.ae_data.chn[1].rawae_big.channelg_xy[i] = (u16)((stats->params.rawae1.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
            statsInt->aec_stats.ae_data.chn[1].rawae_big.channelb_xy[i] = (u16)((stats->params.rawae1.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);

            if(i < ISP3X_RAWAEBIG_SUBWIN_NUM) {
                pixel_num = isp_params->rawae2.subwin[i].h_size * isp_params->rawae2.subwin[i].v_size;
                statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumr[i] = (u32)((stats->params.rawae2.sumr[i] - (pixel_num >> 2) * bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumg[i] = (u32)((stats->params.rawae2.sumg[i] - (pixel_num >> 1) * bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumb[i] = (u32)((stats->params.rawae2.sumb[i] - (pixel_num >> 2) * bls1_val.b) * bls_ratio[2]);

                pixel_num = isp_params->rawae1.subwin[i].h_size * isp_params->rawae1.subwin[i].v_size;
                statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumr[i] = (u32)((stats->params.rawae1.sumr[i] - (pixel_num >> 2) * bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumg[i] = (u32)((stats->params.rawae1.sumg[i] - (pixel_num >> 1) * bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[1].rawae_big.wndx_sumb[i] = (u32)((stats->params.rawae1.sumb[i] - (pixel_num >> 2) * bls1_val.b) * bls_ratio[2]);
            }
        }

        if(bls_cfg->bls1_en) {

            memset(statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memset(statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memset(statsInt->aec_stats.ae_data.chn[2].rawhist_lite.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));

            for(int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
                int tmp;
                switch(isp_params->rawhist2.mode) {
                case 2:
                    tmp = (i - (bls1_val.r >> 2) > 0) ? (i - (bls1_val.r >> 2)) * bls_ratio[0] + 0.5 : 0;
                    break;
                case 3:
                    tmp = (i - (bls1_val.gr >> 4) > 0) ? (i - (bls1_val.gr >> 4)) * bls_ratio[1] + 0.5 : 0;
                    break;
                case 4:
                    tmp = (i - (bls1_val.b >> 2) > 0) ? (i - (bls1_val.b >> 2)) * bls_ratio[2] + 0.5 : 0;
                    break;
                case 5:
                default:
                    s16 hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
                    float hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
                    tmp = (i - hist_bls1) ? (i - hist_bls1) * hist_bls_ratio + 0.5 : 0;
                    break;
                }
                if(tmp > ISP3X_HIST_BIN_N_MAX - 1)
                    tmp = ISP3X_HIST_BIN_N_MAX - 1;
                statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins[tmp] += stats->params.rawhist2.hist_bin[i];
                statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins[tmp] += stats->params.rawhist1.hist_bin[i];
                statsInt->aec_stats.ae_data.chn[2].rawhist_lite.bins[tmp] += stats->params.rawhist0.hist_bin[i];
            }
        } else {
            memcpy(statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins, stats->params.rawhist2.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memcpy(statsInt->aec_stats.ae_data.chn[1].rawhist_big.bins, stats->params.rawhist1.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            memcpy(statsInt->aec_stats.ae_data.chn[2].rawhist_lite.bins, stats->params.rawhist0.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
        }
        break;

    default:
        LOGE("wrong AeSwapMode=%d\n", AeSwapMode);
        return XCAM_RETURN_ERROR_PARAM;
        break;
    }

    statsInt->af_prior = (AfUseAeBig == 0) ? false : true;

    if(!AfUseAeBig) {
        switch(AeSelMode) {
        case AEC_RAWSEL_MODE_CHN_0:
        case AEC_RAWSEL_MODE_CHN_1:
        case AEC_RAWSEL_MODE_CHN_2:
            for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {

                statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelr_xy[i] = (u16)((stats->params.rawae3.data[i].channelr_xy - bls1_val.r) * bls_ratio[0]);
                statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelg_xy[i] = (u16)((stats->params.rawae3.data[i].channelg_xy - bls1_val.gr) * bls_ratio[1]);
                statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.channelb_xy[i] = (u16)((stats->params.rawae3.data[i].channelb_xy - bls1_val.b) * bls_ratio[2]);

                if(i < ISP3X_RAWAEBIG_SUBWIN_NUM) {
                    pixel_num = isp_params->rawae3.subwin[i].h_size * isp_params->rawae3.subwin[i].v_size;
                    statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumr[i] = (u32)((stats->params.rawae3.sumr[i] - (pixel_num >> 2) * bls1_val.r) * bls_ratio[0]);
                    statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumg[i] = (u32)((stats->params.rawae3.sumg[i] - (pixel_num >> 1) * bls1_val.gr) * bls_ratio[1]);
                    statsInt->aec_stats.ae_data.chn[AeSelMode].rawae_big.wndx_sumb[i] = (u32)((stats->params.rawae3.sumb[i] - (pixel_num >> 2) * bls1_val.b) * bls_ratio[2]);
                }
            }

            if(bls_cfg->bls1_en) {
                memset(statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins, 0, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
                for(int i = 0; i < ISP3X_HIST_BIN_N_MAX; i++) {
                    int tmp;
                    switch(isp_params->rawhist3.mode) {
                    case 2:
                        tmp = (i - (bls1_val.r >> 2) > 0) ? (i - (bls1_val.r >> 2)) * bls_ratio[0] + 0.5 : 0;
                        break;
                    case 3:
                        tmp = (i - (bls1_val.gr >> 4) > 0) ? (i - (bls1_val.gr >> 4)) * bls_ratio[1] + 0.5 : 0;
                        break;
                    case 4:
                        tmp = (i - (bls1_val.b >> 2) > 0) ? (i - (bls1_val.b >> 2)) * bls_ratio[2] + 0.5 : 0;
                        break;
                    case 5:
                    default:
                        s16 hist_bls1 = (s16)((bls1_val.gr >> 4) * 0.587 + (bls1_val.r >> 2) * 0.299 + (bls1_val.b >> 2) * 0.144 + 0.5);
                        float hist_bls_ratio = (float)((1 << 8) - 1) / ((1 << 8) - 1 - hist_bls1);
                        tmp = (i - hist_bls1) ? (i - hist_bls1) * hist_bls_ratio + 0.5 : 0;
                        break;
                    }
                    if(tmp > ISP3X_HIST_BIN_N_MAX - 1)
                        tmp = ISP3X_HIST_BIN_N_MAX - 1;
                    statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins[tmp] += stats->params.rawhist3.hist_bin[i];
                }
            } else {
                memcpy(statsInt->aec_stats.ae_data.chn[AeSelMode].rawhist_big.bins, stats->params.rawhist3.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            }
            break;
        case AEC_RAWSEL_MODE_TMO:
            for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {

                statsInt->aec_stats.ae_data.extra.rawae_big.channelr_xy[i] = stats->params.rawae3.data[i].channelr_xy;
                statsInt->aec_stats.ae_data.extra.rawae_big.channelg_xy[i] = stats->params.rawae3.data[i].channelg_xy;
                statsInt->aec_stats.ae_data.extra.rawae_big.channelb_xy[i] = stats->params.rawae3.data[i].channelb_xy;

                if(i < ISP3X_RAWAEBIG_SUBWIN_NUM) {
                    statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumr[i] = stats->params.rawae3.sumr[i];
                    statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumg[i] = stats->params.rawae3.sumg[i];
                    statsInt->aec_stats.ae_data.extra.rawae_big.wndx_sumb[i] = stats->params.rawae3.sumb[i];
                }
            }
            memcpy(statsInt->aec_stats.ae_data.extra.rawhist_big.bins, stats->params.rawhist3.hist_bin, ISP3X_HIST_BIN_N_MAX * sizeof(u32));
            break;

        default:
            LOGE("wrong AeSelMode=%d\n", AeSelMode);
            return XCAM_RETURN_ERROR_PARAM;
        }
    }

#ifdef AE_STATS_DEBUG
    if(AeSwapMode != 0) {
        for(int i = 0; i < 15; i++) {
            for(int j = 0; j < 15; j++) {
                printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
                       statsInt->aec_stats.ae_data.chn[0].rawae_big.channelr_xy[i * 15 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_big.channelg_xy[i * 15 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_big.channelb_xy[i * 15 + j]);
            }
        }
        printf("====================sub-win-result======================\n");

        for(int i = 0; i < 4; i++)
            printf("chn0_subwin[%d]:sumr 0x%08lx, sumg 0x%08lx, sumb 0x%08lx\n", i,
                   statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumr[i],
                   statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumg[i],
                   statsInt->aec_stats.ae_data.chn[0].rawae_big.wndx_sumb[i]);

        printf("====================hist_result========================\n");

        for(int i = 0; i < 256; i++)
            printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_big.bins[i]);

    } else {
        for(int i = 0; i < 5; i++) {
            for(int j = 0; j < 5; j++) {
                printf("chn0[%d,%d]:r 0x%x, g 0x%x, b 0x%x\n", i, j,
                       statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelr_xy[i * 5 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelg_xy[i * 5 + j],
                       statsInt->aec_stats.ae_data.chn[0].rawae_lite.channelb_xy[i * 5 + j]);
            }
        }
        printf("====================hist_result========================\n");
        for(int i = 0; i < 256; i++)
            printf("bin[%d]= 0x%08x\n", i, statsInt->aec_stats.ae_data.chn[0].rawhist_lite.bins[i]);
    }

#endif

    //rotate stats for group ae
    if(mIsGroupMode) {
        RkAiqAecHwStatsRes_t* temp = (RkAiqAecHwStatsRes_t*)calloc(1, sizeof(RkAiqAecHwStatsRes_t));
        if(mModuleRotation == 1/*RK_PS_SrcOverlapPosition_90*/) {
            //1) clockwise 90
            for(int i = 0; i < 3; i++) {
                //BIG
                uint8_t colnum = sqrt(ISP3X_RAWAEBIG_MEAN_NUM);
                for(int row = 0; row < colnum; row++) {
                    for(int col = 0; col < colnum; col++) {
                        temp->chn[i].rawae_big.channelr_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_big.channelr_xy[(colnum - 1 - col) * colnum + row];
                        temp->chn[i].rawae_big.channelg_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_big.channelg_xy[(colnum - 1 - col) * colnum + row];
                        temp->chn[i].rawae_big.channelb_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_big.channelb_xy[(colnum - 1 - col) * colnum + row];
                    }
                }
                //LITE
                colnum = sqrt(ISP3X_RAWAELITE_MEAN_NUM);
                for(int row = 0; row < colnum; row++) {
                    for(int col = 0; col < colnum; col++) {
                        temp->chn[i].rawae_lite.channelr_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_lite.channelr_xy[(colnum - 1 - col) * colnum + row];
                        temp->chn[i].rawae_lite.channelg_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_lite.channelg_xy[(colnum - 1 - col) * colnum + row];
                        temp->chn[i].rawae_lite.channelb_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_lite.channelb_xy[(colnum - 1 - col) * colnum + row];
                    }
                }
                memcpy(&statsInt->aec_stats.ae_data.chn[i].rawae_lite, &temp->chn[i].rawae_lite, sizeof(rawaelite_stat_t));
                memcpy(&statsInt->aec_stats.ae_data.chn[i].rawae_big, &temp->chn[i].rawae_big, sizeof(rawaebig_stat_t));
            }

            if(!AfUseAeBig) {
                uint8_t colnum = sqrt(ISP3X_RAWAEBIG_MEAN_NUM);
                for(int row = 0; row < colnum; row++) {
                    for(int col = 0; col < colnum; col++) {
                        temp->extra.rawae_big.channelr_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.extra.rawae_big.channelr_xy[(colnum - 1 - col) * colnum + row];
                        temp->extra.rawae_big.channelg_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.extra.rawae_big.channelg_xy[(colnum - 1 - col) * colnum + row];
                        temp->extra.rawae_big.channelb_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.extra.rawae_big.channelb_xy[(colnum - 1 - col) * colnum + row];
                    }
                }
                memcpy(&statsInt->aec_stats.ae_data.extra.rawae_big, &temp->extra.rawae_big, sizeof(rawaebig_stat_t));
            }
        } else if(mModuleRotation == 3/*RK_PS_SrcOverlapPosition_270*/) {
            //2) counter clockwise 90
            for(int i = 0; i < 3; i++) {
                //BIG
                uint8_t colnum = sqrt(ISP3X_RAWAEBIG_MEAN_NUM);
                for(int row = 0; row < colnum; row++) {
                    for(int col = 0; col < colnum; col++) {
                        temp->chn[i].rawae_big.channelr_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_big.channelr_xy[col * colnum + (colnum - 1 - row)];
                        temp->chn[i].rawae_big.channelg_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_big.channelg_xy[col * colnum + (colnum - 1 - row)];
                        temp->chn[i].rawae_big.channelb_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_big.channelb_xy[col * colnum + (colnum - 1 - row)];
                    }
                }
                //LITE
                colnum = sqrt(ISP3X_RAWAELITE_MEAN_NUM);
                for(int row = 0; row < colnum; row++) {
                    for(int col = 0; col < colnum; col++) {
                        temp->chn[i].rawae_lite.channelr_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_lite.channelr_xy[col * colnum + (colnum - 1 - row)];
                        temp->chn[i].rawae_lite.channelg_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_lite.channelg_xy[col * colnum + (colnum - 1 - row)];
                        temp->chn[i].rawae_lite.channelb_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.chn[i].rawae_lite.channelb_xy[col * colnum + (colnum - 1 - row)];
                    }
                }

                memcpy(&statsInt->aec_stats.ae_data.chn[i].rawae_lite, &temp->chn[i].rawae_lite, sizeof(rawaelite_stat_t));
                memcpy(&statsInt->aec_stats.ae_data.chn[i].rawae_big, &temp->chn[i].rawae_big, sizeof(rawaebig_stat_t));
            }

            if(!AfUseAeBig) {
                uint8_t colnum = sqrt(ISP3X_RAWAEBIG_MEAN_NUM);
                for(int row = 0; row < colnum; row++) {
                    for(int col = 0; col < colnum; col++) {
                        temp->extra.rawae_big.channelr_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.extra.rawae_big.channelr_xy[col * colnum + (colnum - 1 - row)];
                        temp->extra.rawae_big.channelg_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.extra.rawae_big.channelg_xy[col * colnum + (colnum - 1 - row)];
                        temp->extra.rawae_big.channelb_xy[row * colnum + col] = \
                                statsInt->aec_stats.ae_data.extra.rawae_big.channelb_xy[col * colnum + (colnum - 1 - row)];
                    }
                }
                memcpy(&statsInt->aec_stats.ae_data.extra.rawae_big, &temp->extra.rawae_big, sizeof(rawaebig_stat_t));
            }
        } else {
            LOGW("not support mModuleRotation %d", mModuleRotation);
        }

        if(temp) free(temp);
    }


    /*
     *         unsigned long chn0_mean = 0, chn1_mean = 0;
     *         for(int i = 0; i < ISP3X_RAWAEBIG_MEAN_NUM; i++) {
     *             chn0_mean += stats->params.rawae1.data[i].channelg_xy;
     *             chn1_mean += stats->params.rawae3.data[i].channelg_xy;
     *         }
     *
     *
     *         printf("frame[%d]: chn[0-1]_g_mean_xy: %ld-%ld\n",
     *                 stats->frame_id, chn0_mean/ISP3X_RAWAEBIG_MEAN_NUM,
     *                 chn1_mean/ISP3X_RAWAEBIG_MEAN_NUM);
     */

    //expsoure params
    if (expParams.ptr()) {

        statsInt->aec_stats.ae_exp = expParams->data()->aecExpInfo;
        /*printf("frame[%d],gain=%d,time=%d\n", stats->frame_id,
               expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.analog_gain_code_global,
               expParams->data()->aecExpInfo.LinearExp.exp_sensor_params.coarse_integration_time);*/


        /*
         * printf("%s: L: [0x%x-0x%x], M: [0x%x-0x%x], S: [0x%x-0x%x]\n",
         *        __func__,
         *        expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.coarse_integration_time,
         *        expParams->data()->aecExpInfo.HdrExp[2].exp_sensor_params.analog_gain_code_global,
         *        expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.coarse_integration_time,
         *        expParams->data()->aecExpInfo.HdrExp[1].exp_sensor_params.analog_gain_code_global,
         *        expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.coarse_integration_time,
         *        expParams->data()->aecExpInfo.HdrExp[0].exp_sensor_params.analog_gain_code_global);
         */
    }

    //iris params
    if (irisParams.ptr()) {

        float sof_time = (float)irisParams->data()->sofTime / 1000000000.0f;
        float start_time = (float)irisParams->data()->PIris.StartTim.tv_sec + (float)irisParams->data()->PIris.StartTim.tv_usec / 1000000.0f;
        float end_time = (float)irisParams->data()->PIris.EndTim.tv_sec + (float)irisParams->data()->PIris.EndTim.tv_usec / 1000000.0f;
        float frm_intval = 1 / (statsInt->aec_stats.ae_exp.pixel_clock_freq_mhz * 1000000.0f /
                                (float)statsInt->aec_stats.ae_exp.line_length_pixels / (float)statsInt->aec_stats.ae_exp.frame_length_lines);

        /*printf("%s: step=%d,last-step=%d,start-tim=%f,end-tim=%f,sof_tim=%f\n",
            __func__,
            statsInt->aec_stats.ae_exp.Iris.PIris.step,
            irisParams->data()->PIris.laststep,start_time,end_time,sof_time);
        */

        if(sof_time < end_time + frm_intval)
            statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.laststep;
        else
            statsInt->aec_stats.ae_exp.Iris.PIris.step = irisParams->data()->PIris.step;
    }

    to->set_sequence(stats->frame_id);

    return ret;
}


void RotationDegAwbBlkStas(rk_aiq_awb_stat_blk_res_v201_t *blockResult, int degree)
{

    rk_aiq_awb_stat_blk_res_v201_t blockResult_old[RK_AIQ_AWB_GRID_NUM_TOTAL];
    if(degree == 3 /*RK_PS_SrcOverlapPosition_270*/) {
        memcpy(blockResult_old, blockResult, sizeof(rk_aiq_awb_stat_blk_res_v201_t)*RK_AIQ_AWB_GRID_NUM_TOTAL);
        for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_VERHOR; i++) {
            for(int j = 0; j < RK_AIQ_AWB_GRID_NUM_VERHOR; j++) {
                memcpy(&blockResult[(RK_AIQ_AWB_GRID_NUM_VERHOR - j - 1)*RK_AIQ_AWB_GRID_NUM_VERHOR + i], &blockResult_old[i * RK_AIQ_AWB_GRID_NUM_VERHOR + j], sizeof(rk_aiq_awb_stat_blk_res_v201_t));
            }
        }
    } else if(degree == 1 /*RK_PS_SrcOverlapPosition_90*/) {
        memcpy(blockResult_old, blockResult, sizeof(rk_aiq_awb_stat_blk_res_v201_t)*RK_AIQ_AWB_GRID_NUM_TOTAL);
        for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_VERHOR; i++) {
            for(int j = 0; j < RK_AIQ_AWB_GRID_NUM_VERHOR; j++) {
                memcpy(&blockResult[j * RK_AIQ_AWB_GRID_NUM_VERHOR + (RK_AIQ_AWB_GRID_NUM_VERHOR - i - 1)], &blockResult_old[i * RK_AIQ_AWB_GRID_NUM_VERHOR + j], sizeof(rk_aiq_awb_stat_blk_res_v201_t));
            }
        }
    } else {
        LOGW_AWBGROUP("not support mModuleRotation %d, abandon to rotate awb blk stas !!!!", degree);
    }
}


XCamReturn
RkAiqResourceTranslatorV3x::translateAwbStats (const SmartPtr<VideoBuffer> &from, SmartPtr<RkAiqAwbStatsProxy> &to)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();
    struct rkisp3x_isp_stat_buffer *stats;
    SmartPtr<RkAiqAwbStats> statsInt = to->data();

    if (mIsMultiIsp) {
        return translateMultiAwbStats(from, to);
    }

    stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if(stats == NULL) {
        LOGE("fail to get stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }
    LOGI_ANALYZER("awb stats: camId:%d, frame_id: %d,  meas_type; 0x%x",
                  mCamPhyId, stats->frame_id, stats->meas_type);

    statsInt->awb_stats_valid = stats->meas_type >> 5 & 1;
    if (!statsInt->awb_stats_valid) {
        LOGE_ANALYZER("AWB stats invalid, ignore");
        return XCAM_RETURN_BYPASS;
    }

    rkisp_effect_params_v20 ispParams = {0};
    if (buf->getEffectiveIspParams(stats->frame_id, ispParams) < 0) {
        LOGE("fail to get ispParams ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }
    //awb30
    statsInt->awb_stats_v3x.awb_cfg_effect_v201 = ispParams.awb_cfg_v3x;
    rk_aiq_isp_blc_t *bls_cfg = &ispParams.blc_cfg.v0;
    statsInt->blc_cfg_effect = ispParams.blc_cfg.v0;
    statsInt->awb_cfg_effect_valid = true;
    statsInt->frame_id = stats->frame_id;
    for(int i = 0; i < statsInt->awb_stats_v3x.awb_cfg_effect_v201.lightNum; i++) {
        statsInt->awb_stats_v3x.light[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].RgainValue =
            stats->params.rawawb.ro_rawawb_sum_rgain_nor[i];
        statsInt->awb_stats_v3x.light[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].BgainValue =
            stats->params.rawawb.ro_rawawb_sum_bgain_nor[i];
        statsInt->awb_stats_v3x.light[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].WpNo =
            stats->params.rawawb.ro_rawawb_wp_num_nor[i];
        statsInt->awb_stats_v3x.light[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].RgainValue =
            stats->params.rawawb.ro_rawawb_sum_rgain_big[i];
        statsInt->awb_stats_v3x.light[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].BgainValue =
            stats->params.rawawb.ro_rawawb_sum_bgain_big[i];
        statsInt->awb_stats_v3x.light[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].WpNo =
            stats->params.rawawb.ro_rawawb_wp_num_big[i];

    }

    for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
        statsInt->awb_stats_v3x.blockResult[i].Rvalue = stats->params.rawawb.ramdata[i].r;
        statsInt->awb_stats_v3x.blockResult[i].Gvalue = stats->params.rawawb.ramdata[i].g;
        statsInt->awb_stats_v3x.blockResult[i].Bvalue = stats->params.rawawb.ramdata[i].b;
        statsInt->awb_stats_v3x.blockResult[i].WpNo = stats->params.rawawb.ramdata[i].wp;
    }

    for(int i = 0; i < RK_AIQ_AWB_WP_HIST_BIN_NUM; i++) {
        statsInt->awb_stats_v3x.WpNoHist[i] = stats->params.rawawb.ro_yhist_bin[i];
        // move the shift code here to make WpNoHist merged by several cameras easily
        if( stats->params.rawawb.ro_yhist_bin[i]  & 0x8000 ) {
            statsInt->awb_stats_v3x.WpNoHist[i] = stats->params.rawawb.ro_yhist_bin[i] & 0x7FFF;
            statsInt->awb_stats_v3x.WpNoHist[i] *=    (1 << 3);
        }
    }

#if defined(ISP_HW_V30)
    for(int i = 0; i < statsInt->awb_stats_v3x.awb_cfg_effect_v201.lightNum; i++) {
        statsInt->awb_stats_v3x.WpNo2[i] =  stats->params.rawawb.ro_wp_num2[i];
    }
    for(int i = 0; i < RK_AIQ_AWB_MULTIWINDOW_NUM_V201; i++) {
        statsInt->awb_stats_v3x.multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].RgainValue =
            stats->params.rawawb.ro_sum_r_nor_multiwindow[i];

        statsInt->awb_stats_v3x.multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].BgainValue =
            stats->params.rawawb.ro_sum_b_nor_multiwindow[i];
        statsInt->awb_stats_v3x.multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_NORMAL_V201].WpNo =
            stats->params.rawawb.ro_wp_nm_nor_multiwindow[i];
        statsInt->awb_stats_v3x.multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].RgainValue =
            stats->params.rawawb.ro_sum_r_big_multiwindow[i];
        statsInt->awb_stats_v3x.multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].BgainValue =
            stats->params.rawawb.ro_sum_b_big_multiwindow[i];
        statsInt->awb_stats_v3x.multiwindowLightResult[i].xYType[RK_AIQ_AWB_XY_TYPE_BIG_V201].WpNo =
            stats->params.rawawb.ro_wp_nm_big_multiwindow[i];
    }

    for(int i = 0; i < RK_AIQ_AWB_STAT_WP_RANGE_NUM_V201; i++) {
        statsInt->awb_stats_v3x.excWpRangeResult[i].RgainValue = stats->params.rawawb.ro_sum_r_exc[i];
        statsInt->awb_stats_v3x.excWpRangeResult[i].BgainValue = stats->params.rawawb.ro_sum_b_exc[i];
        statsInt->awb_stats_v3x.excWpRangeResult[i].WpNo =    stats->params.rawawb.ro_wp_nm_exc[i];

    }

    // to fixed the bug in ic design that some egisters maybe overflow
    if(!mIsMultiIsp) {
        int w, h;
        w = statsInt->awb_stats_v3x.awb_cfg_effect_v201.windowSet[2];
        h = statsInt->awb_stats_v3x.awb_cfg_effect_v201.windowSet[3];
        float factor1 = (float)((1 << (RK_AIQ_AWB_WP_WEIGHT_BIS_V201 + 1)) - 1) / ((1 << RK_AIQ_AWB_WP_WEIGHT_BIS_V201) - 1);
        //float factor1 = (float)(1<<(RK_AIQ_AWB_WP_WEIGHT_BIS_V201+1))/((1<<RK_AIQ_AWB_WP_WEIGHT_BIS_V201)-1);
        if(w * h > RK_AIQ_AWB_STAT_MAX_AREA) {
            LOGD_AWB("%s ramdata and ro_wp_num2 is fixed", __FUNCTION__);
            for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
                statsInt->awb_stats_v3x.blockResult[i].WpNo = (float)statsInt->awb_stats_v3x.blockResult[i].WpNo * factor1 + 0.5 ;
                statsInt->awb_stats_v3x.blockResult[i].Rvalue = (float)statsInt->awb_stats_v3x.blockResult[i].Rvalue * factor1 + 0.5 ;
                statsInt->awb_stats_v3x.blockResult[i].Gvalue = (float)statsInt->awb_stats_v3x.blockResult[i].Gvalue * factor1 + 0.5 ;
                statsInt->awb_stats_v3x.blockResult[i].Bvalue = (float)statsInt->awb_stats_v3x.blockResult[i].Bvalue * factor1 + 0.5 ;
            }
            rk_aiq_awb_xy_type_v201_t typ = statsInt->awb_stats_v3x.awb_cfg_effect_v201.xyRangeTypeForWpHist;
            for(int i = 0; i < statsInt->awb_stats_v3x.awb_cfg_effect_v201.lightNum; i++) {
                statsInt->awb_stats_v3x.WpNo2[i] = statsInt->awb_stats_v3x.light[i].xYType[typ].WpNo >> RK_AIQ_WP_GAIN_FRAC_BIS;
            }
        } else {
            if(statsInt->awb_stats_v3x.awb_cfg_effect_v201.blkMeasureMode == RK_AIQ_AWB_BLK_STAT_MODE_REALWP_V201
                    && statsInt->awb_stats_v3x.awb_cfg_effect_v201.blkStatisticsWithLumaWeightEn) {
                for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
                    statsInt->awb_stats_v3x.blockResult[i].WpNo = (float)statsInt->awb_stats_v3x.blockResult[i].WpNo * factor1 + 0.5 ;
                    statsInt->awb_stats_v3x.blockResult[i].Rvalue = (float)statsInt->awb_stats_v3x.blockResult[i].Rvalue * factor1 + 0.5 ;
                    statsInt->awb_stats_v3x.blockResult[i].Gvalue = (float)statsInt->awb_stats_v3x.blockResult[i].Gvalue * factor1 + 0.5 ;
                    statsInt->awb_stats_v3x.blockResult[i].Bvalue = (float)statsInt->awb_stats_v3x.blockResult[i].Bvalue * factor1 + 0.5 ;
                }
            }
        }
    }

#endif
    LOG1_AWB("bls_cfg %p", bls_cfg);
    if(bls_cfg) {
        LOG1_AWB("bls1_enalbe: %d, b r gb gr:[ %d %d %d %d]", bls_cfg->blc1_enable, bls_cfg->blc1_b,
                 bls_cfg->blc1_r, bls_cfg->blc1_gb, bls_cfg->blc1_gr);
    }
    if(bls_cfg && bls_cfg->blc1_enable && (bls_cfg->blc1_b > 0 || bls_cfg->blc1_r > 0 || bls_cfg->blc1_gb > 0 || bls_cfg->blc1_gr > 0)) {

        for(int i = 0; i < RK_AIQ_AWB_GRID_NUM_TOTAL; i++) {
            statsInt->awb_stats_v3x.blockResult[i].Rvalue -=  (statsInt->awb_stats_v3x.blockResult[i].WpNo * bls_cfg->blc1_r + 8) >> 4 ;
            statsInt->awb_stats_v3x.blockResult[i].Gvalue -=  (statsInt->awb_stats_v3x.blockResult[i].WpNo * (bls_cfg->blc1_gr + bls_cfg->blc1_gb) + 16) >> 5 ;
            statsInt->awb_stats_v3x.blockResult[i].Bvalue -= (statsInt->awb_stats_v3x.blockResult[i].WpNo * bls_cfg->blc1_b + 8) >> 4 ; ;
        }
    }
    LOGV_AWBGROUP("mIsGroupMode %d, mCamPhyId %d,mModuleRotation %d", mIsGroupMode, mCamPhyId, mModuleRotation);
    if(mIsGroupMode) {
        RotationDegAwbBlkStas(statsInt->awb_stats_v3x.blockResult, mModuleRotation);
    }
    //statsInt->awb_stats_valid = ISP2X_STAT_RAWAWB(stats->meas_type)? true:false;
    statsInt->awb_stats_valid = stats->meas_type >> 5 & 1;
    to->set_sequence(stats->frame_id);

    return ret;
}

XCamReturn
RkAiqResourceTranslatorV3x::translateMultiAfStats (const SmartPtr<VideoBuffer> &from, SmartPtr<RkAiqAfStatsProxy> &to)
{
    typedef enum WinSplitMode_s {
        LEFT_AND_RIGHT_MODE = 0,
        LEFT_MODE,
        RIGHT_MODE,
        FULL_MODE,
    } SplitMode;

    struct AfSplitInfo {
        SplitMode wina_side_info;
        int32_t wina_l_blknum;
        int32_t wina_r_blknum;
        int32_t wina_r_skip_blknum;
        float wina_l_ratio;
        float wina_r_ratio;

        SplitMode winb_side_info;
        float winb_l_ratio;
        float winb_r_ratio;
    };

    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();
    struct rkisp3x_isp_stat_buffer *left_stats, *right_stats;
    SmartPtr<RkAiqAfStats> statsInt = to->data();
    SmartPtr<RkAiqAfInfoProxy> afParams = buf->get_af_params();

    left_stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if (left_stats == NULL) {
        LOGE("fail to get stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }
    right_stats = left_stats + 1;
    if (right_stats == NULL) {
        LOGE("fail to get right stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    if (left_stats->frame_id != right_stats->frame_id || left_stats->meas_type != right_stats->meas_type)
        LOGE_ANALYZER("status params(frmid or meas_type) of left isp and right isp are different");
    else
        LOGI_ANALYZER("stats: frame_id: %d,  meas_type; 0x%x", left_stats->frame_id, left_stats->meas_type);

    rkisp_effect_params_v20 ispParams = {0};
    if (buf->getEffectiveIspParams(left_stats->frame_id, ispParams) < 0) {
        LOGE("fail to get ispParams ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }

    statsInt->frame_id = left_stats->frame_id;

    struct isp3x_rawaf_meas_cfg &org_af = ispParams.isp_params_v3x[0].meas.rawaf;
    int32_t l_isp_st, l_isp_ed, r_isp_st, r_isp_ed;
    int32_t l_win_st, l_win_ed, r_win_st, r_win_ed;
    int32_t x_st, x_ed, l_blknum, r_blknum, ov_w, blk_w, r_skip_blknum;
    struct AfSplitInfo af_split_info;
    int32_t i, j, k, dst_idx, l_idx, r_idx, l_lht, r_lht, lht0, lht1;

    memset(&af_split_info, 0, sizeof(af_split_info));
    ov_w = left_isp_rect_.w + left_isp_rect_.x - right_isp_rect_.x;
    x_st = org_af.win[0].h_offs;
    x_ed = x_st + org_af.win[0].h_size;
    l_isp_st = left_isp_rect_.x;
    l_isp_ed = left_isp_rect_.x + left_isp_rect_.w;
    r_isp_st = right_isp_rect_.x;
    r_isp_ed = right_isp_rect_.x + right_isp_rect_.w;
    LOGD_AF("wina.x_st %d, wina.x_ed %d, l_isp_st %d, l_isp_ed %d, r_isp_st %d, r_isp_ed %d",
            x_st, x_ed, l_isp_st, l_isp_ed, r_isp_st, r_isp_ed);

    //// winA ////
    af_split_info.wina_l_ratio = 0;
    af_split_info.wina_r_ratio = 0;
    // af win in both side
    if ((x_st < r_isp_st) && (x_ed > l_isp_ed)) {
        af_split_info.wina_side_info = LEFT_AND_RIGHT_MODE;
        // af win < one isp width
        if (org_af.win[0].h_size < left_isp_rect_.w) {
            blk_w = org_af.win[0].h_size / ISP2X_RAWAF_SUMDATA_ROW;
            l_blknum = (l_isp_ed - x_st + blk_w - 1) / blk_w;
            r_blknum = ISP2X_RAWAF_SUMDATA_ROW - l_blknum;
            l_win_ed = l_isp_ed - 2;
            l_win_st = l_win_ed - blk_w * ISP2X_RAWAF_SUMDATA_ROW;
            if (blk_w < ov_w) {
                r_skip_blknum = ov_w / blk_w;
                r_win_st = ov_w - r_skip_blknum * blk_w;
                r_win_ed = ov_w + (ISP2X_RAWAF_SUMDATA_ROW - r_skip_blknum) * blk_w;
                af_split_info.wina_r_skip_blknum = r_skip_blknum;
            }
            else {
                r_skip_blknum = 0;
                r_win_st = 2;
                r_win_ed = r_win_st + ISP2X_RAWAF_SUMDATA_ROW * blk_w;

                // blend last block of left isp and first block of right isp
                af_split_info.wina_r_skip_blknum = 0;
                af_split_info.wina_l_ratio = (float)ov_w / (float)blk_w;
                af_split_info.wina_r_ratio = 1 - af_split_info.wina_l_ratio;
            }
        }
        // af win <= one isp width * 1.5
        else if (org_af.win[0].h_size < left_isp_rect_.w * 3 / 2) {
            l_win_st = x_st;
            l_win_ed = l_isp_ed - 2;
            blk_w = (l_win_ed - l_win_st) / (ISP2X_RAWAF_SUMDATA_ROW + 1);
            l_win_st = l_win_ed - blk_w * ISP2X_RAWAF_SUMDATA_ROW;
            l_blknum = ((l_win_ed - l_win_st) * ISP2X_RAWAF_SUMDATA_ROW + org_af.win[0].h_size - 1) / org_af.win[0].h_size;
            r_blknum = ISP2X_RAWAF_SUMDATA_ROW - l_blknum;
            if (blk_w < ov_w) {
                r_skip_blknum = ov_w / blk_w;
                r_win_st = ov_w - r_skip_blknum * blk_w;
                r_win_ed = ov_w + (ISP2X_RAWAF_SUMDATA_ROW - r_skip_blknum) * blk_w;
                af_split_info.wina_r_skip_blknum = r_skip_blknum;
            }
            else {
                r_skip_blknum = 0;
                r_win_st = 2;
                r_win_ed = r_win_st + ISP2X_RAWAF_SUMDATA_ROW * blk_w;
                // blend last block of left isp and first block of right isp
                af_split_info.wina_r_skip_blknum = 0;
                af_split_info.wina_l_ratio = (float)ov_w / (float)blk_w;
                af_split_info.wina_r_ratio = 1 - af_split_info.wina_l_ratio;
            }
        }
        else {
            l_win_st = x_st;
            l_win_ed = l_isp_ed - 2;
            blk_w = (l_win_ed - l_win_st) / ISP2X_RAWAF_SUMDATA_ROW;
            l_win_st = l_win_ed - blk_w * ISP2X_RAWAF_SUMDATA_ROW;
            r_win_st = 2;
            r_win_ed = r_win_st + blk_w * ISP2X_RAWAF_SUMDATA_ROW;
            af_split_info.wina_side_info = FULL_MODE;
            l_blknum = ISP2X_RAWAF_SUMDATA_ROW;
            r_blknum = ISP2X_RAWAF_SUMDATA_ROW;
        }
    }
    // af win in right side
    else if ((x_st >= r_isp_st) && (x_ed > l_isp_ed)) {
        af_split_info.wina_side_info = RIGHT_MODE;
        l_blknum = 0;
        r_blknum = ISP2X_RAWAF_SUMDATA_ROW;
        r_win_st = x_st - right_isp_rect_.x;
        r_win_ed = x_ed - right_isp_rect_.x;
        l_win_st = r_win_st;
        l_win_ed = r_win_ed;
    }
    // af win in left side
    else {
        af_split_info.wina_side_info = LEFT_MODE;
        l_blknum = ISP2X_RAWAF_SUMDATA_ROW;
        r_blknum = 0;
        l_win_st = x_st;
        l_win_ed = x_ed;
        r_win_st = l_win_st;
        r_win_ed = l_win_ed;
    }

    af_split_info.wina_l_blknum = l_blknum;
    af_split_info.wina_r_blknum = r_blknum;

    //// winB ////
    af_split_info.winb_l_ratio = 0;
    af_split_info.winb_r_ratio = 0;
    x_st = org_af.win[1].h_offs;
    x_ed = x_st + org_af.win[1].h_size;
    LOGD_AF("winb.x_st %d, winb.x_ed %d, l_isp_st %d, l_isp_ed %d, r_isp_st %d, r_isp_ed %d",
            x_st, x_ed, l_isp_st, l_isp_ed, r_isp_st, r_isp_ed);

    // af win in both side
    if ((x_st < r_isp_st) && (x_ed > l_isp_ed)) {
        af_split_info.winb_side_info = LEFT_AND_RIGHT_MODE;
        l_win_st = x_st;
        l_win_ed = l_isp_ed - 2;
        r_win_st = ov_w - 2;
        r_win_ed = x_ed - right_isp_rect_.x;
        // blend winB by width of left isp winB and right isp winB
        af_split_info.winb_l_ratio = (float)(l_win_ed - l_win_st) / (float)(x_ed - x_st);
        af_split_info.winb_r_ratio = 1 - af_split_info.winb_l_ratio;
    }
    // af win in right side
    else if ((x_st >= r_isp_st) && (x_ed > l_isp_ed)) {
        af_split_info.winb_side_info = RIGHT_MODE;
        af_split_info.winb_l_ratio = 0;
        af_split_info.winb_r_ratio = 1;
        r_win_st = x_st - right_isp_rect_.x;
        r_win_ed = x_ed - right_isp_rect_.x;
        l_win_st = r_win_st;
        l_win_ed = r_win_ed;
    }
    // af win in left side
    else {
        af_split_info.winb_side_info = LEFT_MODE;
        af_split_info.winb_l_ratio = 1;
        af_split_info.winb_r_ratio = 0;
        l_win_st = x_st;
        l_win_ed = x_ed;
        r_win_st = l_win_st;
        r_win_ed = l_win_ed;
    }

    //af
    {
        if (((left_stats->meas_type >> 6) & (0x01)) && ((left_stats->meas_type >> 6) & (0x01)))
            statsInt->af_stats_valid = true;
        else
            statsInt->af_stats_valid = false;

        statsInt->af_stats_v3x.int_state = left_stats->params.rawaf.int_state | right_stats->params.rawaf.int_state;
        if (af_split_info.winb_side_info == LEFT_AND_RIGHT_MODE) {
            statsInt->af_stats_v3x.wndb_luma = left_stats->params.rawaf.afm_lum_b * af_split_info.winb_l_ratio +
                                               right_stats->params.rawaf.afm_lum_b * af_split_info.winb_r_ratio;
            statsInt->af_stats_v3x.wndb_sharpness = left_stats->params.rawaf.afm_sum_b * af_split_info.winb_l_ratio +
                                                    right_stats->params.rawaf.afm_sum_b * af_split_info.winb_r_ratio;
            statsInt->af_stats_v3x.winb_highlit_cnt = left_stats->params.rawaf.highlit_cnt_winb * af_split_info.winb_l_ratio +
                    right_stats->params.rawaf.highlit_cnt_winb * af_split_info.winb_r_ratio;
        } else if (af_split_info.winb_side_info == LEFT_MODE) {
            statsInt->af_stats_v3x.wndb_luma = left_stats->params.rawaf.afm_lum_b;
            statsInt->af_stats_v3x.wndb_sharpness = left_stats->params.rawaf.afm_sum_b;
            statsInt->af_stats_v3x.winb_highlit_cnt = left_stats->params.rawaf.highlit_cnt_winb;
        } else {
            statsInt->af_stats_v3x.wndb_luma = right_stats->params.rawaf.afm_lum_b;
            statsInt->af_stats_v3x.wndb_sharpness = right_stats->params.rawaf.afm_sum_b;
            statsInt->af_stats_v3x.winb_highlit_cnt = right_stats->params.rawaf.highlit_cnt_winb;
        }

        if (af_split_info.wina_side_info == FULL_MODE) {
            for (i = 0; i < ISP2X_RAWAF_SUMDATA_ROW; i++) {
                for (j = 0; j < ISP2X_RAWAF_SUMDATA_COLUMN; j++) {
                    dst_idx = i * ISP2X_RAWAF_SUMDATA_ROW + j;
                    if (j == 0) {
                        l_idx = i * ISP2X_RAWAF_SUMDATA_ROW + j;
                        statsInt->af_stats_v3x.wnda_fv_v1[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].v1;
                        statsInt->af_stats_v3x.wnda_fv_v2[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].v2;
                        statsInt->af_stats_v3x.wnda_fv_h1[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].h1;
                        statsInt->af_stats_v3x.wnda_fv_h2[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].h2;
                        statsInt->af_stats_v3x.wnda_luma[dst_idx] = left_stats->params.rawae3.data[l_idx].channelg_xy;
                        statsInt->af_stats_v3x.wina_highlit_cnt[dst_idx] =
                            ((left_stats->params.rawae3.data[l_idx].channelr_xy & 0x3F) << 10) | left_stats->params.rawae3.data[l_idx].channelb_xy;
                    } else if (j >= 1 && j <= 7) {
                        l_idx = i * ISP2X_RAWAF_SUMDATA_ROW + 2 * (j - 1) + 1;
                        statsInt->af_stats_v3x.wnda_fv_v1[dst_idx] =
                            left_stats->params.rawaf.ramdata[l_idx].v1 + left_stats->params.rawaf.ramdata[l_idx + 1].v1;
                        statsInt->af_stats_v3x.wnda_fv_v2[dst_idx] =
                            left_stats->params.rawaf.ramdata[l_idx].v2 + left_stats->params.rawaf.ramdata[l_idx + 1].v2;
                        statsInt->af_stats_v3x.wnda_fv_h1[dst_idx] =
                            left_stats->params.rawaf.ramdata[l_idx].h1 + left_stats->params.rawaf.ramdata[l_idx + 1].h1;
                        statsInt->af_stats_v3x.wnda_fv_h2[dst_idx] =
                            left_stats->params.rawaf.ramdata[l_idx].h2 + left_stats->params.rawaf.ramdata[l_idx + 1].h2;
                        statsInt->af_stats_v3x.wnda_luma[dst_idx] =
                            left_stats->params.rawae3.data[l_idx].channelg_xy + left_stats->params.rawae3.data[l_idx + 1].channelg_xy;
                        lht0 = ((left_stats->params.rawae3.data[l_idx].channelr_xy & 0x3F) << 10) | left_stats->params.rawae3.data[l_idx].channelb_xy;
                        lht1 = ((left_stats->params.rawae3.data[l_idx + 1].channelr_xy & 0x3F) << 10) | left_stats->params.rawae3.data[l_idx + 1].channelb_xy;
                        statsInt->af_stats_v3x.wina_highlit_cnt[dst_idx] = lht0 + lht1;
                    } else {
                        r_idx = i * ISP2X_RAWAF_SUMDATA_ROW + 2 * (j - 8) + 1;
                        statsInt->af_stats_v3x.wnda_fv_v1[dst_idx] =
                            right_stats->params.rawaf.ramdata[r_idx].v1 + right_stats->params.rawaf.ramdata[r_idx + 1].v1;
                        statsInt->af_stats_v3x.wnda_fv_v2[dst_idx] =
                            right_stats->params.rawaf.ramdata[r_idx].v2 + right_stats->params.rawaf.ramdata[r_idx + 1].v2;
                        statsInt->af_stats_v3x.wnda_fv_h1[dst_idx] =
                            right_stats->params.rawaf.ramdata[r_idx].h1 + right_stats->params.rawaf.ramdata[r_idx + 1].h1;
                        statsInt->af_stats_v3x.wnda_fv_h2[dst_idx] =
                            right_stats->params.rawaf.ramdata[r_idx].h2 + right_stats->params.rawaf.ramdata[r_idx + 1].h2;
                        statsInt->af_stats_v3x.wnda_luma[dst_idx] =
                            right_stats->params.rawae3.data[r_idx].channelg_xy + right_stats->params.rawae3.data[r_idx + 1].channelg_xy;
                        lht0 = ((right_stats->params.rawae3.data[r_idx].channelr_xy & 0x3F) << 10) | right_stats->params.rawae3.data[r_idx].channelb_xy;
                        lht1 = ((right_stats->params.rawae3.data[r_idx + 1].channelr_xy & 0x3F) << 10) | right_stats->params.rawae3.data[r_idx + 1].channelb_xy;
                        statsInt->af_stats_v3x.wina_highlit_cnt[dst_idx] = lht0 + lht1;
                    }
                }
            }
        }
        else if (af_split_info.wina_side_info == LEFT_AND_RIGHT_MODE) {
            for (i = 0; i < ISP2X_RAWAF_SUMDATA_ROW; i++) {
                j = ISP2X_RAWAF_SUMDATA_ROW - af_split_info.wina_l_blknum;
                for (k = 0; k < af_split_info.wina_l_blknum; j++, k++) {
                    dst_idx = i * ISP2X_RAWAF_SUMDATA_ROW + k;
                    l_idx = i * ISP2X_RAWAF_SUMDATA_ROW + j;
                    statsInt->af_stats_v3x.wnda_fv_v1[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].v1;
                    statsInt->af_stats_v3x.wnda_fv_v2[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].v2;
                    statsInt->af_stats_v3x.wnda_fv_h1[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].h1;
                    statsInt->af_stats_v3x.wnda_fv_h2[dst_idx] = left_stats->params.rawaf.ramdata[l_idx].h2;
                    statsInt->af_stats_v3x.wnda_luma[dst_idx] = left_stats->params.rawae3.data[l_idx].channelg_xy;
                    statsInt->af_stats_v3x.wina_highlit_cnt[dst_idx] =
                        ((left_stats->params.rawae3.data[l_idx].channelr_xy & 0x3F) << 10) | left_stats->params.rawae3.data[l_idx].channelb_xy;
                }
            }

            for (i = 0; i < ISP2X_RAWAF_SUMDATA_ROW; i++) {
                j = af_split_info.wina_r_skip_blknum;
                for (k = 0; k < af_split_info.wina_r_blknum; j++, k++) {
                    dst_idx = i * ISP2X_RAWAF_SUMDATA_ROW + k + af_split_info.wina_l_blknum;
                    r_idx = i * ISP2X_RAWAF_SUMDATA_ROW + j;
                    statsInt->af_stats_v3x.wnda_fv_v1[dst_idx] = right_stats->params.rawaf.ramdata[r_idx].v1;
                    statsInt->af_stats_v3x.wnda_fv_v2[dst_idx] = right_stats->params.rawaf.ramdata[r_idx].v2;
                    statsInt->af_stats_v3x.wnda_fv_h1[dst_idx] = right_stats->params.rawaf.ramdata[r_idx].h1;
                    statsInt->af_stats_v3x.wnda_fv_h2[dst_idx] = right_stats->params.rawaf.ramdata[r_idx].h2;

                    statsInt->af_stats_v3x.wnda_luma[dst_idx] = right_stats->params.rawae3.data[r_idx].channelg_xy;
                    statsInt->af_stats_v3x.wina_highlit_cnt[dst_idx] =
                        ((right_stats->params.rawae3.data[r_idx].channelr_xy & 0x3F) << 10) | right_stats->params.rawae3.data[r_idx].channelb_xy;
                }
            }

            if (af_split_info.wina_r_skip_blknum == 0) {
                for (j = 0; j < ISP2X_RAWAF_SUMDATA_COLUMN; j++) {
                    dst_idx = j * ISP2X_RAWAF_SUMDATA_ROW + (af_split_info.wina_l_blknum - 1);
                    l_idx = j * ISP2X_RAWAF_SUMDATA_ROW + (ISP2X_RAWAF_SUMDATA_COLUMN - 1);
                    r_idx = j * ISP2X_RAWAF_SUMDATA_ROW;
                    statsInt->af_stats_v3x.wnda_fv_v1[dst_idx] =
                        left_stats->params.rawaf.ramdata[l_idx].v1 * af_split_info.wina_l_ratio +
                        right_stats->params.rawaf.ramdata[r_idx].v1 * af_split_info.wina_r_ratio;
                    statsInt->af_stats_v3x.wnda_fv_v2[dst_idx] =
                        left_stats->params.rawaf.ramdata[l_idx].v2 * af_split_info.wina_l_ratio +
                        right_stats->params.rawaf.ramdata[r_idx].v2 * af_split_info.wina_r_ratio;
                    statsInt->af_stats_v3x.wnda_fv_h1[dst_idx] =
                        left_stats->params.rawaf.ramdata[l_idx].h1 * af_split_info.wina_l_ratio +
                        right_stats->params.rawaf.ramdata[r_idx].h1 * af_split_info.wina_r_ratio;
                    statsInt->af_stats_v3x.wnda_fv_h2[dst_idx] =
                        left_stats->params.rawaf.ramdata[l_idx].h2 * af_split_info.wina_l_ratio +
                        right_stats->params.rawaf.ramdata[r_idx].h2 * af_split_info.wina_r_ratio;

                    statsInt->af_stats_v3x.wnda_luma[dst_idx] =
                        left_stats->params.rawae3.data[l_idx].channelg_xy * af_split_info.wina_l_ratio +
                        right_stats->params.rawae3.data[r_idx].channelg_xy * af_split_info.wina_r_ratio;
                    l_lht = ((left_stats->params.rawae3.data[l_idx].channelr_xy & 0x3F) << 10) | left_stats->params.rawae3.data[l_idx].channelb_xy;
                    r_lht = ((right_stats->params.rawae3.data[r_idx].channelr_xy & 0x3F) << 10) | right_stats->params.rawae3.data[r_idx].channelb_xy;
                    statsInt->af_stats_v3x.wina_highlit_cnt[dst_idx] =
                        l_lht * af_split_info.wina_l_ratio + r_lht * af_split_info.wina_r_ratio;
                }
            }
        } else if (af_split_info.wina_side_info == LEFT_MODE) {
            for (i = 0; i < RKAIQ_RAWAF_SUMDATA_NUM; i++) {
                statsInt->af_stats_v3x.wnda_fv_v1[i] = left_stats->params.rawaf.ramdata[i].v1;
                statsInt->af_stats_v3x.wnda_fv_v2[i] = left_stats->params.rawaf.ramdata[i].v2;
                statsInt->af_stats_v3x.wnda_fv_h1[i] = left_stats->params.rawaf.ramdata[i].h1;
                statsInt->af_stats_v3x.wnda_fv_h2[i] = left_stats->params.rawaf.ramdata[i].h2;

                statsInt->af_stats_v3x.wnda_luma[i] = left_stats->params.rawae3.data[i].channelg_xy;
                statsInt->af_stats_v3x.wina_highlit_cnt[i] =
                    ((left_stats->params.rawae3.data[i].channelr_xy & 0x3F) << 10) | left_stats->params.rawae3.data[i].channelb_xy;
            }
        } else {
            for (i = 0; i < RKAIQ_RAWAF_SUMDATA_NUM; i++) {
                statsInt->af_stats_v3x.wnda_fv_v1[i] = right_stats->params.rawaf.ramdata[i].v1;
                statsInt->af_stats_v3x.wnda_fv_v2[i] = right_stats->params.rawaf.ramdata[i].v2;
                statsInt->af_stats_v3x.wnda_fv_h1[i] = right_stats->params.rawaf.ramdata[i].h1;
                statsInt->af_stats_v3x.wnda_fv_h2[i] = right_stats->params.rawaf.ramdata[i].h2;

                statsInt->af_stats_v3x.wnda_luma[i] = right_stats->params.rawae3.data[i].channelg_xy;
                statsInt->af_stats_v3x.wina_highlit_cnt[i] =
                    ((right_stats->params.rawae3.data[i].channelr_xy & 0x3F) << 10) | right_stats->params.rawae3.data[i].channelb_xy;
            }
        }

        LOGD_AF("af_split_info.wina: %d, %d, %d, %d, %f, %f",
                af_split_info.wina_side_info, af_split_info.wina_l_blknum, af_split_info.wina_r_blknum,
                af_split_info.wina_r_skip_blknum, af_split_info.wina_l_ratio, af_split_info.wina_r_ratio);
        LOGD_AF("af_split_info.winb: %d, %f, %f",
                af_split_info.winb_side_info, af_split_info.winb_l_ratio, af_split_info.winb_r_ratio);

        if(afParams.ptr()) {
            statsInt->af_stats_v3x.focusCode = afParams->data()->focusCode;
            statsInt->af_stats_v3x.zoomCode = afParams->data()->zoomCode;
            statsInt->af_stats_v3x.focus_endtim = afParams->data()->focusEndTim;
            statsInt->af_stats_v3x.focus_starttim = afParams->data()->focusStartTim;
            statsInt->af_stats_v3x.zoom_endtim = afParams->data()->zoomEndTim;
            statsInt->af_stats_v3x.zoom_starttim = afParams->data()->zoomStartTim;
            statsInt->af_stats_v3x.sof_tim = afParams->data()->sofTime;
            statsInt->af_stats_v3x.focusCorrection = afParams->data()->focusCorrection;
            statsInt->af_stats_v3x.zoomCorrection = afParams->data()->zoomCorrection;
            statsInt->af_stats_v3x.angleZ = afParams->data()->angleZ;
        }
    }

    return ret;
}


XCamReturn
RkAiqResourceTranslatorV3x::translateAfStats (const SmartPtr<VideoBuffer> &from, SmartPtr<RkAiqAfStatsProxy> &to)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();
    struct rkisp3x_isp_stat_buffer *stats;
    SmartPtr<RkAiqAfStats> statsInt = to->data();

    if (mIsMultiIsp) {
        return translateMultiAfStats(from, to);
    }

    stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if(stats == NULL) {
        LOGE("fail to get stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }
    LOGI_ANALYZER("stats: frame_id: %d,  meas_type; 0x%x",
                  stats->frame_id, stats->meas_type);

    SmartPtr<RkAiqAfInfoProxy> afParams = buf->get_af_params();

    memset(&statsInt->af_stats_v3x, 0, sizeof(rk_aiq_isp_af_stats_v3x_t));
    statsInt->frame_id = stats->frame_id;

    //af
    {
        statsInt->af_stats_valid =
            (stats->meas_type >> 6) & (0x01) ? true : false;

        statsInt->af_stats_v3x.int_state = stats->params.rawaf.int_state;
        statsInt->af_stats_v3x.wndb_luma = stats->params.rawaf.afm_lum_b;
        statsInt->af_stats_v3x.wndb_sharpness = stats->params.rawaf.afm_sum_b;
        statsInt->af_stats_v3x.winb_highlit_cnt = stats->params.rawaf.highlit_cnt_winb;
        for (int i = 0; i < RKAIQ_RAWAF_SUMDATA_NUM; i++) {
            statsInt->af_stats_v3x.wnda_fv_v1[i] = stats->params.rawaf.ramdata[i].v1;
            statsInt->af_stats_v3x.wnda_fv_v2[i] = stats->params.rawaf.ramdata[i].v2;
            statsInt->af_stats_v3x.wnda_fv_h1[i] = stats->params.rawaf.ramdata[i].h1;
            statsInt->af_stats_v3x.wnda_fv_h2[i] = stats->params.rawaf.ramdata[i].h2;

            statsInt->af_stats_v3x.wnda_luma[i] = stats->params.rawae3.data[i].channelg_xy;
            statsInt->af_stats_v3x.wina_highlit_cnt[i] =
                ((stats->params.rawae3.data[i].channelr_xy & 0x3F) << 10) | stats->params.rawae3.data[i].channelb_xy;
        }

        if(afParams.ptr()) {
            statsInt->af_stats_v3x.focusCode = afParams->data()->focusCode;
            statsInt->af_stats_v3x.zoomCode = afParams->data()->zoomCode;
            statsInt->af_stats_v3x.focus_endtim = afParams->data()->focusEndTim;
            statsInt->af_stats_v3x.focus_starttim = afParams->data()->focusStartTim;
            statsInt->af_stats_v3x.zoom_endtim = afParams->data()->zoomEndTim;
            statsInt->af_stats_v3x.zoom_starttim = afParams->data()->zoomStartTim;
            statsInt->af_stats_v3x.sof_tim = afParams->data()->sofTime;
            statsInt->af_stats_v3x.focusCorrection = afParams->data()->focusCorrection;
            statsInt->af_stats_v3x.zoomCorrection = afParams->data()->zoomCorrection;
            statsInt->af_stats_v3x.angleZ = afParams->data()->angleZ;
        }
    }

    return ret;
}

XCamReturn
RkAiqResourceTranslatorV3x::translateAdehazeStats (const SmartPtr<VideoBuffer> &from, SmartPtr<RkAiqAdehazeStatsProxy> &to)
{

    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    const SmartPtr<Isp20StatsBuffer> buf =
        from.dynamic_cast_ptr<Isp20StatsBuffer>();
    struct rkisp3x_isp_stat_buffer *stats;
    SmartPtr<RkAiqAdehazeStats> statsInt = to->data();

    if (mIsMultiIsp) {
        return translateMultiAdehazeStats(from, to);
    }

    stats = (struct rkisp3x_isp_stat_buffer*)(buf->get_v4l2_userptr());
    if(stats == NULL) {
        LOGE("fail to get stats ,ignore\n");
        return XCAM_RETURN_BYPASS;
    }
    LOGI_ANALYZER("stats: frame_id: %d,  meas_type; 0x%x",
                  stats->frame_id, stats->meas_type);
    //dehaze
    statsInt->adehaze_stats_valid = stats->meas_type >> 17 & 1;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_air_base = stats->params.dhaz.dhaz_adp_air_base;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_wt = stats->params.dhaz.dhaz_adp_wt;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_gratio = stats->params.dhaz.dhaz_adp_gratio;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_adp_wt = stats->params.dhaz.dhaz_adp_wt;
    statsInt->adehaze_stats.dehaze_stats_v30.dhaz_pic_sumh_left = stats->params.dhaz.dhaz_pic_sumh;
    for(int i = 0; i < ISP3X_DHAZ_HIST_IIR_NUM; i++)
        statsInt->adehaze_stats.dehaze_stats_v30.h_rgb_iir[i] = stats->params.dhaz.h_rgb_iir[i];

    to->set_sequence(stats->frame_id);

    return ret;
}

} //namespace RkCam