/*

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

 *

 * This source code is subject to the terms of the BSD 2 Clause License and

 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License

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

 * obtain it at https://www.aomedia.org/license/software-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 <limits.h>

#include <math.h>

#include <stdio.h>

#include "av1me.h"

#include "mcomp.h"

#include "utility.h"

#include "pcs.h"

#include "sequence_control_set.h"

#include "aom_dsp_rtcd.h"

#include "md_process.h"

#include "adaptive_mv_pred.h"

AomVarianceFnPtr svt_aom_mefn_ptr[BLOCK_SIZES_ALL];

void init_fn_ptr(void) {

#if CONFIG_ENABLE_HIGH_BIT_DEPTH

#define BFP0(w, h)                                                                     \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].sdf       = svt_aom_sad##w##x##h;                \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].vf        = svt_aom_variance##w##x##h;           \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].vf_hbd_10 = svt_aom_highbd_10_variance##w##x##h; \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].svf       = svt_aom_sub_pixel_variance##w##x##h; \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].sdx4df    = svt_aom_sad##w##x##h##x4d;

#else

#define BFP0(w, h)                                                                  \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].sdf    = svt_aom_sad##w##x##h;                \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].vf     = svt_aom_variance##w##x##h;           \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].svf    = svt_aom_sub_pixel_variance##w##x##h; \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].sdx4df = svt_aom_sad##w##x##h##x4d;

#endif

    BFP0(4, 16)

    BFP0(16, 4)

    BFP0(8, 32)

    BFP0(32, 8)

    BFP0(16, 64)

    BFP0(64, 16)

    BFP0(128, 128)

    BFP0(128, 64)

    BFP0(64, 128)

    BFP0(32, 16)

    BFP0(16, 32)

    BFP0(64, 32)

    BFP0(32, 64)

    BFP0(32, 32)

    BFP0(64, 64)

    BFP0(16, 16)

    BFP0(16, 8)

    BFP0(8, 16)

    BFP0(8, 8)

    BFP0(8, 4)

    BFP0(4, 8)

    BFP0(4, 4)

#if CONFIG_ENABLE_OBMC

#define OBFP(w, h)                                                           \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].osdf = svt_aom_obmc_sad##w##x##h;      \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].ovf  = svt_aom_obmc_variance##w##x##h; \

    svt_aom_mefn_ptr[BLOCK_##w##X##h].osvf = svt_aom_obmc_sub_pixel_variance##w##x##h;

    OBFP(128, 128)

    OBFP(128, 64)

    OBFP(64, 128)

    OBFP(64, 64)

    OBFP(64, 32)

    OBFP(32, 64)

    OBFP(32, 32)

    OBFP(32, 16)

    OBFP(16, 32)

    OBFP(16, 16)

    OBFP(16, 8)

    OBFP(8, 16)

    OBFP(8, 8)

    OBFP(4, 8)

    OBFP(8, 4)

    OBFP(4, 4)

    OBFP(4, 16)

    OBFP(16, 4)

    OBFP(8, 32)

    OBFP(32, 8)

    OBFP(16, 64)

    OBFP(64, 16)

#endif

}

static INLINE const uint8_t* get_buf_from_mv(const Buf2D* buf, const Mv mv) {

    return &buf->buf[mv.y * buf->stride + mv.x];

}

void svt_av1_set_mv_search_range(MvLimits* mv_limits, const Mv mv) {

    int col_min = (mv.x >> 3) - MAX_FULL_PEL_VAL + !!(mv.x & 7);

    int row_min = (mv.y >> 3) - MAX_FULL_PEL_VAL + !!(mv.y & 7);

    int col_max = (mv.x >> 3) + MAX_FULL_PEL_VAL;

    int row_max = (mv.y >> 3) + MAX_FULL_PEL_VAL;

    col_min = AOMMAX(col_min, (MV_LOW >> 3) + 1);

    row_min = AOMMAX(row_min, (MV_LOW >> 3) + 1);

    col_max = AOMMIN(col_max, (MV_UPP >> 3) - 1);

    row_max = AOMMIN(row_max, (MV_UPP >> 3) - 1);

    // Get intersection of UMV window and valid MV window to reduce # of checks

    // in diamond search.

    if (mv_limits->col_min < col_min) {

        mv_limits->col_min = col_min;

    }

    if (mv_limits->col_max > col_max) {

        mv_limits->col_max = col_max;

    }

    if (mv_limits->row_min < row_min) {

        mv_limits->row_min = row_min;

    }

    if (mv_limits->row_max > row_max) {

        mv_limits->row_max = row_max;

    }

}

int svt_aom_mv_err_cost_light(const Mv mv, const Mv ref) {

    const uint32_t factor     = 50;

    const uint32_t absmvdiffx = ABS(mv.x - ref.x);

    const uint32_t absmvdiffy = ABS(mv.y - ref.y);

    const uint32_t mv_rate    = 1296 + (factor * (absmvdiffx + absmvdiffy));

    return mv_rate;

}

static int mvsad_err_cost_light(const Mv mv, const Mv ref) {

    const uint32_t factor     = 50;

    const uint32_t absmvdiffx = ABS(mv.x - ref.x) * 8;

    const uint32_t absmvdiffy = ABS(mv.y - ref.y) * 8;

    const uint32_t mv_rate    = 1296 + (factor * (absmvdiffx + absmvdiffy));

    return mv_rate;

}

int svt_aom_mv_err_cost(const Mv mv, const Mv ref, const int* mvjcost, const int* mvcost[2], int error_per_bit) {

    if (mvcost) {

        const Mv diff = (Mv){{mv.x - ref.x, mv.y - ref.y}};

        return (int)ROUND_POWER_OF_TWO_64(

            (int64_t)svt_mv_cost(diff, mvjcost, mvcost) * error_per_bit,

            RDDIV_BITS + AV1_PROB_COST_SHIFT - RD_EPB_SHIFT + PIXEL_TRANSFORM_ERROR_SCALE);

    }

    return 0;

}

static int mvsad_err_cost(const IntraBcContext* x, const Mv mv, const Mv ref, int sad_per_bit) {

    if (x->approx_inter_rate) {

        return mvsad_err_cost_light(mv, ref);

    }

    const Mv diff = (Mv){{(mv.x - ref.x) * 8, (mv.y - ref.y) * 8}};

    return ROUND_POWER_OF_TWO(

        (unsigned)svt_mv_cost(diff, x->nmv_vec_cost, (const int* const*)x->mv_cost_stack) * sad_per_bit,

        AV1_PROB_COST_SHIFT);

}

void svt_av1_init3smotion_compensation(SearchSiteConfig* cfg, int stride) {

    int len, ss_count = 1;

    cfg->ss[0].mv.as_int = 0;

    cfg->ss[0].offset    = 0;

    for (len = MAX_FIRST_STEP; len > 0; len /= 2) {

        // Generate offsets for 8 search sites per step.

        const Mv ss_mvs[8] = {{{0, -len}},

                              {{0, len}},

                              {{-len, 0}},

                              {{len, 0}},

                              {{-len, -len}},

                              {{len, -len}},

                              {{-len, len}},

                              {{len, len}}};

        int      i;

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

            SearchSite* const ss = &cfg->ss[ss_count++];

            ss->mv               = ss_mvs[i];

            ss->offset           = ss->mv.y * stride + ss->mv.x;

        }

    }

    cfg->ss_count          = ss_count;

    cfg->searches_per_step = 8;

}

static INLINE int is_mv_in(const MvLimits* mv_limits, const Mv mv) {

    return (mv.x >= mv_limits->col_min) && (mv.x <= mv_limits->col_max) && (mv.y >= mv_limits->row_min) &&

        (mv.y <= mv_limits->row_max);

}

int svt_av1_get_mvpred_var(const IntraBcContext* x, const Mv best_mv, const Mv center_mv, const AomVarianceFnPtr* vfp,

                           int use_mvcost) {

    const Buf2D* const what    = &x->plane[0].src;

    const Buf2D* const in_what = &x->xdplane[0].pre[0];

    const Mv           mv      = {{best_mv.x * 8, best_mv.y * 8}};

    unsigned int       unused;

    if (x->approx_inter_rate) {

        return vfp->vf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv), in_what->stride, &unused) +

            (use_mvcost ? svt_aom_mv_err_cost_light(mv, center_mv) : 0);

    } else {

        return vfp->vf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv), in_what->stride, &unused) +

            (use_mvcost ? svt_aom_mv_err_cost(mv, center_mv, x->nmv_vec_cost, x->mv_cost_stack, x->errorperbit) : 0);

    }

}

// Predictor-first early exit for RTC IntraBC: evaluate the AV1 DV predictor's SAD directly and, if

// the per-pixel SAD is within the budget (0 => exact match only), accept it and skip the hash and

// full-pixel searches. Returns 1 and writes *best_pred_mv (full-pel) when accepted, else 0.

int svt_av1_intrabc_pred_first(IntraBcContext* x, BlockSize bsize, const Mv* mvp_full, uint16_t pred_exit_th,

                               Mv* best_pred_mv) {

    if (!is_mv_in(&x->mv_limits, *mvp_full)) {

        return 0;

    }

    const AomVarianceFnPtr* fn_ptr  = &svt_aom_mefn_ptr[bsize];

    const Buf2D* const      what    = &x->plane[0].src;

    const Buf2D* const      in_what = &x->xdplane[0].pre[0];

    const unsigned int sad = fn_ptr->sdf(what->buf, what->stride, get_buf_from_mv(in_what, *mvp_full), in_what->stride);

    const unsigned int area = (unsigned int)block_size_wide[bsize] * (unsigned int)block_size_high[bsize];

    if (sad <= (unsigned int)pred_exit_th * area) {

        *best_pred_mv = *mvp_full;

        return 1;

    }

    return 0;

}

// BVP candidate evaluation for the RTC IntraBC fallback: evaluate up to 4 full-pel DV candidates

// (neighbour predictor, second predictor, frame's last-used DV) in a single sad_x4d call and return

// the lowest-SAD one within the budget. Zero (self) and out-of-range candidates are excluded; their

// x4d slots are padded with the first valid candidate so all 4 addresses are safe.

// Returns 1 and writes *best (full-pel) when one qualifies, else 0.

int svt_av1_intrabc_pred_best4(IntraBcContext* x, BlockSize bsize, const Mv cands[4], uint16_t pred_exit_th, Mv* best) {

    bool valid[4];

    int  pad = -1;

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

        valid[i] = (cands[i].as_int != 0) && is_mv_in(&x->mv_limits, cands[i]);

        if (valid[i] && pad < 0) {

            pad = i;

        }

    }

    if (pad < 0) {

        return 0;

    }

    const AomVarianceFnPtr* fn_ptr  = &svt_aom_mefn_ptr[bsize];

    const Buf2D* const      what    = &x->plane[0].src;

    const Buf2D* const      in_what = &x->xdplane[0].pre[0];

    const uint8_t*          addrs[4];

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

        addrs[i] = get_buf_from_mv(in_what, valid[i] ? cands[i] : cands[pad]);

    }

    unsigned int sads[4];

    fn_ptr->sdx4df(what->buf, what->stride, addrs, in_what->stride, sads);

    const unsigned int area     = (unsigned int)block_size_wide[bsize] * (unsigned int)block_size_high[bsize];

    int                best_i   = -1;

    unsigned int       best_sad = UINT_MAX;

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

        if (valid[i] && sads[i] < best_sad) {

            best_sad = sads[i];

            best_i   = i;

        }

    }

    if (best_i >= 0 && best_sad <= (unsigned int)pred_exit_th * area) {

        *best = cands[best_i];

        return 1;

    }

    return 0;

}

// One-shot offset probe for the RTC IntraBC fallback (variant A): given a qualifying full-pel center

// DV, evaluate a fixed cloud of integer offsets around it (radius-1 ring then radius-2) in one pass

// and return the lowest-SAD point (possibly the center), at a fixed cost of ceil(npts/4) sad_x4d

// calls. Out-of-range offsets are skipped; x4d slots are padded with the first valid address.

void svt_av1_intrabc_probe_around(IntraBcContext* x, BlockSize bsize, Mv center, int npts, Mv* best) {

    static const int8_t off[16][2] = {{1, 0},

                                      {-1, 0},

                                      {0, 1},

                                      {0, -1},

                                      {1, 1},

                                      {1, -1},

                                      {-1, 1},

                                      {-1, -1},

                                      {2, 0},

                                      {-2, 0},

                                      {0, 2},

                                      {0, -2},

                                      {2, 2},

                                      {2, -2},

                                      {-2, 2},

                                      {-2, -2}};

    if (npts > 16) {

        npts = 16;

    }

    const AomVarianceFnPtr* fn_ptr  = &svt_aom_mefn_ptr[bsize];

    const Buf2D* const      what    = &x->plane[0].src;

    const Buf2D* const      in_what = &x->xdplane[0].pre[0];

    Mv                      bestmv  = center;

    unsigned int best_sad = fn_ptr->sdf(what->buf, what->stride, get_buf_from_mv(in_what, center), in_what->stride);

    for (int base = 0; base < npts; base += 4) {

        Mv             cand[4];

        const uint8_t* addr[4];

        int            nv = 0;

        for (int k = 0; k < 4 && base + k < npts; ++k) {

            Mv c = {{(int16_t)(center.x + off[base + k][0]), (int16_t)(center.y + off[base + k][1])}};

            if (is_mv_in(&x->mv_limits, c)) {

                cand[nv] = c;

                addr[nv] = get_buf_from_mv(in_what, c);

                ++nv;

            }

        }

        if (!nv) {

            continue;

        }

        for (int k = nv; k < 4; ++k) {

            cand[k] = cand[0];

            addr[k] = addr[0];

        }

        unsigned int sads[4];

        fn_ptr->sdx4df(what->buf, what->stride, addr, in_what->stride, sads);

        for (int k = 0; k < nv; ++k) {

            if (sads[k] < best_sad) {

                best_sad = sads[k];

                bestmv   = cand[k];

            }

        }

    }

    *best = bestmv;

}

// Exhaustive motion search around a given centre position with a given

// step size.

static int exhaustive_mesh_search(IntraBcContext* x, Mv* ref_mv, Mv* best_mv, int range, int step, int sad_per_bit,

                                  const AomVarianceFnPtr* fn_ptr, const Mv center_mv) {

    const Buf2D* const what       = &x->plane[0].src;

    const Buf2D* const in_what    = &x->xdplane[0].pre[0];

    Mv                 fcenter_mv = {.as_int = center_mv.as_int};

    unsigned int       best_sad   = INT_MAX;

    int                r, c, i;

    int                start_col, end_col, start_row, end_row;

    int                col_step = (step > 1) ? step : 4;

    assert(step >= 1);

    clamp_mv(&fcenter_mv, x->mv_limits.col_min, x->mv_limits.col_max, x->mv_limits.row_min, x->mv_limits.row_max);

    *best_mv = fcenter_mv;

    best_sad = fn_ptr->sdf(what->buf, what->stride, get_buf_from_mv(in_what, fcenter_mv), in_what->stride) +

        mvsad_err_cost(x, fcenter_mv, *ref_mv, sad_per_bit);

    start_row = AOMMAX(-range, x->mv_limits.row_min - fcenter_mv.y);

    start_col = AOMMAX(-range, x->mv_limits.col_min - fcenter_mv.x);

    end_row   = AOMMIN(range, x->mv_limits.row_max - fcenter_mv.y);

    end_col   = AOMMIN(range, x->mv_limits.col_max - fcenter_mv.x);

    for (r = start_row; r <= end_row; r += step) {

        for (c = start_col; c <= end_col; c += col_step) {

            // Step > 1 means we are not checking every location in this pass.

            if (step > 1) {

                const Mv     mv  = {{fcenter_mv.x + c, fcenter_mv.y + r}};

                unsigned int sad = fn_ptr->sdf(what->buf, what->stride, get_buf_from_mv(in_what, mv), in_what->stride);

                if (sad < best_sad) {

                    sad += mvsad_err_cost(x, mv, *ref_mv, sad_per_bit);

                    if (sad < best_sad) {

                        best_sad          = sad;

                        x->second_best_mv = *best_mv;

                        *best_mv          = mv;

                    }

                }

            } else {

                // 4 sads in a single call if we are checking every location

                if (c + 3 <= end_col) {

                    unsigned int   sads[4];

                    const uint8_t* addrs[4];

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

                        const Mv mv = {{fcenter_mv.x + c + i, fcenter_mv.y + r}};

                        addrs[i]    = get_buf_from_mv(in_what, mv);

                    }

                    fn_ptr->sdx4df(what->buf, what->stride, addrs, in_what->stride, sads);

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

                        if (sads[i] < best_sad) {

                            const Mv           mv  = {{fcenter_mv.x + c + i, fcenter_mv.y + r}};

                            const unsigned int sad = sads[i] + mvsad_err_cost(x, mv, *ref_mv, sad_per_bit);

                            if (sad < best_sad) {

                                best_sad          = sad;

                                x->second_best_mv = *best_mv;

                                *best_mv          = mv;

                            }

                        }

                    }

                } else {

                    for (i = 0; i < end_col - c; ++i) {

                        const Mv     mv  = {{fcenter_mv.x + c + i, fcenter_mv.y + r}};

                        unsigned int sad = fn_ptr->sdf(

                            what->buf, what->stride, get_buf_from_mv(in_what, mv), in_what->stride);

                        if (sad < best_sad) {

                            sad += mvsad_err_cost(x, mv, *ref_mv, sad_per_bit);

                            if (sad < best_sad) {

                                best_sad          = sad;

                                x->second_best_mv = *best_mv;

                                *best_mv          = mv;

                            }

                        }

                    }

                }

            }

        }

    }

    return best_sad;

}

int svt_av1_diamond_search_sad_c(IntraBcContext* x, const SearchSiteConfig* cfg, Mv* ref_mv, Mv* best_mv,

                                 int search_param, int sad_per_bit, int* num00, const AomVarianceFnPtr* fn_ptr,

                                 const Mv center_mv) {

    int i, j, step;

    uint8_t*       what        = x->plane[0].src.buf;

    const int      what_stride = x->plane[0].src.stride;

    const uint8_t* in_what;

    const int      in_what_stride = x->xdplane[0].pre[0].stride;

    const uint8_t* best_address;

    unsigned int bestsad;

    int          best_site = 0;

    int          last_site = 0;

    int ref_row;

    int ref_col;

    // search_param determines the length of the initial step and hence the number

    // of iterations.

    // 0 = initial step (MAX_FIRST_STEP) pel

    // 1 = (MAX_FIRST_STEP/2) pel,

    // 2 = (MAX_FIRST_STEP/4) pel...

    const SearchSite* ss        = &cfg->ss[search_param * cfg->searches_per_step];

    const int         tot_steps = (cfg->ss_count / cfg->searches_per_step) - search_param;

    const Mv fcenter_mv = {{center_mv.x >> 3, center_mv.y >> 3}};

    clamp_mv(ref_mv, x->mv_limits.col_min, x->mv_limits.col_max, x->mv_limits.row_min, x->mv_limits.row_max);

    ref_row    = ref_mv->y;

    ref_col    = ref_mv->x;

    *num00     = 0;

    best_mv->y = ref_row;

    best_mv->x = ref_col;

    // Work out the start point for the search

    in_what      = x->xdplane[0].pre[0].buf + ref_row * in_what_stride + ref_col;

    best_address = in_what;

    // Check the starting position

    bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride) +

        mvsad_err_cost(x, *best_mv, fcenter_mv, sad_per_bit);

    i = 1;

    for (step = 0; step < tot_steps; step++) {

        int all_in = 1;

        // All_in is true if every one of the points we are checking are within

        // the bounds of the image.

        all_in &= ((best_mv->y + ss[i].mv.y) > x->mv_limits.row_min);

        all_in &= ((best_mv->y + ss[i + 1].mv.y) < x->mv_limits.row_max);

        all_in &= ((best_mv->x + ss[i + 2].mv.x) > x->mv_limits.col_min);

        all_in &= ((best_mv->x + ss[i + 3].mv.x) < x->mv_limits.col_max);

        // If all the pixels are within the bounds we don't check whether the

        // search point is valid in this loop,  otherwise we check each point

        // for validity..

        if (all_in) {

            unsigned int sad_array[4];

            for (j = 0; j < cfg->searches_per_step; j += 4) {

                unsigned char const* block_offset[4];

                for (int t = 0; t < 4; t++) {

                    block_offset[t] = ss[i + t].offset + best_address;

                }

                fn_ptr->sdx4df(what, what_stride, block_offset, in_what_stride, sad_array);

                for (int t = 0; t < 4; t++, i++) {

                    if (sad_array[t] < bestsad) {

                        const Mv this_mv = {{best_mv->x + ss[i].mv.x, best_mv->y + ss[i].mv.y}};

                        sad_array[t] += mvsad_err_cost(x, this_mv, fcenter_mv, sad_per_bit);

                        if (sad_array[t] < bestsad) {

                            bestsad   = sad_array[t];

                            best_site = i;

                        }

                    }

                }

            }

        } else {

            for (j = 0; j < cfg->searches_per_step; j++) {

                // Trap illegal vectors

                const Mv this_mv = {{best_mv->x + ss[i].mv.x, best_mv->y + ss[i].mv.y}};

                if (is_mv_in(&x->mv_limits, this_mv)) {

                    const uint8_t* const check_here = ss[i].offset + best_address;

                    unsigned int         thissad    = fn_ptr->sdf(what, what_stride, check_here, in_what_stride);

                    if (thissad < bestsad) {

                        thissad += mvsad_err_cost(x, this_mv, fcenter_mv, sad_per_bit);

                        if (thissad < bestsad) {

                            bestsad   = thissad;

                            best_site = i;

                        }

                    }

                }

                i++;

            }

        }

        if (best_site != last_site) {

            x->second_best_mv = *best_mv;

            best_mv->y += ss[best_site].mv.y;

            best_mv->x += ss[best_site].mv.x;

            best_address += ss[best_site].offset;

            last_site = best_site;

#if defined(NEW_DIAMOND_SEARCH)

            while (1) {

                const Mv this_mv = {{best_mv->x + ss[best_site].mv.x, best_mv->y + ss[best_site].mv.y}};

                if (is_mv_in(&x->mv_limits, &this_mv)) {

                    const uint8_t* const check_here = ss[best_site].offset + best_address;

                    unsigned int         thissad    = fn_ptr->sdf(what, what_stride, check_here, in_what_stride);

                    if (thissad < bestsad) {

                        thissad += mvsad_err_cost(x, this_mv, fcenter_mv, sad_per_bit);

                        if (thissad < bestsad) {

                            bestsad = thissad;

                            best_mv->y += ss[best_site].mv.y;

                            best_mv->x += ss[best_site].mv.x;

                            best_address += ss[best_site].offset;

                            continue;

                        }

                    }

                }

                break;

            }

#endif

        } else if (best_address == in_what) {

            (*num00)++;

        }

    }

    return bestsad;

}

static int svt_av1_refining_search_sad(IntraBcContext* x, Mv* ref_mv, int error_per_bit, int search_range,

                                       const AomVarianceFnPtr* fn_ptr, const Mv center_mv) {

    const Mv           neighbors[4] = {{{0, -1}}, {{-1, 0}}, {{1, 0}}, {{0, 1}}};

    const Buf2D* const what         = &x->plane[0].src;

    const Buf2D* const in_what      = &x->xdplane[0].pre[0];

    const Mv           fcenter_mv   = {{center_mv.x >> 3, center_mv.y >> 3}};

    const uint8_t*     best_address = get_buf_from_mv(in_what, *ref_mv);

    unsigned int       best_sad     = fn_ptr->sdf(what->buf, what->stride, best_address, in_what->stride) +

        mvsad_err_cost(x, *ref_mv, fcenter_mv, error_per_bit);

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

        int       best_site = -1;

        const int all_in    = (ref_mv->y - 1) > x->mv_limits.row_min && (ref_mv->y + 1) < x->mv_limits.row_max &&

            (ref_mv->x - 1) > x->mv_limits.col_min && (ref_mv->x + 1) < x->mv_limits.col_max;

        if (all_in) {

            unsigned int         sads[4];

            const uint8_t* const positions[4] = {

                best_address - in_what->stride, best_address - 1, best_address + 1, best_address + in_what->stride};

            fn_ptr->sdx4df(what->buf, what->stride, positions, in_what->stride, sads);

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

                if (sads[j] < best_sad) {

                    const Mv mv = {{ref_mv->x + neighbors[j].x, ref_mv->y + neighbors[j].y}};

                    sads[j] += mvsad_err_cost(x, mv, fcenter_mv, error_per_bit);

                    if (sads[j] < best_sad) {

                        best_sad  = sads[j];

                        best_site = j;

                    }

                }

            }

        } else {

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

                const Mv mv = {{ref_mv->x + neighbors[j].x, ref_mv->y + neighbors[j].y}};

                if (is_mv_in(&x->mv_limits, mv)) {

                    unsigned int sad = fn_ptr->sdf(

                        what->buf, what->stride, get_buf_from_mv(in_what, mv), in_what->stride);

                    if (sad < best_sad) {

                        sad += mvsad_err_cost(x, mv, fcenter_mv, error_per_bit);

                        if (sad < best_sad) {

                            best_sad  = sad;

                            best_site = j;

                        }

                    }

                }

            }

        }

        if (best_site == -1) {

            break;

        } else {

            x->second_best_mv = *ref_mv;

            ref_mv->y += neighbors[best_site].y;

            ref_mv->x += neighbors[best_site].x;

            best_address = get_buf_from_mv(in_what, *ref_mv);

        }

    }

    return best_sad;

}

/* do_refine: If last step (1-away) of n-step search doesn't pick the center

              point as the best match, we will do a final 1-away diamond

              refining search  */

static int full_pixel_diamond(PictureControlSet* pcs, IntraBcContext /*MACROBLOCK*/* x, Mv* mvp_full, int step_param,

                              int sadpb, int further_steps, int do_refine, int* cost_list,

                              const AomVarianceFnPtr* fn_ptr, const Mv ref_mv) {

    Mv  temp_mv;

    int thissme, n, num00 = 0;

    (void)cost_list;

    /*int bestsme = cpi->diamond_search_sad(x, &cpi->ss_cfg, mvp_full, &temp_mv,

                                        step_param, sadpb, &n, fn_ptr, ref_mv);*/

    int bestsme = svt_av1_diamond_search_sad_c(

        x, &pcs->ss_cfg, mvp_full, &temp_mv, step_param, sadpb, &n, fn_ptr, ref_mv);

    if (bestsme < INT_MAX) {

        bestsme = svt_av1_get_mvpred_var(x, temp_mv, ref_mv, fn_ptr, 1);

    }

    x->best_mv = temp_mv;

    // If there won't be more n-step search, check to see if refining search is

    // needed.

    if (n > further_steps) {

        do_refine = 0;

    }

    while (n < further_steps) {

        ++n;

        if (num00) {

            num00--;

        } else {

            /*thissme = cpi->diamond_search_sad(x, &cpi->ss_cfg, mvp_full, &temp_mv,

                                        step_param + n, sadpb, &num00, fn_ptr,

                                        ref_mv);*/

            thissme = svt_av1_diamond_search_sad_c(

                x, &pcs->ss_cfg, mvp_full, &temp_mv, step_param + n, sadpb, &num00, fn_ptr, ref_mv);

            if (thissme < INT_MAX) {

                thissme = svt_av1_get_mvpred_var(x, temp_mv, ref_mv, fn_ptr, 1);

            }

            // check to see if refining search is needed.

            if (num00 > further_steps - n) {

                do_refine = 0;

            }

            if (thissme < bestsme) {

                bestsme    = thissme;

                x->best_mv = temp_mv;

            }

        }

    }

    // final 1-away diamond refining search

    if (do_refine) {

        const int search_range = 8;

        Mv        best_mv      = x->best_mv;

        thissme                = svt_av1_refining_search_sad(x, &best_mv, sadpb, search_range, fn_ptr, ref_mv);

        if (thissme < INT_MAX) {

            thissme = svt_av1_get_mvpred_var(x, best_mv, ref_mv, fn_ptr, 1);

        }

        if (thissme < bestsme) {

            bestsme    = thissme;

            x->best_mv = best_mv;

        }

    }

    // Return cost list.

    /* if (cost_list) {

    calc_int_cost_list(x, ref_mv, sadpb, fn_ptr, &x->best_mv.as_mv, cost_list);

  }*/

    return bestsme;

}

#define MIN_RANGE 7

#define MAX_RANGE 256

#define MIN_INTERVAL 1

// Runs an limited range exhaustive mesh search using a pattern set

// according to the encode speed profile.

static int intrabc_full_pixel_exhaustive(PictureControlSet* pcs, IntraBcContext* x, const Mv center_mv, int sadpb,

                                         const AomVarianceFnPtr* fn_ptr, const Mv ref_mv, Mv* dst_mv) {

    const IntrabcCtrls* ctrls = &pcs->ppcs->intrabc_ctrls;

    Mv search_mv = center_mv;

    Mv ref_mv_fp = {{ref_mv.x >> 3, ref_mv.y >> 3}};

    int range     = ctrls->mesh_patterns[0].range;

    int interval  = ctrls->mesh_patterns[0].interval;

    int best_cost = INT_MAX;

    // Validate parameters

    if (range < MIN_RANGE || range > MAX_RANGE || interval < MIN_INTERVAL || interval > range) {

        return INT_MAX;

    }

    const int base_interval_div = range / interval;

    // Adapt search range based on center MV magnitude

    int mv_mag = AOMMAX(abs(search_mv.x), abs(search_mv.y));

    range      = AOMMAX(range, (5 * mv_mag) / 4);

    range      = AOMMIN(range, MAX_RANGE);

    interval   = AOMMAX(interval, range / base_interval_div);

    // Initial coarse search

    best_cost = exhaustive_mesh_search(x, &ref_mv_fp, &search_mv, range, interval, sadpb, fn_ptr, search_mv);

    // Progressive refinement

    if (interval > MIN_INTERVAL && range > MIN_RANGE) {

        for (int i = 1; i < MAX_MESH_STEP; i++) {

            const MeshPattern* pattern = &ctrls->mesh_patterns[i];

            if (pattern->range == 0) {

                break;

            }

            best_cost = exhaustive_mesh_search(

                x, &ref_mv_fp, &search_mv, pattern->range, pattern->interval, sadpb, fn_ptr, search_mv);

            if (pattern->interval == 1) {

                break;

            }

        }

    }

    // Final cost evaluation

    if (best_cost < INT_MAX) {

        best_cost = svt_av1_get_mvpred_var(x, search_mv, ref_mv, fn_ptr, 1);

    }

    *dst_mv = search_mv;

    return best_cost;

}

#if CONFIG_ENABLE_OBMC

static int get_obmc_mvpred_var(const IntraBcContext* x, const int32_t* wsrc, const int32_t* mask, const Mv best_mv,

                               const Mv center_mv, const AomVarianceFnPtr* vfp, int use_mvcost, int is_second) {

    const Buf2D* in_what = (const Buf2D*)(&x->xdplane[0].pre[is_second]);

    const Mv     mv      = {{best_mv.x * 8, best_mv.y * 8}};

    unsigned int unused;

    if (x->approx_inter_rate) {

        return vfp->ovf(get_buf_from_mv((const Buf2D*)in_what, best_mv), in_what->stride, wsrc, mask, &unused) +

            (use_mvcost ? svt_aom_mv_err_cost_light(mv, center_mv) : 0);

    } else {

        return vfp->ovf(get_buf_from_mv((const Buf2D*)in_what, best_mv), in_what->stride, wsrc, mask, &unused) +

            (use_mvcost ? svt_aom_mv_err_cost(mv, center_mv, x->nmv_vec_cost, x->mv_cost_stack, x->errorperbit) : 0);

    }

}

static int obmc_refining_search_sad(const IntraBcContext* x, const int32_t* wsrc, const int32_t* mask, Mv* ref_mv,

                                    int error_per_bit, int search_range, const AomVarianceFnPtr* fn_ptr,

                                    const Mv center_mv, int is_second, uint8_t search_diag) {

    const Mv     neighbors[8] = {{{0, -1}}, {{-1, 0}}, {{1, 0}}, {{0, 1}}, {{1, -1}}, {{1, 1}}, {{-1, 1}}, {{-1, -1}}};

    const Buf2D* in_what      = (const Buf2D*)(&x->xdplane[0].pre[is_second]);

    const Mv     fcenter_mv   = {{center_mv.x >> 3, center_mv.y >> 3}};

    unsigned int best_sad = fn_ptr->osdf(get_buf_from_mv((const Buf2D*)in_what, *ref_mv), in_what->stride, wsrc, mask) +

        mvsad_err_cost(x, *ref_mv, fcenter_mv, error_per_bit);

    int i, j;

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

        int best_site = -1;

        for (j = 0; j < (search_diag ? 8 : 4); j++) {

            const Mv mv = {{ref_mv->x + neighbors[j].x, ref_mv->y + neighbors[j].y}};

            if (is_mv_in(&x->mv_limits, mv)) {

                unsigned int sad = fn_ptr->osdf(

                    get_buf_from_mv((const Buf2D*)in_what, mv), in_what->stride, wsrc, mask);

                if (sad < best_sad) {

                    sad += mvsad_err_cost(x, mv, fcenter_mv, error_per_bit);

                    if (sad < best_sad) {

                        best_sad  = sad;

                        best_site = j;

                    }

                }

            }

        }

        if (best_site == -1) {

            break;

        } else {

            ref_mv->y += neighbors[best_site].y;

            ref_mv->x += neighbors[best_site].x;

        }

    }

    return best_sad;

}

int svt_av1_obmc_full_pixel_search(ModeDecisionContext* ctx, IntraBcContext* x, const Mv mvp_full, int sadpb,

                                   const AomVarianceFnPtr* fn_ptr, const Mv ref_mv, Mv* dst_mv, int is_second) {

    // obmc_full_pixel_diamond does not provide BDR gain on 360p

    const int32_t* wsrc         = ctx->wsrc_buf;

    const int32_t* mask         = ctx->mask_buf;

    const int      search_range = ctx->obmc_ctrls.fpel_search_range;

    *dst_mv                     = mvp_full;

    x->approx_inter_rate        = ctx->approx_inter_rate;

    clamp_mv(dst_mv, x->mv_limits.col_min, x->mv_limits.col_max, x->mv_limits.row_min, x->mv_limits.row_max);

    clamp_mv(dst_mv, x->mv_limits.col_min, x->mv_limits.col_max, x->mv_limits.row_min, x->mv_limits.row_max);

    int thissme = obmc_refining_search_sad(

        x, wsrc, mask, dst_mv, sadpb, search_range, fn_ptr, ref_mv, is_second, ctx->obmc_ctrls.fpel_search_diag);

    if (thissme < INT_MAX) {

        thissme = get_obmc_mvpred_var(x, wsrc, mask, *dst_mv, ref_mv, fn_ptr, 1, is_second);

    }

    return thissme;

}

#endif

#if CONFIG_ENABLE_OBMC

static INLINE void set_subpel_mv_search_range(const MvLimits* mv_limits, int* col_min, int* col_max, int* row_min,

                                              int* row_max, const Mv ref_mv) {

    const int max_mv = MAX_FULL_PEL_VAL * 8;

    const int minc   = AOMMAX(mv_limits->col_min * 8, ref_mv.x - max_mv);

    const int maxc   = AOMMIN(mv_limits->col_max * 8, ref_mv.x + max_mv);

    const int minr   = AOMMAX(mv_limits->row_min * 8, ref_mv.y - max_mv);

    const int maxr   = AOMMIN(mv_limits->row_max * 8, ref_mv.y + max_mv);

    *col_min = AOMMAX(MV_LOW + 1, minc);

    *col_max = AOMMIN(MV_UPP - 1, maxc);

    *row_min = AOMMAX(MV_LOW + 1, minr);

    *row_max = AOMMIN(MV_UPP - 1, maxr);

}

static const Mv search_step_table[12] = {

    // left, right, up, down

    {{-4, 0}},

    {{4, 0}},

    {{0, -4}},

    {{0, 4}},

    {{-2, 0}},

    {{2, 0}},

    {{0, -2}},

    {{0, 2}},

    {{-1, 0}},

    {{1, 0}},

    {{0, -1}},

    {{0, 1}}};

static unsigned int setup_obmc_center_error(const int32_t* mask, const Mv bestmv, const Mv ref_mv, int error_per_bit,

                                            const AomVarianceFnPtr* vfp, const int32_t* const wsrc,

                                            const uint8_t* const y, int y_stride, int offset, int* mvjcost,

                                            const int* mvcost[2], unsigned int* sse1,

                                            uint8_t use_low_precision_cost_estimation, int* distortion) {

    unsigned int besterr;

    besterr     = vfp->ovf(y + offset, y_stride, wsrc, mask, sse1);

    *distortion = besterr;

    if (use_low_precision_cost_estimation) {

        besterr += svt_aom_mv_err_cost_light(bestmv, ref_mv);

    } else {

        besterr += svt_aom_mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);

    }

    return besterr;

}

/* returns subpixel variance error function */

#define DIST(r, c) vfp->osvf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r), z, mask, &sse)

#define CHECK_BETTER(v, r, c, lp)                                                                    \

    do {                                                                                             \

        if (c >= minc && c <= maxc && r >= minr && r <= maxr) {                                      \

            thismse = (DIST(r, c));                                                                  \

                                                                                                     \

            if (lp)                                                                                  \

                v = svt_aom_mv_err_cost_light((const Mv){{c, r}}, ref_mv);                           \

            else                                                                                     \

                v = svt_aom_mv_err_cost((const Mv){{c, r}}, ref_mv, mvjcost, mvcost, error_per_bit); \

            if ((v + thismse) < besterr) {                                                           \

                besterr     = v + thismse;                                                           \

                br          = r;                                                                     \

                bc          = c;                                                                     \

                *distortion = thismse;                                                               \

                *sse1       = sse;                                                                   \