/*

* Copyright(c) 2019 Intel Corporation

* Copyright (c) 2016, Alliance for Open Media. All rights reserved

*

* This source code is subject to the terms of the BSD 3-Clause Clear License and

* the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear License

* was not distributed with this source code in the LICENSE file, you can

* obtain it at https://www.aomedia.org/license. If the Alliance for Open

* Media Patent License 1.0 was not distributed with this source code in the

* PATENTS file, you can obtain it at https://www.aomedia.org/license/patent-license.

*/

#include <stdlib.h>

#include "inter_prediction.h"

#include "convolve.h"

#include "common_dsp_rtcd.h"

#include "utility.h"

#include "pic_operators.h"

#define SCALE_SUBPEL_BITS 10

#define SCALE_SUBPEL_SHIFTS (1 << SCALE_SUBPEL_BITS)

#define SCALE_SUBPEL_MASK (SCALE_SUBPEL_SHIFTS - 1)

#define SCALE_EXTRA_BITS (SCALE_SUBPEL_BITS - SUBPEL_BITS)

void svt_aom_pack_block(uint8_t* in8_bit_buffer, uint32_t in8_stride, uint8_t* inn_bit_buffer, uint32_t inn_stride,

                        uint16_t* out16_bit_buffer, uint32_t out_stride, uint32_t width, uint32_t height) {

    svt_aom_pack2d_src(

        in8_bit_buffer, in8_stride, inn_bit_buffer, inn_stride, out16_bit_buffer, out_stride, width, height);

}

const int             div_mult[32] = {0,    16384, 8192, 5461, 4096, 3276, 2730, 2340, 2048, 1820, 1638,

                                      1489, 1365,  1260, 1170, 1092, 1024, 963,  910,  862,  819,  780,

                                      744,  712,   682,  655,  630,  606,  585,  564,  546,  528};

static WedgeMasksType wedge_masks[BLOCK_SIZES_ALL][2];

int svt_aom_is_masked_compound_type(COMPOUND_TYPE type) {

    return (type == COMPOUND_WEDGE || type == COMPOUND_DIFFWTD);

}

void svt_aom_highbd_subtract_block_c(int rows, int cols, int16_t* diff, ptrdiff_t diff_stride, const uint8_t* src8,

                                     ptrdiff_t src_stride, const uint8_t* pred8, ptrdiff_t pred_stride, int bd) {

    uint16_t* src  = (uint16_t*)(src8);

    uint16_t* pred = (uint16_t*)(pred8);

    (void)bd;

    for (int r = 0; r < rows; r++) {

        for (int c = 0; c < cols; c++) {

            diff[c] = src[c] - pred[c];

        }

        diff += diff_stride;

        pred += pred_stride;

        src += src_stride;

    }

}

void svt_aom_subtract_block_c(int rows, int cols, int16_t* diff, ptrdiff_t diff_stride, const uint8_t* src,

                              ptrdiff_t src_stride, const uint8_t* pred, ptrdiff_t pred_stride) {

    for (int r = 0; r < rows; r++) {

        for (int c = 0; c < cols; c++) {

            diff[c] = src[c] - pred[c];

        }

        diff += diff_stride;

        pred += pred_stride;

        src += src_stride;

    }

}

static void diffwtd_mask(uint8_t* mask, int which_inverse, int mask_base, const uint8_t* src0, int src0_stride,

                         const uint8_t* src1, int src1_stride, int h, int w) {

    for (int i = 0; i < h; ++i) {

        for (int j = 0; j < w; ++j) {

            int diff        = abs((int)src0[i * src0_stride + j] - (int)src1[i * src1_stride + j]);

            int m           = clamp(mask_base + (diff / DIFF_FACTOR), 0, AOM_BLEND_A64_MAX_ALPHA);

            mask[i * w + j] = which_inverse ? AOM_BLEND_A64_MAX_ALPHA - m : m;

        }

    }

}

static AOM_FORCE_INLINE void diffwtd_mask_highbd(uint8_t* mask, int which_inverse, int mask_base, const uint16_t* src0,

                                                 int src0_stride, const uint16_t* src1, int src1_stride, int h, int w,

                                                 const unsigned int bd) {

    assert(bd >= 8);

    if (bd == 8) {

        if (which_inverse) {

            for (int i = 0; i < h; ++i) {

                for (int j = 0; j < w; ++j) {

                    int          diff = abs((int)src0[j] - (int)src1[j]) / DIFF_FACTOR;

                    unsigned int m    = negative_to_zero(mask_base + diff);

                    m                 = AOMMIN(m, AOM_BLEND_A64_MAX_ALPHA);

                    mask[j]           = AOM_BLEND_A64_MAX_ALPHA - m;

                }

                src0 += src0_stride;

                src1 += src1_stride;

                mask += w;

            }

        } else {

            for (int i = 0; i < h; ++i) {

                for (int j = 0; j < w; ++j) {

                    int          diff = abs((int)src0[j] - (int)src1[j]) / DIFF_FACTOR;

                    unsigned int m    = negative_to_zero(mask_base + diff);

                    m                 = AOMMIN(m, AOM_BLEND_A64_MAX_ALPHA);

                    mask[j]           = m;

                }

                src0 += src0_stride;

                src1 += src1_stride;

                mask += w;

            }

        }

    } else {

        const unsigned int bd_shift = bd - 8;

        if (which_inverse) {

            for (int i = 0; i < h; ++i) {

                for (int j = 0; j < w; ++j) {

                    int          diff = (abs((int)src0[j] - (int)src1[j]) >> bd_shift) / DIFF_FACTOR;

                    unsigned int m    = negative_to_zero(mask_base + diff);

                    m                 = AOMMIN(m, AOM_BLEND_A64_MAX_ALPHA);

                    mask[j]           = AOM_BLEND_A64_MAX_ALPHA - m;

                }

                src0 += src0_stride;

                src1 += src1_stride;

                mask += w;

            }

        } else {

            for (int i = 0; i < h; ++i) {

                for (int j = 0; j < w; ++j) {

                    int          diff = (abs((int)src0[j] - (int)src1[j]) >> bd_shift) / DIFF_FACTOR;

                    unsigned int m    = negative_to_zero(mask_base + diff);

                    m                 = AOMMIN(m, AOM_BLEND_A64_MAX_ALPHA);

                    mask[j]           = m;

                }

                src0 += src0_stride;

                src1 += src1_stride;

                mask += w;

            }

        }

    }

}

void svt_av1_build_compound_diffwtd_mask_highbd_c(uint8_t* mask, DIFFWTD_MASK_TYPE mask_type, const uint8_t* src0,

                                                  int src0_stride, const uint8_t* src1, int src1_stride, int h, int w,

                                                  int bd) {

    switch (mask_type) {

    case DIFFWTD_38:

        diffwtd_mask_highbd(mask, 0, 38, (uint16_t*)src0, src0_stride, (uint16_t*)src1, src1_stride, h, w, bd);

        break;

    case DIFFWTD_38_INV:

        diffwtd_mask_highbd(mask, 1, 38, (uint16_t*)src0, src0_stride, (uint16_t*)src1, src1_stride, h, w, bd);

        break;

    default:

        assert(0);

    }

}

void svt_av1_build_compound_diffwtd_mask_c(uint8_t* mask, DIFFWTD_MASK_TYPE mask_type, const uint8_t* src0,

                                           int src0_stride, const uint8_t* src1, int src1_stride, int h, int w) {

    switch (mask_type) {

    case DIFFWTD_38:

        diffwtd_mask(mask, 0, 38, src0, src0_stride, src1, src1_stride, h, w);

        break;

    case DIFFWTD_38_INV:

        diffwtd_mask(mask, 1, 38, src0, src0_stride, src1, src1_stride, h, w);

        break;

    default:

        assert(0);

    }

}

// Note: Expect val to be in q4 precision

static INLINE int32_t scaled_x(int32_t val, const ScaleFactors* sf) {

    const int     off  = (sf->x_scale_fp - (1 << REF_SCALE_SHIFT)) * (1 << (SUBPEL_BITS - 1));

    const int64_t tval = (int64_t)val * sf->x_scale_fp + off;

    return (int)ROUND_POWER_OF_TWO_SIGNED_64(tval, REF_SCALE_SHIFT - SCALE_EXTRA_BITS);

}

// Note: Expect val to be in q4 precision

static INLINE int32_t scaled_y(int32_t val, const ScaleFactors* sf) {

    const int32_t off  = (sf->y_scale_fp - (1 << REF_SCALE_SHIFT)) * (1 << (SUBPEL_BITS - 1));

    const int64_t tval = (int64_t)val * sf->y_scale_fp + off;

    return (int32_t)ROUND_POWER_OF_TWO_SIGNED_64(tval, REF_SCALE_SHIFT - SCALE_EXTRA_BITS);

}

// Note: Expect val to be in q4 precision

static int32_t unscaled_value(int32_t val, const ScaleFactors* sf) {

    (void)sf;

    return val << SCALE_EXTRA_BITS;

}

static int32_t get_fixed_point_scale_factor(int32_t other_size, int32_t this_size) {

    // Calculate scaling factor once for each reference frame

    // and use fixed point scaling factors in decoding and encoding routines.

    // Hardware implementations can calculate scale factor in device driver

    // and use multiplication and shifting on hardware instead of division.

    return ((other_size << REF_SCALE_SHIFT) + this_size / 2) / this_size;

}

// Given the fixed point scale, calculate coarse point scale.

static int32_t fixed_point_scale_to_coarse_point_scale(int32_t scale_fp) {

    return ROUND_POWER_OF_TWO(scale_fp, REF_SCALE_SHIFT - SCALE_SUBPEL_BITS);

}

void svt_av1_setup_scale_factors_for_frame(ScaleFactors* sf, int other_w, int other_h, int this_w, int this_h) {

    if (!valid_ref_frame_size(other_w, other_h, this_w, this_h)) {

        sf->x_scale_fp = REF_INVALID_SCALE;

        sf->y_scale_fp = REF_INVALID_SCALE;

        sf->is_scaled  = 0;

        return;

    }

    sf->x_scale_fp = get_fixed_point_scale_factor(other_w, this_w);

    sf->y_scale_fp = get_fixed_point_scale_factor(other_h, this_h);

    sf->x_step_q4 = fixed_point_scale_to_coarse_point_scale(sf->x_scale_fp);

    sf->y_step_q4 = fixed_point_scale_to_coarse_point_scale(sf->y_scale_fp);

    sf->is_scaled = av1_is_scaled(sf);

    if (sf->is_scaled) {

        sf->scale_value_x = scaled_x;

        sf->scale_value_y = scaled_y;

    } else {

        sf->scale_value_x = unscaled_value;

        sf->scale_value_y = unscaled_value;

    }

}

static INLINE int32_t has_scale(int32_t xs, int32_t ys) {

    return xs != SCALE_SUBPEL_SHIFTS || ys != SCALE_SUBPEL_SHIFTS;

}

static INLINE void revert_scale_extra_bits(SubpelParams* sp) {

    sp->subpel_x >>= SCALE_EXTRA_BITS;

    sp->subpel_y >>= SCALE_EXTRA_BITS;

    sp->xs >>= SCALE_EXTRA_BITS;

    sp->ys >>= SCALE_EXTRA_BITS;

    assert(sp->subpel_x < SUBPEL_SHIFTS);

    assert(sp->subpel_y < SUBPEL_SHIFTS);

    assert(sp->xs <= SUBPEL_SHIFTS);

    assert(sp->ys <= SUBPEL_SHIFTS);

}

DECLARE_ALIGNED(256, const InterpKernel, sub_pel_filters_8[SUBPEL_SHIFTS]) = {{0, 0, 0, 128, 0, 0, 0, 0},

                                                                              {0, 2, -6, 126, 8, -2, 0, 0},

                                                                              {0, 2, -10, 122, 18, -4, 0, 0},

                                                                              {0, 2, -12, 116, 28, -8, 2, 0},

                                                                              {0, 2, -14, 110, 38, -10, 2, 0},

                                                                              {0, 2, -14, 102, 48, -12, 2, 0},

                                                                              {0, 2, -16, 94, 58, -12, 2, 0},

                                                                              {0, 2, -14, 84, 66, -12, 2, 0},

                                                                              {0, 2, -14, 76, 76, -14, 2, 0},

                                                                              {0, 2, -12, 66, 84, -14, 2, 0},

                                                                              {0, 2, -12, 58, 94, -16, 2, 0},

                                                                              {0, 2, -12, 48, 102, -14, 2, 0},

                                                                              {0, 2, -10, 38, 110, -14, 2, 0},

                                                                              {0, 2, -8, 28, 116, -12, 2, 0},

                                                                              {0, 0, -4, 18, 122, -10, 2, 0},

                                                                              {0, 0, -2, 8, 126, -6, 2, 0}};

DECLARE_ALIGNED(256, const InterpKernel, sub_pel_filters_4[SUBPEL_SHIFTS]) = {{0, 0, 0, 128, 0, 0, 0, 0},

                                                                              {0, 0, -4, 126, 8, -2, 0, 0},

                                                                              {0, 0, -8, 122, 18, -4, 0, 0},

                                                                              {0, 0, -10, 116, 28, -6, 0, 0},

                                                                              {0, 0, -12, 110, 38, -8, 0, 0},

                                                                              {0, 0, -12, 102, 48, -10, 0, 0},

                                                                              {0, 0, -14, 94, 58, -10, 0, 0},

                                                                              {0, 0, -12, 84, 66, -10, 0, 0},

                                                                              {0, 0, -12, 76, 76, -12, 0, 0},

                                                                              {0, 0, -10, 66, 84, -12, 0, 0},

                                                                              {0, 0, -10, 58, 94, -14, 0, 0},

                                                                              {0, 0, -10, 48, 102, -12, 0, 0},

                                                                              {0, 0, -8, 38, 110, -12, 0, 0},

                                                                              {0, 0, -6, 28, 116, -10, 0, 0},

                                                                              {0, 0, -4, 18, 122, -8, 0, 0},

                                                                              {0, 0, -2, 8, 126, -4, 0, 0}};

#define MAX_FILTER_TAP 8

int svt_aom_get_relative_dist_enc(SeqHeader* seq_header, int ref_hint, int order_hint) {

    int diff, m;

    if (!seq_header->order_hint_info.enable_order_hint) {

        return 0;

    }

    diff = ref_hint - order_hint;

    m    = 1 << (seq_header->order_hint_info.order_hint_bits - 1);

    diff = (diff & (m - 1)) - (diff & m);

    return diff;

}

static const int quant_dist_weight[4][2]          = {{2, 3}, {2, 5}, {2, 7}, {1, MAX_FRAME_DISTANCE}};

static const int quant_dist_lookup_table[2][4][2] = {

    {{9, 7}, {11, 5}, {12, 4}, {13, 3}},

    {{7, 9}, {5, 11}, {4, 12}, {3, 13}},

};

void svt_av1_dist_wtd_comp_weight_assign(SeqHeader* seq_header, int cur_frame_index, int bck_frame_index,

                                         int fwd_frame_index, int compound_idx, int order_idx, int* fwd_offset,

                                         int* bck_offset, int* use_dist_wtd_comp_avg, int is_compound) {

    assert(fwd_offset != NULL && bck_offset != NULL);

    if (!is_compound || compound_idx) {

        *use_dist_wtd_comp_avg = 0;

        return;

    }

    *use_dist_wtd_comp_avg = 1;

    int d0 = clamp(

        abs(svt_aom_get_relative_dist_enc(seq_header, fwd_frame_index, cur_frame_index)), 0, MAX_FRAME_DISTANCE);

    int d1 = clamp(

        abs(svt_aom_get_relative_dist_enc(seq_header, cur_frame_index, bck_frame_index)), 0, MAX_FRAME_DISTANCE);

    const int order = d0 <= d1;

    if (d0 == 0 || d1 == 0) {

        *fwd_offset = quant_dist_lookup_table[order_idx][3][order];

        *bck_offset = quant_dist_lookup_table[order_idx][3][1 - order];

        return;

    }

    int i;

    for (i = 0; i < 3; ++i) {

        int c0    = quant_dist_weight[i][order];

        int c1    = quant_dist_weight[i][!order];

        int d0_c0 = d0 * c0;

        int d1_c1 = d1 * c1;

        if ((d0 > d1 && d0_c0 < d1_c1) || (d0 <= d1 && d0_c0 > d1_c1)) {

            break;

        }

    }

    *fwd_offset = quant_dist_lookup_table[order_idx][i][order];

    *bck_offset = quant_dist_lookup_table[order_idx][i][1 - order];

}

void svt_av1_convolve_2d_sr_c(const uint8_t* src, int32_t src_stride, uint8_t* dst, int32_t dst_stride, int32_t w,

                              int32_t h, const InterpFilterParams* filter_params_x,

                              const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                              const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    int16_t       im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];

    int32_t       im_h      = h + filter_params_y->taps - 1;

    int32_t       im_stride = w;

    const int32_t fo_vert   = filter_params_y->taps / 2 - 1;

    const int32_t fo_horiz  = filter_params_x->taps / 2 - 1;

    const int32_t bd        = 8;

    const int32_t bits      = FILTER_BITS * 2 - conv_params->round_0 - conv_params->round_1;

    // horizontal filter

    const uint8_t* src_horiz = src - fo_vert * src_stride;

    const int16_t* x_filter  = av1_get_interp_filter_subpel_kernel(*filter_params_x, subpel_x_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < im_h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t sum = (1 << (bd + FILTER_BITS - 1));

            for (int32_t k = 0; k < filter_params_x->taps; ++k) {

                sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];

            }

            assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));

            im_block[y * im_stride + x] = (int16_t)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

        }

    }

    // vertical filter

    int16_t*       src_vert    = im_block + fo_vert * im_stride;

    const int16_t* y_filter    = av1_get_interp_filter_subpel_kernel(*filter_params_y, subpel_y_q4 & SUBPEL_MASK);

    const int32_t  offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t sum = 1 << offset_bits;

            for (int32_t k = 0; k < filter_params_y->taps; ++k) {

                sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];

            }

            assert(0 <= sum && sum < (1 << (offset_bits + 2)));

            int16_t res             = (ConvBufType)(ROUND_POWER_OF_TWO(sum, conv_params->round_1) -

                                        ((1 << (offset_bits - conv_params->round_1)) +

                                         (1 << (offset_bits - conv_params->round_1 - 1))));

            dst[y * dst_stride + x] = (uint8_t)clip_pixel_highbd(ROUND_POWER_OF_TWO(res, bits), 8);

        }

    }

}

void svt_av1_convolve_y_sr_c(const uint8_t* src, int32_t src_stride, uint8_t* dst, int32_t dst_stride, int32_t w,

                             int32_t h, const InterpFilterParams* filter_params_x,

                             const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                             const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    assert(filter_params_y != NULL);

    const int32_t fo_vert = filter_params_y->taps / 2 - 1;

    (void)filter_params_x;

    (void)subpel_x_q4;

    (void)conv_params;

    assert(conv_params->round_0 <= FILTER_BITS);

    assert(((conv_params->round_0 + conv_params->round_1) <= (FILTER_BITS + 1)) ||

           ((conv_params->round_0 + conv_params->round_1) == (2 * FILTER_BITS)));

    // vertical filter

    const int16_t* y_filter = av1_get_interp_filter_subpel_kernel(*filter_params_y, subpel_y_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t res = 0;

            for (int32_t k = 0; k < filter_params_y->taps; ++k) {

                res += y_filter[k] * src[(y - fo_vert + k) * src_stride + x];

            }

            dst[y * dst_stride + x] = (uint8_t)clip_pixel_highbd(ROUND_POWER_OF_TWO(res, FILTER_BITS), 8);

        }

    }

}

void svt_av1_convolve_x_sr_c(const uint8_t* src, int32_t src_stride, uint8_t* dst, int32_t dst_stride, int32_t w,

                             int32_t h, const InterpFilterParams* filter_params_x,

                             const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                             const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    const int32_t fo_horiz = filter_params_x->taps / 2 - 1;

    const int32_t bits     = FILTER_BITS - conv_params->round_0;

    (void)filter_params_y;

    (void)subpel_y_q4;

    (void)conv_params;

    assert(bits >= 0);

    assert((FILTER_BITS - conv_params->round_1) >= 0 ||

           ((conv_params->round_0 + conv_params->round_1) == 2 * FILTER_BITS));

    // horizontal filter

    const int16_t* x_filter = av1_get_interp_filter_subpel_kernel(*filter_params_x, subpel_x_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t res = 0;

            for (int32_t k = 0; k < filter_params_x->taps; ++k) {

                res += x_filter[k] * src[y * src_stride + x - fo_horiz + k];

            }

            res                     = ROUND_POWER_OF_TWO(res, conv_params->round_0);

            dst[y * dst_stride + x] = (uint8_t)clip_pixel_highbd(ROUND_POWER_OF_TWO(res, bits), 8);

        }

    }

}

void svt_av1_convolve_2d_copy_sr_c(const uint8_t* src, int32_t src_stride, uint8_t* dst, int32_t dst_stride, int32_t w,

                                   int32_t h, const InterpFilterParams* filter_params_x,

                                   const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                                   const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    (void)filter_params_x;

    (void)filter_params_y;

    (void)subpel_x_q4;

    (void)subpel_y_q4;

    (void)conv_params;

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            dst[y * dst_stride + x] = src[y * src_stride + x];

        }

    }

}

void svt_av1_convolve_2d_scale_c(const uint8_t* src, int src_stride, uint8_t* dst8, int dst8_stride, int w, int h,

                                 const InterpFilterParams* filter_params_x, const InterpFilterParams* filter_params_y,

                                 const int subpel_x_qn, const int x_step_qn, const int subpel_y_qn, const int y_step_qn,

                                 ConvolveParams* conv_params) {

    int16_t        im_block[(2 * MAX_SB_SIZE + MAX_FILTER_TAP) * MAX_SB_SIZE];

    int            im_h         = (((h - 1) * y_step_qn + subpel_y_qn) >> SCALE_SUBPEL_BITS) + filter_params_y->taps;

    CONV_BUF_TYPE* dst16        = conv_params->dst;

    const int      dst16_stride = conv_params->dst_stride;

    const int      bits         = FILTER_BITS * 2 - conv_params->round_0 - conv_params->round_1;

    assert(bits >= 0);

    int       im_stride = w;

    const int fo_vert   = filter_params_y->taps / 2 - 1;

    const int fo_horiz  = filter_params_x->taps / 2 - 1;

    const int bd        = 8;

    // horizontal filter

    const uint8_t* src_horiz = src - fo_vert * src_stride;

    for (int y = 0; y < im_h; ++y) {

        int x_qn = subpel_x_qn;

        for (int x = 0; x < w; ++x, x_qn += x_step_qn) {

            const uint8_t* const src_x        = &src_horiz[(x_qn >> SCALE_SUBPEL_BITS)];

            const int            x_filter_idx = (x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;

            assert(x_filter_idx < SUBPEL_SHIFTS);

            const int16_t* x_filter = av1_get_interp_filter_subpel_kernel(*filter_params_x, x_filter_idx);

            int32_t        sum      = (1 << (bd + FILTER_BITS - 1));

            for (int k = 0; k < filter_params_x->taps; ++k) {

                sum += x_filter[k] * src_x[k - fo_horiz];

            }

            assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));

            im_block[y * im_stride + x] = (int16_t)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

        }

        src_horiz += src_stride;

    }

    // vertical filter

    int16_t*  src_vert    = im_block + fo_vert * im_stride;

    const int offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

    for (int x = 0; x < w; ++x) {

        int y_qn = subpel_y_qn;

        for (int y = 0; y < h; ++y, y_qn += y_step_qn) {

            const int16_t* src_y        = &src_vert[(y_qn >> SCALE_SUBPEL_BITS) * im_stride];

            const int      y_filter_idx = (y_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;

            assert(y_filter_idx < SUBPEL_SHIFTS);

            const int16_t* y_filter = av1_get_interp_filter_subpel_kernel(*filter_params_y, y_filter_idx);

            int32_t        sum      = 1 << offset_bits;

            for (int k = 0; k < filter_params_y->taps; ++k) {

                sum += y_filter[k] * src_y[(k - fo_vert) * im_stride];

            }

            assert(0 <= sum && sum < (1 << (offset_bits + 2)));

            CONV_BUF_TYPE res = ROUND_POWER_OF_TWO(sum, conv_params->round_1);

            if (conv_params->is_compound) {

                if (conv_params->do_average) {

                    int32_t tmp = dst16[y * dst16_stride + x];

                    if (conv_params->use_dist_wtd_comp_avg) {

                        tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

                        tmp = tmp >> DIST_PRECISION_BITS;

                    } else {

                        tmp += res;

                        tmp = tmp >> 1;

                    }

                    /* Subtract round offset and convolve round */

                    tmp = tmp -

                        ((1 << (offset_bits - conv_params->round_1)) + (1 << (offset_bits - conv_params->round_1 - 1)));

                    dst8[y * dst8_stride + x] = clip_pixel(ROUND_POWER_OF_TWO(tmp, bits));

                } else {

                    dst16[y * dst16_stride + x] = res;

                }

            } else {

                /* Subtract round offset and convolve round */

                int32_t tmp = res -

                    ((1 << (offset_bits - conv_params->round_1)) + (1 << (offset_bits - conv_params->round_1 - 1)));

                dst8[y * dst8_stride + x] = clip_pixel(ROUND_POWER_OF_TWO(tmp, bits));

            }

        }

        src_vert++;

    }

}

void svt_av1_jnt_convolve_2d_c(const uint8_t* src, int32_t src_stride, uint8_t* dst8, int32_t dst8_stride, int32_t w,

                               int32_t h, const InterpFilterParams* filter_params_x,

                               const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                               const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    ConvBufType*  dst        = conv_params->dst;

    int32_t       dst_stride = conv_params->dst_stride;

    int16_t       im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];

    int32_t       im_h       = h + filter_params_y->taps - 1;

    int32_t       im_stride  = w;

    const int32_t fo_vert    = filter_params_y->taps / 2 - 1;

    const int32_t fo_horiz   = filter_params_x->taps / 2 - 1;

    const int32_t bd         = 8;

    const int32_t round_bits = 2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

    // horizontal filter

    const uint8_t* src_horiz = src - fo_vert * src_stride;

    const int16_t* x_filter  = av1_get_interp_filter_subpel_kernel(*filter_params_x, subpel_x_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < im_h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t sum = (1 << (bd + FILTER_BITS - 1));

            for (int32_t k = 0; k < filter_params_x->taps; ++k) {

                sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];

            }

            assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));

            im_block[y * im_stride + x] = (int16_t)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

        }

    }

    // vertical filter

    int16_t*       src_vert    = im_block + fo_vert * im_stride;

    const int16_t* y_filter    = av1_get_interp_filter_subpel_kernel(*filter_params_y, subpel_y_q4 & SUBPEL_MASK);

    const int32_t  offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t sum = 1 << offset_bits;

            for (int32_t k = 0; k < filter_params_y->taps; ++k) {

                sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];

            }

            assert(0 <= sum && sum < (1 << (offset_bits + 2)));

            ConvBufType res = (ConvBufType)ROUND_POWER_OF_TWO(sum, conv_params->round_1);

            if (conv_params->do_average) {

                int32_t tmp = dst[y * dst_stride + x];

                if (conv_params->use_jnt_comp_avg) {

                    tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

                    tmp = tmp >> DIST_PRECISION_BITS;

                } else {

                    tmp += res;

                    tmp = tmp >> 1;

                }

                tmp -= (1 << (offset_bits - conv_params->round_1)) + (1 << (offset_bits - conv_params->round_1 - 1));

                dst8[y * dst8_stride + x] = (uint8_t)clip_pixel_highbd(ROUND_POWER_OF_TWO(tmp, round_bits), 8);

            } else {

                dst[y * dst_stride + x] = res;

            }

        }

    }

}

void svt_av1_jnt_convolve_y_c(const uint8_t* src, int32_t src_stride, uint8_t* dst8, int32_t dst8_stride, int32_t w,

                              int32_t h, const InterpFilterParams* filter_params_x,

                              const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                              const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    ConvBufType*  dst          = conv_params->dst;

    int32_t       dst_stride   = conv_params->dst_stride;

    const int32_t fo_vert      = filter_params_y->taps / 2 - 1;

    const int32_t bits         = FILTER_BITS - conv_params->round_0;

    const int32_t bd           = 8;

    const int32_t offset_bits  = bd + 2 * FILTER_BITS - conv_params->round_0;

    const int32_t round_offset = (1 << (offset_bits - conv_params->round_1)) +

        (1 << (offset_bits - conv_params->round_1 - 1));

    const int32_t round_bits = 2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

    (void)filter_params_x;

    (void)subpel_x_q4;

    // vertical filter

    const int16_t* y_filter = av1_get_interp_filter_subpel_kernel(*filter_params_y, subpel_y_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t res = 0;

            for (int32_t k = 0; k < filter_params_y->taps; ++k) {

                res += y_filter[k] * src[(y - fo_vert + k) * src_stride + x];

            }

            res *= (1 << bits);

            res = ROUND_POWER_OF_TWO(res, conv_params->round_1) + round_offset;

            if (conv_params->do_average) {

                int32_t tmp = dst[y * dst_stride + x];

                if (conv_params->use_jnt_comp_avg) {

                    tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

                    tmp = tmp >> DIST_PRECISION_BITS;

                } else {

                    tmp += res;

                    tmp = tmp >> 1;

                }

                tmp -= round_offset;

                dst8[y * dst8_stride + x] = (uint8_t)clip_pixel_highbd(ROUND_POWER_OF_TWO(tmp, round_bits), 8);

            } else {

                dst[y * dst_stride + x] = (ConvBufType)res;

            }

        }

    }

}

void svt_av1_jnt_convolve_x_c(const uint8_t* src, int32_t src_stride, uint8_t* dst8, int32_t dst8_stride, int32_t w,

                              int32_t h, const InterpFilterParams* filter_params_x,

                              const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                              const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    ConvBufType*  dst          = conv_params->dst;

    int32_t       dst_stride   = conv_params->dst_stride;

    const int32_t fo_horiz     = filter_params_x->taps / 2 - 1;

    const int32_t bits         = FILTER_BITS - conv_params->round_1;

    const int32_t bd           = 8;

    const int32_t offset_bits  = bd + 2 * FILTER_BITS - conv_params->round_0;

    const int32_t round_offset = (1 << (offset_bits - conv_params->round_1)) +

        (1 << (offset_bits - conv_params->round_1 - 1));

    const int32_t round_bits = 2 * FILTER_BITS - conv_params->round_0 - conv_params->round_1;

    (void)filter_params_y;

    (void)subpel_y_q4;

    // horizontal filter

    const int16_t* x_filter = av1_get_interp_filter_subpel_kernel(*filter_params_x, subpel_x_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t res = 0;

            for (int32_t k = 0; k < filter_params_x->taps; ++k) {

                res += x_filter[k] * src[y * src_stride + x - fo_horiz + k];

            }

            res = (1 << bits) * ROUND_POWER_OF_TWO(res, conv_params->round_0);

            res += round_offset;

            if (conv_params->do_average) {

                int32_t tmp = dst[y * dst_stride + x];

                if (conv_params->use_jnt_comp_avg) {

                    tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

                    tmp = tmp >> DIST_PRECISION_BITS;

                } else {

                    tmp += res;

                    tmp = tmp >> 1;

                }

                tmp -= round_offset;

                dst8[y * dst8_stride + x] = (uint8_t)clip_pixel_highbd(ROUND_POWER_OF_TWO(tmp, round_bits), 8);

            } else {

                dst[y * dst_stride + x] = (ConvBufType)res;

            }

        }

    }

}

void svt_av1_jnt_convolve_2d_copy_c(const uint8_t* src, int32_t src_stride, uint8_t* dst8, int32_t dst8_stride,

                                    int32_t w, int32_t h, const InterpFilterParams* filter_params_x,

                                    const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                                    const int32_t subpel_y_q4, ConvolveParams* conv_params) {

    ConvBufType*  dst          = conv_params->dst;

    int32_t       dst_stride   = conv_params->dst_stride;

    const int32_t bits         = FILTER_BITS * 2 - conv_params->round_1 - conv_params->round_0;

    const int32_t bd           = 8;

    const int32_t offset_bits  = bd + 2 * FILTER_BITS - conv_params->round_0;

    const int32_t round_offset = (1 << (offset_bits - conv_params->round_1)) +

        (1 << (offset_bits - conv_params->round_1 - 1));

    (void)filter_params_x;

    (void)filter_params_y;

    (void)subpel_x_q4;

    (void)subpel_y_q4;

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            ConvBufType res = src[y * src_stride + x] << bits;

            res += (ConvBufType)round_offset;

            if (conv_params->do_average) {

                int32_t tmp = dst[y * dst_stride + x];

                if (conv_params->use_jnt_comp_avg) {

                    tmp = tmp * conv_params->fwd_offset + res * conv_params->bck_offset;

                    tmp = tmp >> DIST_PRECISION_BITS;

                } else {

                    tmp += res;

                    tmp = tmp >> 1;

                }

                tmp -= round_offset;

                dst8[y * dst8_stride + x] = (uint8_t)clip_pixel_highbd(ROUND_POWER_OF_TWO(tmp, bits), 8);

            } else {

                dst[y * dst_stride + x] = res;

            }

        }

    }

}

void svt_av1_highbd_convolve_2d_copy_sr_c(const uint16_t* src, int32_t src_stride, uint16_t* dst, int32_t dst_stride,

                                          int32_t w, int32_t h, const InterpFilterParams* filter_params_x,

                                          const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                                          const int32_t subpel_y_q4, ConvolveParams* conv_params, int32_t bd) {

    (void)filter_params_x;

    (void)filter_params_y;

    (void)subpel_x_q4;

    (void)subpel_y_q4;

    (void)conv_params;

    (void)bd;

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            dst[y * dst_stride + x] = src[y * src_stride + x];

        }

    }

}

void svt_av1_highbd_convolve_x_sr_c(const uint16_t* src, int32_t src_stride, uint16_t* dst, int32_t dst_stride,

                                    int32_t w, int32_t h, const InterpFilterParams* filter_params_x,

                                    const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                                    const int32_t subpel_y_q4, ConvolveParams* conv_params, int32_t bd) {

    const int32_t fo_horiz = filter_params_x->taps / 2 - 1;

    const int32_t bits     = FILTER_BITS - conv_params->round_0;

    (void)filter_params_y;

    (void)subpel_y_q4;

    assert(bits >= 0);

    assert((FILTER_BITS - conv_params->round_1) >= 0 ||

           ((conv_params->round_0 + conv_params->round_1) == 2 * FILTER_BITS));

    // horizontal filter

    const int16_t* x_filter = av1_get_interp_filter_subpel_kernel(*filter_params_x, subpel_x_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t res = 0;

            for (int32_t k = 0; k < filter_params_x->taps; ++k) {

                res += x_filter[k] * src[y * src_stride + x - fo_horiz + k];

            }

            res                     = ROUND_POWER_OF_TWO(res, conv_params->round_0);

            dst[y * dst_stride + x] = clip_pixel_highbd(ROUND_POWER_OF_TWO(res, bits), bd);

        }

    }

}

void svt_av1_highbd_convolve_y_sr_c(const uint16_t* src, int32_t src_stride, uint16_t* dst, int32_t dst_stride,

                                    int32_t w, int32_t h, const InterpFilterParams* filter_params_x,

                                    const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                                    const int32_t subpel_y_q4, ConvolveParams* conv_params, int32_t bd) {

    assert(filter_params_y != NULL);

    const int32_t fo_vert = filter_params_y->taps / 2 - 1;

    (void)filter_params_x;

    (void)subpel_x_q4;

    (void)conv_params;

    assert(conv_params->round_0 <= FILTER_BITS);

    assert(((conv_params->round_0 + conv_params->round_1) <= (FILTER_BITS + 1)) ||

           ((conv_params->round_0 + conv_params->round_1) == (2 * FILTER_BITS)));

    // vertical filter

    const int16_t* y_filter = av1_get_interp_filter_subpel_kernel(*filter_params_y, subpel_y_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t res = 0;

            for (int32_t k = 0; k < filter_params_y->taps; ++k) {

                res += y_filter[k] * src[(y - fo_vert + k) * src_stride + x];

            }

            dst[y * dst_stride + x] = clip_pixel_highbd(ROUND_POWER_OF_TWO(res, FILTER_BITS), bd);

        }

    }

}

void svt_av1_highbd_convolve_2d_sr_c(const uint16_t* src, int32_t src_stride, uint16_t* dst, int32_t dst_stride,

                                     int32_t w, int32_t h, const InterpFilterParams* filter_params_x,

                                     const InterpFilterParams* filter_params_y, const int32_t subpel_x_q4,

                                     const int32_t subpel_y_q4, ConvolveParams* conv_params, int32_t bd) {

    int16_t       im_block[(MAX_SB_SIZE + MAX_FILTER_TAP - 1) * MAX_SB_SIZE];

    int32_t       im_h      = h + filter_params_y->taps - 1;

    int32_t       im_stride = w;

    const int32_t fo_vert   = filter_params_y->taps / 2 - 1;

    const int32_t fo_horiz  = filter_params_x->taps / 2 - 1;

    const int32_t bits      = FILTER_BITS * 2 - conv_params->round_0 - conv_params->round_1;

    assert(bits >= 0);

    // horizontal filter

    const uint16_t* src_horiz = src - fo_vert * src_stride;

    const int16_t*  x_filter  = av1_get_interp_filter_subpel_kernel(*filter_params_x, subpel_x_q4 & SUBPEL_MASK);

    for (int32_t y = 0; y < im_h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t sum = (1 << (bd + FILTER_BITS - 1));

            for (int32_t k = 0; k < filter_params_x->taps; ++k) {

                sum += x_filter[k] * src_horiz[y * src_stride + x - fo_horiz + k];

            }

            assert(0 <= sum && sum < (1 << (bd + FILTER_BITS + 1)));

            im_block[y * im_stride + x] = (ConvBufType)ROUND_POWER_OF_TWO(sum, conv_params->round_0);

        }

    }

    // vertical filter

    int16_t*       src_vert    = im_block + fo_vert * im_stride;

    const int16_t* y_filter    = av1_get_interp_filter_subpel_kernel(*filter_params_y, subpel_y_q4 & SUBPEL_MASK);

    const int32_t  offset_bits = bd + 2 * FILTER_BITS - conv_params->round_0;

    for (int32_t y = 0; y < h; ++y) {

        for (int32_t x = 0; x < w; ++x) {

            int32_t sum = 1 << offset_bits;

            for (int32_t k = 0; k < filter_params_y->taps; ++k) {

                sum += y_filter[k] * src_vert[(y - fo_vert + k) * im_stride + x];

            }

            assert(0 <= sum && sum < (1 << (offset_bits + 2)));

            int32_t res = ROUND_POWER_OF_TWO(sum, conv_params->round_1) -

                ((1 << (offset_bits - conv_params->round_1)) + (1 << (offset_bits - conv_params->round_1 - 1)));

            dst[y * dst_stride + x] = clip_pixel_highbd(ROUND_POWER_OF_TWO(res, bits), bd);

        }

    }

}

void svt_av1_highbd_convolve_2d_scale_c(const uint16_t* src, int src_stride, uint16_t* dst, int dst_stride, int w,

                                        int h, const InterpFilterParams* filter_params_x,

                                        const InterpFilterParams* filter_params_y, const int subpel_x_qn,

                                        const int x_step_qn, const int subpel_y_qn, const int y_step_qn,

                                        ConvolveParams* conv_params, int bd) {

    int16_t        im_block[(2 * MAX_SB_SIZE + MAX_FILTER_TAP) * MAX_SB_SIZE];

    int            im_h         = (((h - 1) * y_step_qn + subpel_y_qn) >> SCALE_SUBPEL_BITS) + filter_params_y->taps;

    int            im_stride    = w;

    const int      fo_vert      = filter_params_y->taps / 2 - 1;

    const int      fo_horiz     = filter_params_x->taps / 2 - 1;

    CONV_BUF_TYPE* dst16        = conv_params->dst;

    const int      dst16_stride = conv_params->dst_stride;

    const int      bits         = FILTER_BITS * 2 - conv_params->round_0 - conv_params->round_1;

    assert(bits >= 0);

    // horizontal filter

    const uint16_t* src_horiz = src - fo_vert * src_stride;

    for (int y = 0; y < im_h; ++y) {

        int x_qn = subpel_x_qn;

        for (int x = 0; x < w; ++x, x_qn += x_step_qn) {

            const uint16_t* const src_x        = &src_horiz[(x_qn >> SCALE_SUBPEL_BITS)];

            const int             x_filter_idx = (x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS;