/*

* 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.

*/

/***************************************

* Includes

***************************************/

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#include "common_utils.h"

#include "enc_dec_process.h"

#include "definitions.h"

#include "sequence_control_set.h"

#include "mode_decision.h"

#include "md_process.h"

#include "motion_estimation.h"

#include "av1me.h"

#include "hash.h"

#include "enc_inter_prediction.h"

#include "rd_cost.h"

#include "aom_dsp_rtcd.h"

#include "svt_log.h"

#include "resize.h"

#include "mcomp.h"

#include "ac_bias.h"

#include "src_ops_process.h"

#include "utility.h"

#include "adaptive_mv_pred.h"

#include "av1me.h"

static const uint32_t intra_luma_to_chroma[INTRA_MODES] = {

    UV_DC_PRED, // Average of above and left pixels

    UV_V_PRED, // Vertical

    UV_H_PRED, // Horizontal

    UV_D45_PRED, // Directional 45  degree

    UV_D135_PRED, // Directional 135 degree

    UV_D113_PRED, // Directional 113 degree

    UV_D157_PRED, // Directional 157 degree

    UV_D203_PRED, // Directional 203 degree

    UV_D67_PRED, // Directional 67  degree

    UV_SMOOTH_PRED, // Combination of horizontal and vertical interpolation

    UV_SMOOTH_V_PRED, // Vertical interpolation

    UV_SMOOTH_H_PRED, // Horizontal interpolation

    UV_PAETH_PRED, // Predict from the direction of smallest gradient

};

void calc_target_weighted_pred(PictureControlSet* pcs, ModeDecisionContext* ctx, const Av1Common* cm,

                               const MacroBlockD* xd, int mi_row, int mi_col, const uint8_t* above, int above_stride,

                               const uint8_t* left, int left_stride);

#define INC_MD_CAND_CNT(cnt, max_can_count)                  \

    MULTI_LINE_MACRO_BEGIN                                   \

    if (cnt + 1 < max_can_count)                             \

        cnt++;                                               \

    else                                                     \

        SVT_ERROR("Mode decision candidate count exceeded"); \

    MULTI_LINE_MACRO_END

#define SUPERRES_INVALID_STATE 0x7fffffff

bool svt_av1_is_lossless_segment(PictureControlSet* pcs, int8_t segment_id) {

    FrameHeader* frm_hdr = &pcs->ppcs->frm_hdr;

    if (frm_hdr->segmentation_params.segmentation_enabled) {

        return pcs->lossless[segment_id];

    } else {

        return pcs->lossless[0];

    }

}

static bool check_mv_validity(int16_t x_mv, int16_t y_mv, uint8_t need_shift) {

    Mv mv;

    //go to 1/8th if input is 1/4pel

    mv.y = y_mv << need_shift;

    mv.x = x_mv << need_shift;

    /* AV1 limits

      -16384 < MV_x_in_1/8 or MV_y_in_1/8 < 16384

      which means in full pel:

      -2048 < MV_x_in_full_pel or MV_y_in_full_pel < 2048

    */

    if (!is_mv_valid(&mv)) {

        return false;

    }

    return true;

}

int svt_is_interintra_allowed(uint8_t enable_inter_intra, BlockSize bsize, PredictionMode mode,

                              const MvReferenceFrame ref_frame[2]) {

    return enable_inter_intra && svt_aom_is_interintra_allowed_bsize((const BlockSize)bsize) &&

        svt_aom_is_interintra_allowed_mode(mode) && svt_aom_is_interintra_allowed_ref(ref_frame);

}

int svt_aom_filter_intra_allowed_bsize(BlockSize bs) {

    return block_size_wide[bs] <= 32 && block_size_high[bs] <= 32;

}

int svt_aom_filter_intra_allowed(uint8_t enable_filter_intra, BlockSize bsize, uint8_t palette_size, uint32_t mode) {

    return enable_filter_intra && mode == DC_PRED && palette_size == 0 && svt_aom_filter_intra_allowed_bsize(bsize);

}

// returns the max inter-inter compound type based on settings and block size

static MD_COMP_TYPE get_tot_comp_types_bsize(MD_COMP_TYPE tot_comp_types, BlockSize bsize) {

    return (svt_aom_get_wedge_params_bits(bsize) == 0) ? MIN(tot_comp_types, MD_COMP_WEDGE) : tot_comp_types;

}

/*

Get the ME offset for a given block (the offset used to locate the PA MVs from the parent PCS).

*/

uint32_t svt_aom_get_me_block_offset(const uint32_t org_x, const uint32_t org_y, const BlockSize bsize,

                                     const uint8_t enable_me_8x8, const uint8_t enable_me_16x16) {

    const int      bwidth     = block_size_wide[bsize];

    const int      bheight    = block_size_high[bsize];

    const uint32_t max_length = MAX(bwidth, bheight);

    uint32_t me_idx = 0;

    switch (max_length) {

    case 4:

    case 8:

        me_idx++;

        if (org_x & 8) { // (org_x % 16) / 8

            me_idx += 1;

        }

        if (org_y & 8) { // (org_y % 16) / 8

            me_idx += 2;

        }

        AOM_FALLTHROUGH_INTENDED;

    case 16:

        me_idx++;

        if (org_x & 16) { // (org_x % 32) / 16

            me_idx += 5;

        }

        if (org_y & 16) { // (org_y % 32) / 16

            me_idx += 10;

        }

        AOM_FALLTHROUGH_INTENDED;

    case 32:

        me_idx++;

        if (org_x & 32) { // (org_x % 64) / 32

            me_idx += 21;

        }

        if (org_y & 32) { // (org_y % 64) / 32

            me_idx += 42;

        }

        break;

    default:

        // me_idx = 0;

        break;

    }

    uint32_t me_block_offset = me_idx_85[me_idx]; // convert idx to me_idx

    if (!enable_me_8x8) {

        if (me_block_offset >= MAX_SB64_PU_COUNT_NO_8X8) {

            me_block_offset = me_idx_85_8x8_to_16x16_conversion[me_block_offset - MAX_SB64_PU_COUNT_NO_8X8];

        }

        assert(me_block_offset < 21);

        if (!enable_me_16x16) {

            if (me_block_offset >= MAX_SB64_PU_COUNT_WO_16X16) {

                assert(me_block_offset < 21);

                me_block_offset = me_idx_16x16_to_parent_32x32_conversion[me_block_offset - MAX_SB64_PU_COUNT_WO_16X16];

            }

        }

    }

    return me_block_offset;

}

//Given one reference frame identified by the pair (list_index,ref_index)

//indicate if ME data is valid

uint8_t svt_aom_is_me_data_present(uint32_t me_block_offset, uint32_t me_cand_offset, const MeSbResults* me_results,

                                   uint8_t list_idx, uint8_t ref_idx) {

    uint8_t            total_me_cnt     = me_results->total_me_candidate_index[me_block_offset];

    const MeCandidate* me_block_results = &me_results->me_candidate_array[me_cand_offset];

    for (uint32_t me_cand_i = 0; me_cand_i < total_me_cnt; ++me_cand_i) {

        const MeCandidate* me_cand = &me_block_results[me_cand_i];

        assert(me_cand->direction <= 2);

        if (me_cand->direction == 0 || me_cand->direction == 2) {

            if (list_idx == me_cand->ref0_list && ref_idx == me_cand->ref_idx_l0) {

                return 1;

            }

        }

        if (me_cand->direction == 1 || me_cand->direction == 2) {

            if (list_idx == me_cand->ref1_list && ref_idx == me_cand->ref_idx_l1) {

                return 1;

            }

        }

    }

    return 0;

}

/********************************************

* Constants

********************************************/

// 1 - Regular uni-pred ,

// 2 - Regular uni-pred + Wedge compound Inter Intra

// 3 - Regular uni-pred + Wedge compound Inter Intra + Smooth compound Inter Intra

#if CONFIG_ENABLE_OBMC

static bool warped_motion_mode_allowed(PictureControlSet* pcs, ModeDecisionContext* ctx) {

    FrameHeader* frm_hdr = &pcs->ppcs->frm_hdr;

    return frm_hdr->allow_warped_motion && has_overlappable_candidates(ctx->blk_ptr) && ctx->blk_geom->bwidth >= 8 &&

        ctx->blk_geom->bheight >= 8 && ctx->wm_ctrls.enabled;

}

#endif

MotionMode svt_aom_obmc_motion_mode_allowed(

    const PictureControlSet* pcs, ModeDecisionContext* ctx, const BlockSize bsize,

    uint8_t          situation, // 0: candidate(s) preparation, 1: data preparation, 2: simple translation face-off

    MvReferenceFrame rf0, MvReferenceFrame rf1, PredictionMode mode) {

    if (ctx->obmc_ctrls.trans_face_off && !situation) {

        return SIMPLE_TRANSLATION;

    }

    // check if should cap the max block size for obmc

    if (block_size_wide[bsize] > ctx->obmc_ctrls.max_blk_size ||

        block_size_high[bsize] > ctx->obmc_ctrls.max_blk_size) {

        return SIMPLE_TRANSLATION;

    }

    if (!ctx->obmc_ctrls.enabled) {

        return SIMPLE_TRANSLATION;

    }

    FrameHeader* frm_hdr = &pcs->ppcs->frm_hdr;

    if (!frm_hdr->is_motion_mode_switchable) {

        return SIMPLE_TRANSLATION;

    }

    if (frm_hdr->force_integer_mv == 0) {

        const TransformationType gm_type = pcs->ppcs->global_motion[rf0].wmtype;

        if (is_global_mv_block(mode, bsize, gm_type)) {

            return SIMPLE_TRANSLATION;

        }

    }

    if (is_motion_variation_allowed_bsize(bsize) && is_inter_singleref_mode(mode) && rf1 != INTRA_FRAME &&

        !(rf1 > INTRA_FRAME)) // is_motion_variation_allowed_compound

    {

        if (!has_overlappable_candidates(ctx->blk_ptr)) { // check_num_overlappable_neighbors

            return SIMPLE_TRANSLATION;

        }

        return OBMC_CAUSAL;

    } else {

        return SIMPLE_TRANSLATION;

    }

}

//static uint32_t  AntiContouringIntraMode[11] = { EB_INTRA_PLANAR, EB_INTRA_DC, EB_INTRA_HORIZONTAL, EB_INTRA_VERTICAL,

//EB_INTRA_MODE_2, EB_INTRA_MODE_6, EB_INTRA_MODE_14, EB_INTRA_MODE_18, EB_INTRA_MODE_22, EB_INTRA_MODE_30, EB_INTRA_MODE_34 };

int32_t svt_aom_have_newmv_in_inter_mode(PredictionMode mode) {

    return (mode == NEWMV || mode == NEW_NEWMV || mode == NEAREST_NEWMV || mode == NEW_NEARESTMV ||

            mode == NEAR_NEWMV || mode == NEW_NEARMV);

}

static MvReferenceFrame to_ref_frame[2][4] = {{LAST_FRAME, LAST2_FRAME, LAST3_FRAME, GOLDEN_FRAME},

                                              {BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME, INVALID_REF}};

MvReferenceFrame svt_get_ref_frame_type(uint8_t list, uint8_t ref_idx) {

    return to_ref_frame[list][ref_idx];

};

uint8_t svt_aom_get_max_drl_index(uint8_t refmvCnt, PredictionMode mode) {

    uint8_t max_drl = 0;

    if (mode == NEWMV || mode == NEW_NEWMV) {

        if (refmvCnt < 2) {

            max_drl = 1;

        } else if (refmvCnt == 2) {

            max_drl = 2;

        } else {

            max_drl = 3;

        }

    }

    if (mode == NEARMV || mode == NEAR_NEARMV || mode == NEAR_NEWMV || mode == NEW_NEARMV) {

        if (refmvCnt < 3) {

            max_drl = 1;

        } else if (refmvCnt == 3) {

            max_drl = 2;

        } else {

            max_drl = 3;

        }

    }

    return max_drl;

}

#define MV_COST_WEIGHT 108

static int64_t pick_interintra_wedge(PictureControlSet* pcs, ModeDecisionContext* ctx, const BlockSize bsize,

                                     const uint8_t* const p0, const uint8_t* const p1, uint8_t* src_buf,

                                     uint32_t src_stride, int8_t* wedge_index_out) {

    assert(svt_aom_is_interintra_wedge_used(bsize));

    // assert(cpi->common.seq_params.enable_interintra_compound);

    const int bw = block_size_wide[bsize];

    const int bh = block_size_high[bsize];

    DECLARE_ALIGNED(32, int16_t, residual1[MAX_INTERINTRA_SB_SQUARE]); // src - pred1

    DECLARE_ALIGNED(32, int16_t, diff10[MAX_INTERINTRA_SB_SQUARE]); // pred1 - pred0

#if CONFIG_ENABLE_HIGH_BIT_DEPTH

    if (ctx->hbd_md) {

        svt_aom_highbd_subtract_block(bh, bw, residual1, bw, src_buf, src_stride, p1, bw, EB_TEN_BIT);

        svt_aom_highbd_subtract_block(bh, bw, diff10, bw, p1, bw, p0, bw, EB_TEN_BIT);

    } else

#endif

    {

        svt_aom_subtract_block(bh, bw, residual1, bw, src_buf, src_stride, p1, bw);

        svt_aom_subtract_block(bh, bw, diff10, bw, p1, bw, p0, bw);

    }

    int8_t  wedge_index = -1;

    int64_t rd          = pick_wedge_fixed_sign(pcs, ctx, bsize, residual1, diff10, 0, &wedge_index);

    *wedge_index_out    = wedge_index;

    return rd;

}

static void inter_intra_search(PictureControlSet* pcs, ModeDecisionContext* ctx, ModeDecisionCandidate* cand) {

    SequenceControlSet* scs = pcs->scs;

    DECLARE_ALIGNED(16, uint8_t, tmp_buf[2 * MAX_INTERINTRA_SB_SQUARE]);

    DECLARE_ALIGNED(16, uint8_t, ii_pred_buf[2 * MAX_INTERINTRA_SB_SQUARE]);

    // get inter pred for ref0

    EbPictureBufferDesc* src_pic = ctx->hbd_md ? pcs->input_frame16bit : pcs->ppcs->enhanced_pic;

    uint16_t* src_buf_hbd = (uint16_t*)src_pic->y_buffer + (ctx->blk_org_x) + (ctx->blk_org_y) * src_pic->y_stride;

    uint8_t*  src_buf     = src_pic->y_buffer + (ctx->blk_org_x) + (ctx->blk_org_y) * src_pic->y_stride;

    uint8_t  bit_depth   = ctx->hbd_md ? EB_TEN_BIT : EB_EIGHT_BIT;

    uint32_t full_lambda = ctx->hbd_md ? ctx->full_lambda_md[EB_10_BIT_MD] : ctx->full_lambda_md[EB_8_BIT_MD];

    uint32_t            bwidth  = ctx->blk_geom->bwidth;

    uint32_t            bheight = ctx->blk_geom->bheight;

    EbPictureBufferDesc pred_desc;

    pred_desc.border   = 0;

    pred_desc.y_stride = bwidth;

    EbPictureBufferDesc* ref_pic_list0 = svt_aom_get_ref_pic_buffer(pcs, cand->block_mi.ref_frame[0]);

    EbPictureBufferDesc* ref_pic_list1 = NULL;

    // Use scaled references if resolution of the reference is different from that of the input

    // Only have one ref

    if (ref_pic_list0 != NULL) {

        uint8_t list_idx0  = get_list_idx(cand->block_mi.ref_frame[0]);

        int8_t  ref_idx_l0 = get_ref_frame_idx(cand->block_mi.ref_frame[0]);

        svt_aom_use_scaled_rec_refs_if_needed(

            pcs,

            pcs->ppcs->enhanced_pic,

            (EbReferenceObject*)pcs->ref_pic_ptr_array[list_idx0][ref_idx_l0]->object_ptr,

            &ref_pic_list0,

            ctx->hbd_md);

    }

    pred_desc.y_buffer = tmp_buf;

    //we call the regular inter prediction path here (no compound)

    cand->block_mi.interp_filters     = 0;

    cand->block_mi.is_interintra_used = 0;

    svt_aom_inter_prediction(scs,

                             pcs,

                             &cand->block_mi,

                             &cand->wm_params_l0,

                             &cand->wm_params_l1,

                             ctx->blk_ptr,

                             ctx->blk_geom->bsize,

                             ctx->shape,

                             false, // use_precomputed_obmc

                             false, // use_precomputed_ii - ii not performed here

                             ctx,

                             NULL,

                             NULL,

                             NULL,

                             ref_pic_list0,

                             ref_pic_list1,

                             ctx->blk_org_x,

                             ctx->blk_org_y,

                             &pred_desc, //output

                             0, //output org_x,

                             0, //output org_y,

                             PICTURE_BUFFER_DESC_LUMA_MASK,

                             ctx->hbd_md ? EB_TEN_BIT : EB_EIGHT_BIT,

                             0); // is_16bit_pipeline

    assert(svt_aom_is_interintra_wedge_used(ctx->blk_geom->bsize)); //if not I need to add nowedge path!!

    int64_t        best_interintra_rd   = INT64_MAX;

    InterIntraMode best_interintra_mode = INTERINTRA_MODES;

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

        // if ((!cpi->oxcf.enable_smooth_intra || cpi->sf.disable_smooth_intra) &&

        //     (InterIntraMode)j == II_SMOOTH_PRED)

        //   continue;

        InterIntraMode interintra_mode = (InterIntraMode)j;

        // rmode = interintra_mode_cost[mbmi->interintra_mode];

        const int bsize_group = eb_size_group_lookup[ctx->blk_geom->bsize];

        const int rmode       = ctx->md_rate_est_ctx->inter_intra_mode_fac_bits[bsize_group][interintra_mode];

        // av1_combine_interintra(xd, bsize, 0, tmp_buf, bw, intrapred, bw);

        if (ctx->hbd_md) {

            svt_aom_combine_interintra_highbd(interintra_mode, // mode,

                                              0, // use_wedge_interintra,

                                              0, // cand->interintra_wedge_index,

                                              0, // int wedge_sign,

                                              ctx->blk_geom->bsize,

                                              ctx->blk_geom->bsize, // plane_bsize,

                                              ii_pred_buf,

                                              bwidth, /*uint8_t *comppred, int compstride,*/

                                              tmp_buf,

                                              bwidth, /*const uint8_t *interpred, int interstride,*/

                                              ctx->intrapred_buf[j],

                                              bwidth /*const uint8_t *intrapred,   int intrastride*/,

                                              bit_depth);

        } else {

            svt_aom_combine_interintra(interintra_mode, //mode,

                                       0, //use_wedge_interintra,

                                       0, //cand->interintra_wedge_index,

                                       0, //int wedge_sign,

                                       ctx->blk_geom->bsize,

                                       ctx->blk_geom->bsize, // plane_bsize,

                                       ii_pred_buf,

                                       bwidth, /*uint8_t *comppred, int compstride,*/

                                       tmp_buf,

                                       bwidth, /*const uint8_t *interpred, int interstride,*/

                                       ctx->intrapred_buf[j],

                                       bwidth /*const uint8_t *intrapred,   int intrastride*/);

        }

        int64_t rd;

        if (ctx->inter_intra_comp_ctrls.use_rd_model) {

            int     rate_sum;

            int64_t dist_sum;

            model_rd_for_sb_with_curvfit(pcs,

                                         ctx,

                                         ctx->blk_geom->bsize,

                                         bwidth,

                                         bheight,

                                         ctx->hbd_md ? (uint8_t*)src_buf_hbd : src_buf,

                                         src_pic->y_stride,

                                         ii_pred_buf,

                                         bwidth,

                                         0,

                                         0,

                                         0,

                                         0,

                                         &rate_sum,

                                         &dist_sum,

                                         NULL,

                                         NULL,

                                         NULL);

            rd = RDCOST(full_lambda, rate_sum + rmode, dist_sum);

        } else {

#if CONFIG_ENABLE_HIGH_BIT_DEPTH

            if (ctx->hbd_md) {

                rd = svt_aom_highbd_sse((uint8_t*)src_buf_hbd, src_pic->y_stride, ii_pred_buf, bwidth, bwidth, bheight);

            } else

#endif

            {

                rd = svt_aom_sse(src_buf, src_pic->y_stride, ii_pred_buf, bwidth, bwidth, bheight);

            }

        }

        if (rd < best_interintra_rd) {

            best_interintra_rd             = rd;

            cand->block_mi.interintra_mode = best_interintra_mode = interintra_mode;

        }

    }

    // To test: Enable wedge search if source variance and edge strength are above the thresholds.

    //CHKN need to re-do intra pred using the winner, or have a separate intra serch for wedge

    int64_t       best_interintra_rd_wedge = INT64_MAX;

    const uint8_t ii_wedge_mode            = ctx->shape == PART_N ? ctx->inter_intra_comp_ctrls.wedge_mode_sq

                                                                  : ctx->inter_intra_comp_ctrls.wedge_mode_nsq;

    if (ii_wedge_mode) {

        best_interintra_rd_wedge = pick_interintra_wedge(pcs,

                                                         ctx,

                                                         ctx->blk_geom->bsize,

                                                         ctx->intrapred_buf[best_interintra_mode],

                                                         tmp_buf,

                                                         ctx->hbd_md ? (uint8_t*)src_buf_hbd : src_buf,

                                                         src_pic->y_stride,

                                                         &cand->block_mi.interintra_wedge_index);

    }

    // for ii_wedge_mode 1, always inject wedge as a separate candidate; for wedge mode 2 only inject

    // if wedge is better than non-wedge

    if (ii_wedge_mode == 1 || best_interintra_rd_wedge < best_interintra_rd) {

        cand->block_mi.use_wedge_interintra = 1;

    } else {

        cand->block_mi.use_wedge_interintra = 0;

    }

}

static COMPOUND_TYPE to_av1_compound_lut[] = {COMPOUND_AVERAGE, COMPOUND_DISTWTD, COMPOUND_DIFFWTD, COMPOUND_WEDGE};

static void determine_compound_mode(PictureControlSet* pcs, ModeDecisionContext* ctx, ModeDecisionCandidate* cand,

                                    MD_COMP_TYPE cur_type) {

    BlockModeInfo* block_mi        = &cand->block_mi;

    block_mi->interinter_comp.type = to_av1_compound_lut[cur_type];

    switch (cur_type) {

    case MD_COMP_AVG:

        block_mi->comp_group_idx = 0;

        block_mi->compound_idx   = 1;

        break;

    case MD_COMP_DIST:

        block_mi->comp_group_idx = 0;

        block_mi->compound_idx   = 0;

        break;

    case MD_COMP_DIFF0:

        block_mi->comp_group_idx            = 1;

        block_mi->compound_idx              = 1;

        block_mi->interinter_comp.mask_type = 55;

        svt_aom_search_compound_diff_wedge(pcs, ctx, cand);

        break;

    case MD_COMP_WEDGE:

        block_mi->comp_group_idx = 1;

        block_mi->compound_idx   = 1;

        svt_aom_search_compound_diff_wedge(pcs, ctx, cand);

        break;

    default:

        SVT_ERROR("not used comp type\n");

        assert(0);

        break;

    }

}

void svt_aom_choose_best_av1_mv_pred(ModeDecisionContext* ctx, MvReferenceFrame ref_frame,

                                     PredictionMode mode, // NEW or NEW_NEW

                                     Mv mv0, Mv mv1,

                                     uint8_t* bestDrlIndex, // output

                                     Mv       best_pred_mv[2] // output

) {

    if (ctx->shut_fast_rate) {

        return;

    }

    if (ctx->approx_inter_rate > 1) {

        *bestDrlIndex   = 0;

        best_pred_mv[0] = ctx->ref_mv_stack[ref_frame][0].this_mv;

        best_pred_mv[1] = ctx->ref_mv_stack[ref_frame][0].comp_mv;

        return;

    }

    int16_t mv0x = mv0.x;

    int16_t mv0y = mv0.y;

    int16_t mv1x = mv1.x;

    int16_t mv1y = mv1.y;

    uint8_t is_compound = is_inter_compound_mode(mode);

    struct MdRateEstimationContext* md_rate_est_ctx = ctx->md_rate_est_ctx;

    BlkStruct*                      blk_ptr         = ctx->blk_ptr;

    uint8_t                         max_drl_index;

    Mv                              nearestmv[2] = {{{0}}, {{0}}};

    Mv                              nearmv[2];

    Mv                              ref_mv[2];

    Mv                              mv;

    max_drl_index = svt_aom_get_max_drl_index(blk_ptr->av1xd->ref_mv_count[ref_frame], mode);

    // max_drl_index = 1;

    if (max_drl_index == 1) {

        *bestDrlIndex = 0;

        best_pred_mv[0] = ctx->ref_mv_stack[ref_frame][0].this_mv;

        best_pred_mv[1] = ctx->ref_mv_stack[ref_frame][0].comp_mv;

    } else {

        uint8_t  drli;

        uint32_t best_mv_cost = 0xFFFFFFFF;

        for (drli = 0; drli < max_drl_index; drli++) {

            svt_aom_get_av1_mv_pred_drl(ctx, blk_ptr, ref_frame, is_compound, mode, drli, nearestmv, nearmv, ref_mv);

            //compute the rate for this drli Cand

            mv.y             = mv0y;

            mv.x             = mv0x;

            uint32_t mv_rate = 0;

            if (ctx->approx_inter_rate) {

                mv_rate = (uint32_t)svt_av1_mv_bit_cost_light(&mv, &(ref_mv[0]));

            } else {

                mv_rate = (uint32_t)svt_av1_mv_bit_cost(

                    &mv, &(ref_mv[0]), md_rate_est_ctx->nmv_vec_cost, md_rate_est_ctx->nmvcoststack, MV_COST_WEIGHT);

            }

            if (is_compound) {

                mv.y = mv1y;

                mv.x = mv1x;

                if (ctx->approx_inter_rate) {

                    mv_rate += (uint32_t)svt_av1_mv_bit_cost_light(&mv, &(ref_mv[1]));

                } else {

                    mv_rate += (uint32_t)svt_av1_mv_bit_cost(&mv,

                                                             &(ref_mv[1]),

                                                             md_rate_est_ctx->nmv_vec_cost,

                                                             md_rate_est_ctx->nmvcoststack,

                                                             MV_COST_WEIGHT);

                }

            }

            const int32_t new_mv = (mode == NEWMV || mode == NEW_NEWMV);

            if (new_mv) {

                int32_t idx;

                for (idx = 0; idx < 2; ++idx) {

                    if (blk_ptr->av1xd->ref_mv_count[ref_frame] > idx + 1) {

                        uint8_t drl_1_ctx = av1_drl_ctx(&(ctx->ref_mv_stack[ref_frame][0]), idx);

                        mv_rate += ctx->md_rate_est_ctx->drl_mode_fac_bits[drl_1_ctx][drli != idx];

                        if (drli == idx) {

                            break;

                        }

                    }

                }

            }

            if (mv_rate < best_mv_cost) {

                best_mv_cost    = mv_rate;

                *bestDrlIndex   = drli;

                best_pred_mv[0] = ref_mv[0];

                best_pred_mv[1] = ref_mv[1];

            }

        }

    }

}

static void mode_decision_cand_bf_dctor(EbPtr p) {

    // pred/rec_coeff/quant are borrowed from the MD-context pools; residual/recon are

    // shared (temp_*). Nothing is owned by the candidate buffer itself.

    (void)p;

}

static void mode_decision_scratch_cand_bf_dctor(EbPtr p) {

    ModeDecisionCandidateBuffer* obj = (ModeDecisionCandidateBuffer*)p;

    EB_DELETE(obj->pred);

    EB_DELETE(obj->residual);

    EB_DELETE(obj->rec_coeff);

    EB_DELETE(obj->recon);

    EB_DELETE(obj->quant);

}

/***************************************

* Mode Decision Candidate Ctor

***************************************/

EbErrorType svt_aom_mode_decision_cand_bf_ctor(ModeDecisionCandidateBuffer* buffer_ptr, EbPictureBufferDesc* pred,

                                               EbPictureBufferDesc* rec_coeff, EbPictureBufferDesc* quant,

                                               EbPictureBufferDesc* temp_residual, EbPictureBufferDesc* temp_recon_ptr,

                                               uint64_t* fast_cost, uint64_t* full_cost, uint64_t* full_cost_ssim) {

    buffer_ptr->dctor = mode_decision_cand_bf_dctor;

    // Candidate Ptr

    buffer_ptr->cand = NULL;

    // Video Buffers — pred/rec_coeff/quant borrowed from MD-context pools; residual/recon

    // shared with the MD context.

    buffer_ptr->pred      = pred;

    buffer_ptr->residual  = temp_residual;

    buffer_ptr->rec_coeff = rec_coeff;

    buffer_ptr->quant     = quant;

    buffer_ptr->recon     = temp_recon_ptr;

    // Costs

    buffer_ptr->fast_cost      = fast_cost;

    buffer_ptr->full_cost      = full_cost;

    buffer_ptr->full_cost_ssim = full_cost_ssim;

    return EB_ErrorNone;

}

EbErrorType svt_aom_mode_decision_scratch_cand_bf_ctor(ModeDecisionCandidateBuffer* buffer_ptr, uint8_t sb_size,

                                                       EbBitDepth max_bitdepth) {

    EbPictureBufferDescInitData picture_buffer_desc_init_data;

    EbPictureBufferDescInitData double_width_picture_buffer_desc_init_data;

    EbPictureBufferDescInitData thirty_two_width_picture_buffer_desc_init_data;

    buffer_ptr->dctor = mode_decision_scratch_cand_bf_dctor;

    // Init Picture Data

    picture_buffer_desc_init_data.max_width                           = sb_size;

    picture_buffer_desc_init_data.max_height                          = sb_size;

    picture_buffer_desc_init_data.bit_depth                           = max_bitdepth;

    picture_buffer_desc_init_data.color_format                        = EB_YUV420;

    picture_buffer_desc_init_data.buffer_enable_mask                  = PICTURE_BUFFER_DESC_FULL_MASK;

    picture_buffer_desc_init_data.border                              = 0;

    picture_buffer_desc_init_data.split_mode                          = false;

    picture_buffer_desc_init_data.is_16bit_pipeline                   = max_bitdepth > EB_EIGHT_BIT;

    double_width_picture_buffer_desc_init_data.max_width              = sb_size;

    double_width_picture_buffer_desc_init_data.max_height             = sb_size;

    double_width_picture_buffer_desc_init_data.bit_depth              = EB_SIXTEEN_BIT;

    double_width_picture_buffer_desc_init_data.color_format           = EB_YUV420;

    double_width_picture_buffer_desc_init_data.buffer_enable_mask     = PICTURE_BUFFER_DESC_FULL_MASK;

    double_width_picture_buffer_desc_init_data.border                 = 0;

    double_width_picture_buffer_desc_init_data.split_mode             = false;

    double_width_picture_buffer_desc_init_data.is_16bit_pipeline      = true;

    thirty_two_width_picture_buffer_desc_init_data.max_width          = sb_size;

    thirty_two_width_picture_buffer_desc_init_data.max_height         = sb_size;

    thirty_two_width_picture_buffer_desc_init_data.bit_depth          = EB_THIRTYTWO_BIT;

    thirty_two_width_picture_buffer_desc_init_data.color_format       = EB_YUV420;

    thirty_two_width_picture_buffer_desc_init_data.buffer_enable_mask = PICTURE_BUFFER_DESC_FULL_MASK;

    thirty_two_width_picture_buffer_desc_init_data.border             = 0;

    thirty_two_width_picture_buffer_desc_init_data.split_mode         = false;

    thirty_two_width_picture_buffer_desc_init_data.is_16bit_pipeline  = true;

    // Candidate Ptr

    buffer_ptr->cand = NULL;

    // Video Buffers

    EB_NEW(buffer_ptr->pred, svt_picture_buffer_desc_ctor, (EbPtr)&picture_buffer_desc_init_data);

    EB_NEW(buffer_ptr->residual, svt_picture_buffer_desc_ctor, (EbPtr)&double_width_picture_buffer_desc_init_data);

    EB_NEW(buffer_ptr->rec_coeff, svt_picture_buffer_desc_ctor, (EbPtr)&thirty_two_width_picture_buffer_desc_init_data);

    EB_NEW(buffer_ptr->quant, svt_picture_buffer_desc_ctor, (EbPtr)&thirty_two_width_picture_buffer_desc_init_data);

    EB_NEW(buffer_ptr->recon, svt_picture_buffer_desc_ctor, (EbPtr)&picture_buffer_desc_init_data);

    return EB_ErrorNone;

}

/***************************************

* return true if the MV candidate is already injected

***************************************/

static bool mv_is_already_injected(ModeDecisionContext* ctx, Mv mv0, Mv mv1, uint8_t ref_type) {

    MvReferenceFrame rf[2];

    av1_set_ref_frame(rf, ref_type);

    // Unipred Candidate

    if (rf[1] <= INTRA_FRAME) {

        // First check the validity of the candidate MV, and exit if invalid MV

        if (ctx->corrupted_mv_check && !check_mv_validity(mv0.x, mv0.y, 0)) {

            return true;

        }

        for (int cand_idx = 0; cand_idx < ctx->injected_mv_count; cand_idx++) {

            if (ctx->injected_ref_types[cand_idx] == ref_type && ctx->injected_mvs[cand_idx][0].as_int == mv0.as_int) {

                return true;

            }

        }

    } else { // Bipred Candidate

        // First check the validity of the candidate MV, and exit if invalid MV

        if (ctx->corrupted_mv_check && (!check_mv_validity(mv0.x, mv0.y, 0) || !check_mv_validity(mv1.x, mv1.y, 0))) {

            return true;

        }

        RedundantCandCtrls* redund_ctrls = &ctx->cand_reduction_ctrls.redundant_cand_ctrls;

        if (redund_ctrls->score_th) {

            uint8_t is_high_mag = (ABS(mv0.x) > redund_ctrls->mag_th) && (ABS(mv0.y) > redund_ctrls->mag_th) &&

                (ABS(mv1.x) > redund_ctrls->mag_th) && (ABS(mv1.y) > redund_ctrls->mag_th);

            for (int cand_idx = 0; cand_idx < ctx->injected_mv_count; cand_idx++) {

                if (ctx->injected_ref_types[cand_idx] == ref_type) {

                    int score = ABS(ctx->injected_mvs[cand_idx][0].x - mv0.x) +

                        ABS(ctx->injected_mvs[cand_idx][0].y - mv0.y) + ABS(ctx->injected_mvs[cand_idx][1].x - mv1.x) +

                        ABS(ctx->injected_mvs[cand_idx][1].y - mv1.y);

                    if (score == 0 || (score < redund_ctrls->score_th && is_high_mag)) {

                        return true;

                    }

                }

            }

        } else {

            for (int cand_idx = 0; cand_idx < ctx->injected_mv_count; cand_idx++) {

                if (ctx->injected_ref_types[cand_idx] == ref_type &&

                    ctx->injected_mvs[cand_idx][0].as_int == mv0.as_int &&

                    ctx->injected_mvs[cand_idx][1].as_int == mv1.as_int) {

                    return true;

                }

            }

        }

    }

    return false;

}

bool svt_aom_is_valid_unipred_ref(ModeDecisionContext* ctx, uint8_t inter_cand_group, uint8_t list_idx,

                                  uint8_t ref_idx) {

    if (!ctx->ref_pruning_ctrls.enabled) {

        return true;

    }

    if (!ctx->ref_filtering_res[inter_cand_group][list_idx][ref_idx].do_ref &&

        (ref_idx || !ctx->ref_pruning_ctrls.closest_refs[inter_cand_group])) {

        return false;

    } else {

        return true;

    }

}

// Determine if the MV-to-MVP difference satisfies the mv_diff restriction

static bool is_valid_mv_diff(Mv best_pred_mv[2], Mv mv0, Mv mv1, uint8_t is_compound) {

    const uint8_t mv_diff_max_bit = MV_IN_USE_BITS;

    if (abs(mv0.x - best_pred_mv[0].x) > (1 << mv_diff_max_bit) ||

        abs(mv0.y - best_pred_mv[0].y) > (1 << mv_diff_max_bit)) {

        return false;

    }

    if (is_compound) {

        if (abs(mv1.x - best_pred_mv[1].x) > (1 << mv_diff_max_bit) ||

            abs(mv1.y - best_pred_mv[1].y) > (1 << mv_diff_max_bit)) {

            return false;

        }

    }

    return true;

}

static bool is_valid_bipred_ref(ModeDecisionContext* ctx, uint8_t inter_cand_group, uint8_t list_idx_0,

                                uint8_t ref_idx_0, uint8_t list_idx_1, uint8_t ref_idx_1) {

    if (!ctx->ref_pruning_ctrls.enabled) {

        return true;

    }

    // Both ref should be 1 for bipred refs to be valid: if 1 is not best_refs then there is a chance to exit the injection

    if (!ctx->ref_filtering_res[inter_cand_group][list_idx_0][ref_idx_0].do_ref ||

        !ctx->ref_filtering_res[inter_cand_group][list_idx_1][ref_idx_1].do_ref) {

        // Check whether we should check the closest, if no then there no need to move forward and return false

        if (!ctx->ref_pruning_ctrls.closest_refs[inter_cand_group]) {

            return false;

        }

        // Else check if ref are LAST and BWD, if not then return false

        if (ref_idx_0 || ref_idx_1) {

            return false;

        }

    }

    return true;

}

#define BIPRED_3x3_REFINMENT_POSITIONS 8

static int8_t allow_refinement_flag[BIPRED_3x3_REFINMENT_POSITIONS] = {1, 0, 1, 0, 1, 0, 1, 0};

static int8_t bipred_3x3_x_pos[BIPRED_3x3_REFINMENT_POSITIONS]      = {-1, -1, 0, 1, 1, 1, 0, -1};

static int8_t bipred_3x3_y_pos[BIPRED_3x3_REFINMENT_POSITIONS]      = {0, 1, 1, 1, 0, -1, -1, -1};

static INLINE uint8_t is_dc_only_safe(PictureControlSet* pcs, ModeDecisionContext* ctx) {

    // Early exit if pruning not enabled, SB-128, NSQ, or 4x4 (no variance available)

    if (!ctx->intra_ctrls.prune_using_edge_info || pcs->scs->super_block_size == 128 || ctx->shape != PART_N ||

        ctx->blk_geom->sq_size == 4) {

        return 0;

    }

    // Block variance lookup

    int            blk_idx;

    int            sub_idx[4];

    const Position blk_org = {.x = ctx->blk_org_x - ctx->sb_origin_x, .y = ctx->blk_org_y - ctx->sb_origin_y};

    svt_aom_get_blk_var_map(ctx->blk_geom->sq_size, blk_org.x, blk_org.y, &blk_idx, sub_idx);

    uint16_t* sb_var  = pcs->ppcs->variance[ctx->sb_index];

    uint32_t  blk_var = sb_var[blk_idx];

    // For 8x8, we do not have 4x4 sub-variance, skip spread check

    if (ctx->blk_geom->sq_size == 8) {

        return (blk_var < 2000);

    }

    // For 16x16 and above, compute spread from sub-blocks

    uint32_t min_var = UINT32_MAX;

    uint32_t max_var = 0;

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

        uint32_t v = sb_var[sub_idx[i]];

        min_var    = MIN(min_var, v);

        max_var    = MAX(max_var, v);

    }

    uint32_t spread_var = max_var - min_var;

    return (blk_var < 2000 && spread_var < 4000);

}

// Inject inter-intra, WM, OBMC for unipred simple-trans candidate

//

// total_cand_count is the index to ctx->fast_cand_array for the next candidate injected (which is the

// same as the number of candidates injected so far).  It is assumed the simple-trans candidate to base

// the other candidtes on is the previously injected candidate (at index total_cand_count - 1).

//

// enable_ii, enable_wm, and enable_obmc allow the caller to disable some modes explicitly; if enabled, the

// mode will be injected if the block size/candidate type supports the mode. The enable signals are left as

// arguments because some candidates do not inject all modes (e.g. unipred does not inject WM/OBMC).

static void inj_non_simple_modes(PictureControlSet* pcs, ModeDecisionContext* ctx, uint32_t* total_cand_count,

                                 const bool enable_ii, const bool enable_wm, const bool enable_obmc) {

    // index of simple translation candidate (to be used to copy cand info for other modes)

    // assumes the simple trans cand is the previously injected candidate

    const uint32_t                     simple_trans_cand_idx = *total_cand_count - 1;

    const ModeDecisionCandidate* const simple_trans_cand     = &ctx->fast_cand_array[simple_trans_cand_idx];

    // The candidate count to be used to track number of inj cands, and the index of fast_cand_array for new candidates

    uint32_t cand_count = *total_cand_count;

    assert(simple_trans_cand->block_mi.ref_frame[1] == NONE_FRAME);

    const uint8_t list_idx = get_list_idx(simple_trans_cand->block_mi.ref_frame[0]);

    const uint8_t ref_idx  = get_ref_frame_idx(simple_trans_cand->block_mi.ref_frame[0]);

    // INJECT INTER-INTRA

    const uint8_t is_ii_allowed = svt_aom_is_valid_unipred_ref(ctx, INTER_INTRA_GROUP, list_idx, ref_idx) &&

        svt_is_interintra_allowed(ctx->inter_intra_comp_ctrls.enabled,

                                  ctx->blk_geom->bsize,

                                  simple_trans_cand->block_mi.mode,

                                  simple_trans_cand->block_mi.ref_frame);

    if (enable_ii && is_ii_allowed) {

        ModeDecisionCandidate* cand = &ctx->fast_cand_array[cand_count];

        svt_memcpy(cand, simple_trans_cand, sizeof(ModeDecisionCandidate));

        inter_intra_search(pcs, ctx, cand);

        cand->block_mi.is_interintra_used = 1;

        cand->block_mi.ref_frame[1]       = INTRA_FRAME;

        const InterIntraMode ii_mode      = cand->block_mi.interintra_mode;

        INC_MD_CAND_CNT(cand_count, pcs->ppcs->max_can_count);

        // if ii_wedge_mode is 1, then inject wedge/non-wedge as separate candidates; OW, only inject the best (above)

        const uint8_t ii_wedge_mode = ctx->shape == PART_N ? ctx->inter_intra_comp_ctrls.wedge_mode_sq

                                                           : ctx->inter_intra_comp_ctrls.wedge_mode_nsq;

        if (ii_wedge_mode == 1) {