#include "enc_mode_config.h"

/*

* Copyright(c) 2019 Intel Corporation

* Copyright(c) 2019 Netflix, Inc.

*

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

#include <limits.h>

#include "pd_process.h"

#include "definitions.h"

#include "enc_handle.h"

#include "pcs.h"

#include "sequence_control_set.h"

#include "pic_analysis_process.h"

#include "pic_analysis_results.h"

#include "pd_results.h"

#include "reference_object.h"

#include "EbSvtAv1ErrorCodes.h"

#include "temporal_filtering.h"

#include "object.h"

#include "utility.h"

#include "svt_log.h"

#include "common_dsp_rtcd.h"

#include "resize.h"

#include "svt_malloc.h"

#include "inter_prediction.h"

#include "aom_dsp_rtcd.h"

#include "pic_operators.h"

#if CONFIG_SINGLE_THREAD_KERNEL

#include "me_process.h" // MotionEstimationContext_t for inline TF in ST mode

#endif

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

 * Defines

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

#define LAY1_OFF 3

#define LAY2_OFF 5

#define LAY3_OFF 6

#define LAY4_OFF 7

void             svt_aom_get_max_allocated_me_refs(uint8_t ref_count_used_list0, uint8_t ref_count_used_list1,

                                                   uint8_t* max_ref_to_alloc, uint8_t* max_cand_to_alloc);

void             svt_aom_init_resize_picture(SequenceControlSet* scs, PictureParentControlSet* pcs);

MvReferenceFrame svt_get_ref_frame_type(uint8_t list, uint8_t ref_idx);

static uint32_t calc_ahd(SequenceControlSet* scs, PictureParentControlSet* input_pcs, PictureParentControlSet* ref_pcs,

                         uint8_t* active_region_cnt) {

    uint32_t ahd           = 0;

    uint32_t region_width  = ref_pcs->enhanced_pic->width / scs->picture_analysis_number_of_regions_per_width;

    uint32_t region_height = ref_pcs->enhanced_pic->height / scs->picture_analysis_number_of_regions_per_height;

    // Loop over regions inside the picture

    for (uint32_t region_in_picture_width_index = 0;

         region_in_picture_width_index < scs->picture_analysis_number_of_regions_per_width;

         region_in_picture_width_index++) { // loop over horizontal regions

        for (uint32_t region_in_picture_height_index = 0;

             region_in_picture_height_index < scs->picture_analysis_number_of_regions_per_height;

             region_in_picture_height_index++) { // loop over vertical regions

            uint32_t ahd_per_region = 0;

            for (int bin = 0; bin < HISTOGRAM_NUMBER_OF_BINS; ++bin) {

                ahd_per_region += ABS(

                    (int32_t)input_pcs

                        ->picture_histogram[region_in_picture_width_index][region_in_picture_height_index][bin] -

                    (int32_t)

                        ref_pcs->picture_histogram[region_in_picture_width_index][region_in_picture_height_index][bin]);

            }

            ahd += ahd_per_region;

            if (ahd_per_region > (region_width * region_height)) {

                (*active_region_cnt)++;

            }

        }

    }

    return ahd;

}

static INLINE int get_relative_dist(const OrderHintInfo* oh, int a, int b) {

    if (!oh->enable_order_hint) {

        return 0;

    }

    const int bits = oh->order_hint_bits;

    assert(bits >= 1);

    assert(a >= 0 && a < (1 << bits));

    assert(b >= 0 && b < (1 << bits));

    int       diff = a - b;

    const int m    = 1 << (bits - 1);

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

    return diff;

}

void svt_av1_setup_skip_mode_allowed(PictureParentControlSet* pcs) {

    FrameHeader*               frm_hdr         = &pcs->frm_hdr;

    const OrderHintInfo* const order_hint_info = &pcs->scs->seq_header.order_hint_info;

    SkipModeInfo* const        skip_mode_info  = &frm_hdr->skip_mode_params;

    skip_mode_info->skip_mode_allowed = 0;

    skip_mode_info->ref_frame_idx_0   = INVALID_IDX;

    skip_mode_info->ref_frame_idx_1   = INVALID_IDX;

    uint32_t* ref_order_hint = pcs->ref_order_hint;

    // If these conditions are true, skip mode is not allowed, so return early

    if (!order_hint_info->enable_order_hint || pcs->slice_type == I_SLICE /*frame_is_intra_only(cm)*/ ||

        frm_hdr->reference_mode == SINGLE_REFERENCE) {

        return;

    }

    const int cur_order_hint     = (int)pcs->cur_order_hint;

    int       ref_order_hints[2] = {-1, INT_MAX};

    int       ref_idx[2]         = {INVALID_IDX, INVALID_IDX};

    // Identify the nearest forward and backward references.

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

        const int ref_hint = (const int)ref_order_hint[i]; // buf->order_hint;

        if (get_relative_dist(order_hint_info, ref_hint, cur_order_hint) < 0) {

            // Forward reference

            if (ref_order_hints[0] == -1 || get_relative_dist(order_hint_info, ref_hint, ref_order_hints[0]) > 0) {

                ref_order_hints[0] = ref_hint;

                ref_idx[0]         = i;

            }

        } else if (get_relative_dist(order_hint_info, ref_hint, cur_order_hint) > 0) {

            // Backward reference

            if (ref_order_hints[1] == INT_MAX || get_relative_dist(order_hint_info, ref_hint, ref_order_hints[1]) < 0) {

                ref_order_hints[1] = ref_hint;

                ref_idx[1]         = i;

            }

        }

    }

    if (ref_idx[0] != INVALID_IDX && ref_idx[1] != INVALID_IDX) {

        // == Bi-directional prediction ==

        skip_mode_info->skip_mode_allowed = 1;

        skip_mode_info->ref_frame_idx_0   = LAST_FRAME + MIN(ref_idx[0], ref_idx[1]);

        skip_mode_info->ref_frame_idx_1   = LAST_FRAME + MAX(ref_idx[0], ref_idx[1]);

    } else if (ref_idx[0] != INVALID_IDX && ref_idx[1] == INVALID_IDX) {

        // == Forward prediction only ==

        // Identify the second nearest forward reference.

        ref_order_hints[1] = -1;

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

            const int ref_hint = (const int)ref_order_hint[i]; // buf->order_hint;

            if ((ref_order_hints[0] != -1 && get_relative_dist(order_hint_info, ref_hint, ref_order_hints[0]) < 0) &&

                (ref_order_hints[1] == -1 || get_relative_dist(order_hint_info, ref_hint, ref_order_hints[1]) > 0)) {

                // Second closest forward reference

                ref_order_hints[1] = ref_hint;

                ref_idx[1]         = i;

            }

        }

        if (ref_order_hints[1] != -1) {

            skip_mode_info->skip_mode_allowed = 1;

            skip_mode_info->ref_frame_idx_0   = LAST_FRAME + MIN(ref_idx[0], ref_idx[1]);

            skip_mode_info->ref_frame_idx_1   = LAST_FRAME + MAX(ref_idx[0], ref_idx[1]);

        }

    }

}

uint8_t circ_inc(uint8_t max, uint8_t off, uint8_t input) {

    input++;

    if (input >= max) {

        input = 0;

    }

    if (off == 2) {

        input++;

        if (input >= max) {

            input = 0;

        }

    }

    return input;

}

#define FLASH_TH 5

#define FADE_TH 3

#define SCENE_TH 3000

#define NUM64x64INPIC(w, h) ((w * h) >> (svt_log2f(BLOCK_SIZE_64) << 1))

#define QUEUE_GET_PREVIOUS_SPOT(h, size) (((h) == 0) ? (size) - 1 : (h) - 1)

#define QUEUE_GET_NEXT_SPOT(h, off, size) (((int)(h + off) >= (int)(size)) ? h + off - (int)(size) : h + off)

static void picture_decision_context_dctor(EbPtr p) {

    EbThreadContext*        thread_ctx = (EbThreadContext*)p;

    PictureDecisionContext* obj        = (PictureDecisionContext*)thread_ctx->priv;

    if (obj->prev_picture_histogram) {

        for (int region_in_picture_width_index = 0; region_in_picture_width_index < MAX_NUMBER_OF_REGIONS_IN_WIDTH;

             region_in_picture_width_index++) {

            if (obj->prev_picture_histogram[region_in_picture_width_index]) {

                for (int region_in_picture_height_index = 0;

                     region_in_picture_height_index < MAX_NUMBER_OF_REGIONS_IN_HEIGHT;

                     region_in_picture_height_index++) {

                    EB_FREE_ARRAY(

                        obj->prev_picture_histogram[region_in_picture_width_index][region_in_picture_height_index]);

                }

            }

            EB_FREE_PTR_ARRAY(obj->prev_picture_histogram[region_in_picture_width_index],

                              MAX_NUMBER_OF_REGIONS_IN_HEIGHT);

        }

        EB_FREE_PTR_ARRAY(obj->prev_picture_histogram, MAX_NUMBER_OF_REGIONS_IN_WIDTH);

    }

    EB_FREE_2D(obj->ahd_running_avg);

    EB_FREE_2D(obj->ahd_running_avg_cr);

    EB_FREE_2D(obj->ahd_running_avg_cb);

    EB_FREE_ARRAY(obj);

}

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

  * Picture Analysis Context Constructor

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

EbErrorType svt_aom_picture_decision_context_ctor(EbThreadContext* thread_ctx, const EbEncHandle* enc_handle_ptr,

                                                  uint8_t calc_hist) {

    PictureDecisionContext* pd_ctx;

    EB_CALLOC_ARRAY(pd_ctx, 1);

    thread_ctx->priv  = pd_ctx;

    thread_ctx->dctor = picture_decision_context_dctor;

    memset(pd_ctx->tf_pic_array, 0, (1 << MAX_TEMPORAL_LAYERS) * sizeof(PictureParentControlSet*));

    pd_ctx->tf_pic_arr_cnt                          = 0;

    pd_ctx->picture_analysis_results_input_fifo_ptr = svt_system_resource_get_consumer_fifo(

        enc_handle_ptr->picture_analysis_results_resource_ptr, 0);

    pd_ctx->picture_decision_results_output_fifo_ptr = svt_system_resource_get_producer_fifo(

        enc_handle_ptr->picture_decision_results_resource_ptr, 0);

    if (calc_hist) {

        EB_ALLOC_PTR_ARRAY(pd_ctx->prev_picture_histogram, MAX_NUMBER_OF_REGIONS_IN_WIDTH);

        for (uint32_t region_in_picture_width_index = 0; region_in_picture_width_index < MAX_NUMBER_OF_REGIONS_IN_WIDTH;

             region_in_picture_width_index++) { // loop over horizontal regions

            EB_ALLOC_PTR_ARRAY(pd_ctx->prev_picture_histogram[region_in_picture_width_index],

                               MAX_NUMBER_OF_REGIONS_IN_HEIGHT);

            for (uint32_t region_in_picture_height_index = 0;

                 region_in_picture_height_index < MAX_NUMBER_OF_REGIONS_IN_HEIGHT;

                 region_in_picture_height_index++) {

                EB_CALLOC_ARRAY(

                    pd_ctx->prev_picture_histogram[region_in_picture_width_index][region_in_picture_height_index],

                    HISTOGRAM_NUMBER_OF_BINS * sizeof(uint32_t));

            }

        }

        EB_CALLOC_2D(pd_ctx->ahd_running_avg,

                     MAX_NUMBER_OF_REGIONS_IN_WIDTH * sizeof(uint32_t),

                     MAX_NUMBER_OF_REGIONS_IN_HEIGHT * sizeof(uint32_t));

    }

    pd_ctx->reset_running_avg = true;

    pd_ctx->me_fifo_ptr       = svt_system_resource_get_producer_fifo(enc_handle_ptr->me_pool_ptr, 0);

    pd_ctx->mg_progress_id                    = 0;

    pd_ctx->last_i_noise_levels_log1p_fp16[0] = 0;

    pd_ctx->transition_detected               = -1;

    pd_ctx->sframe_poc                        = 0;

    pd_ctx->sframe_due                        = 0;

    pd_ctx->last_long_base_pic                = 0;

    pd_ctx->enable_startup_mg                 = false;

    pd_ctx->is_startup_gop                    = false;

    pd_ctx->sframe_hier_lvls                  = 0;

    pd_ctx->sframe_last_arf                   = 0;

    pd_ctx->next_arf_is_s                     = false;

    pd_ctx->current_input_poc                 = -1;

    return EB_ErrorNone;

}

static bool scene_transition_detector(PictureDecisionContext* pd_ctx, SequenceControlSet* scs,

                                      PictureParentControlSet** parent_pcs_window) {

    PictureParentControlSet* current_pcs_ptr = parent_pcs_window[1];

    PictureParentControlSet* future_pcs_ptr  = parent_pcs_window[2];

    // calculating the frame threshold based on the number of 64x64 blocks in the frame

    uint32_t region_threshold;

    bool is_abrupt_change; // this variable signals an abrupt change (scene change or flash)

    bool is_scene_change; // this variable signals a frame representing a scene change

    uint32_t** ahd_running_avg = pd_ctx->ahd_running_avg;

    uint32_t region_in_picture_width_index;

    uint32_t region_in_picture_height_index;

    uint32_t region_width;

    uint32_t region_height;

    uint32_t region_width_offset;

    uint32_t region_height_offset;

    uint32_t is_abrupt_change_count = 0;

    uint32_t is_scene_change_count  = 0;

    uint32_t region_count_threshold = (uint32_t)(((float)((scs->picture_analysis_number_of_regions_per_width *

                                                           scs->picture_analysis_number_of_regions_per_height) *

                                                          50) /

                                                  100) +

                                                 0.5);

    region_width  = parent_pcs_window[1]->enhanced_pic->width / scs->picture_analysis_number_of_regions_per_width;

    region_height = parent_pcs_window[1]->enhanced_pic->height / scs->picture_analysis_number_of_regions_per_height;

    // Loop over regions inside the picture

    for (region_in_picture_width_index = 0;

         region_in_picture_width_index < scs->picture_analysis_number_of_regions_per_width;

         region_in_picture_width_index++) { // loop over horizontal regions

        for (region_in_picture_height_index = 0;

             region_in_picture_height_index < scs->picture_analysis_number_of_regions_per_height;

             region_in_picture_height_index++) { // loop over vertical regions

            is_abrupt_change = false;

            is_scene_change  = false;

            // accumulative histogram (absolute) differences between the past and current frame

            uint32_t ahd = 0;

            region_width_offset = (region_in_picture_width_index ==

                                   scs->picture_analysis_number_of_regions_per_width - 1)

                ? parent_pcs_window[1]->enhanced_pic->width -

                    (scs->picture_analysis_number_of_regions_per_width * region_width)

                : 0;

            region_height_offset = (region_in_picture_height_index ==

                                    scs->picture_analysis_number_of_regions_per_height - 1)

                ? parent_pcs_window[1]->enhanced_pic->height -

                    (scs->picture_analysis_number_of_regions_per_height * region_height)

                : 0;

            region_width += region_width_offset;

            region_height += region_height_offset;

            region_threshold = SCENE_TH * NUM64x64INPIC(region_width, region_height);

            for (int bin = 0; bin < HISTOGRAM_NUMBER_OF_BINS; ++bin) {

                ahd += ABS((int32_t)current_pcs_ptr

                               ->picture_histogram[region_in_picture_width_index][region_in_picture_height_index][bin] -

                           (int32_t)pd_ctx->prev_picture_histogram[region_in_picture_width_index]

                                                                  [region_in_picture_height_index][bin]);

            }

            if (pd_ctx->reset_running_avg) {

                ahd_running_avg[region_in_picture_width_index][region_in_picture_height_index] = ahd;

            }

            uint32_t ahd_error = ABS(

                (int32_t)ahd_running_avg[region_in_picture_width_index][region_in_picture_height_index] - (int32_t)ahd);

            if (ahd_error > region_threshold && ahd >= ahd_error) {

                is_abrupt_change = true;

            }

            if (is_abrupt_change) {

                // this variable denotes the average intensity difference between the next and the past frames

                uint8_t aid_future_past = (uint8_t)ABS(

                    (int16_t)future_pcs_ptr

                        ->average_intensity_per_region[region_in_picture_width_index][region_in_picture_height_index] -

                    (int16_t)pd_ctx->prev_average_intensity_per_region[region_in_picture_width_index]

                                                                      [region_in_picture_height_index]);

                uint8_t aid_future_present = (uint8_t)ABS(

                    (int16_t)future_pcs_ptr

                        ->average_intensity_per_region[region_in_picture_width_index][region_in_picture_height_index] -

                    (int16_t)current_pcs_ptr

                        ->average_intensity_per_region[region_in_picture_width_index][region_in_picture_height_index]);

                uint8_t aid_present_past = (uint8_t)ABS(

                    (int16_t)current_pcs_ptr

                        ->average_intensity_per_region[region_in_picture_width_index][region_in_picture_height_index] -

                    (int16_t)pd_ctx->prev_average_intensity_per_region[region_in_picture_width_index]

                                                                      [region_in_picture_height_index]);

                if (aid_future_past < FLASH_TH && aid_future_present >= FLASH_TH && aid_present_past >= FLASH_TH) {

                    //SVT_LOG ("\nFlash in frame# %i , %i\n", current_pcs_ptr->picture_number,aid_future_past);

                } else if (aid_future_present < FADE_TH && aid_present_past < FADE_TH) {

                    //SVT_LOG ("\nFlash in frame# %i , %i\n", current_pcs_ptr->picture_number,aid_future_past);

                } else {

                    is_scene_change = true;

                    //SVT_LOG ("\nScene Change in frame# %i , %i\n", current_pcs_ptr->picture_number,aid_future_past);

                }

            } else {

                ahd_running_avg[region_in_picture_width_index][region_in_picture_height_index] =

                    (3 * ahd_running_avg[region_in_picture_width_index][region_in_picture_height_index] + ahd) / 4;

            }

            is_abrupt_change_count += is_abrupt_change;

            is_scene_change_count += is_scene_change;

        }

    }

    pd_ctx->reset_running_avg = is_abrupt_change_count >= region_count_threshold;

    return is_scene_change_count >= region_count_threshold;

}

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

* release_prev_picture_from_reorder_queue

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

EbErrorType release_prev_picture_from_reorder_queue(EncodeContext* enc_ctx) {

    EbErrorType return_error = EB_ErrorNone;

    PictureDecisionReorderEntry* queue_previous_entry_ptr;

    int32_t                      previous_entry_index;

    // Get the previous entry from the Picture Decision Reordering Queue (Entry N-1)

    // P.S. The previous entry in display order is needed for Scene Change Detection

    previous_entry_index     = (enc_ctx->picture_decision_reorder_queue_head_index == 0)

            ? enc_ctx->picture_decision_reorder_queue_size - 1

            : enc_ctx->picture_decision_reorder_queue_head_index - 1;

    queue_previous_entry_ptr = enc_ctx->picture_decision_reorder_queue[previous_entry_index];

    // SB activity classification based on (0,0) SAD & picture activity derivation

    if (queue_previous_entry_ptr->ppcs_wrapper) {

        // Reset the Picture Decision Reordering Queue Entry

        // P.S. The reset of the Picture Decision Reordering Queue Entry could not be done before running the Scene Change Detector

        queue_previous_entry_ptr->picture_number += enc_ctx->picture_decision_reorder_queue_size;

        queue_previous_entry_ptr->ppcs_wrapper = NULL;

    }

    return return_error;

}

static void early_hme_b64(uint8_t* sixteenth_b64_buffer, uint32_t sixteenth_b64_buffer_stride,

                          uint8_t  hme_search_method, //

                          int16_t  org_x, // Block position in the horizontal direction- sixteenth resolution

                          int16_t  org_y, // Block position in the vertical direction- sixteenth resolution

                          uint32_t block_width, // Block width - sixteenth resolution

                          uint32_t block_height, // Block height - sixteenth resolution

                          int16_t  sa_width, // search area width

                          int16_t  sa_height, // search area height

                          EbPictureBufferDesc* sixteenth_ref_pic_ptr, // sixteenth-downsampled reference picture

                          uint64_t*            best_sad, // output: Level0 SAD

                          Mv*                  sr_center // output: Level0 xMV, Level0 yMV

) {

    // round up the search region width to nearest multiple of 8 because the SAD calculation performance (for

    // intrinsic functions) is the same for search region width from 1 to 8

    sa_width           = (int16_t)((sa_width + 7) & ~0x07);

    int16_t pad_width  = (int16_t)(sixteenth_ref_pic_ptr->border) - 1;

    int16_t pad_height = (int16_t)(sixteenth_ref_pic_ptr->border) - 1;

    int16_t sa_origin_x = -(int16_t)(sa_width >> 1);

    int16_t sa_origin_y = -(int16_t)(sa_height >> 1);

    // Correct the left edge of the Search Area if it is not on the reference picture

    if (((org_x + sa_origin_x) < -pad_width)) {

        sa_origin_x = -pad_width - org_x;

        sa_width    = sa_width - (-pad_width - (org_x + sa_origin_x));

    }

    // Correct the right edge of the Search Area if its not on the reference picture

    if (((org_x + sa_origin_x) > (int16_t)sixteenth_ref_pic_ptr->width - 1)) {

        sa_origin_x = sa_origin_x - ((org_x + sa_origin_x) - ((int16_t)sixteenth_ref_pic_ptr->width - 1));

    }

    if (((org_x + sa_origin_x + sa_width) > (int16_t)sixteenth_ref_pic_ptr->width)) {

        sa_width = MAX(1, sa_width - ((org_x + sa_origin_x + sa_width) - (int16_t)sixteenth_ref_pic_ptr->width));

    }

    // Constrain x_HME_L1 to be a multiple of 8 (round down as cropping alrea performed)

    sa_width = (sa_width < 8) ? sa_width : sa_width & ~0x07;

    // Correct the top edge of the Search Area if it is not on the reference picture

    if (((org_y + sa_origin_y) < -pad_height)) {

        sa_origin_y = -pad_height - org_y;

        sa_height   = sa_height - (-pad_height - (org_y + sa_origin_y));

    }

    // Correct the bottom edge of the Search Area if its not on the reference picture

    if (((org_y + sa_origin_y) > (int16_t)sixteenth_ref_pic_ptr->height - 1)) {

        sa_origin_y = sa_origin_y - ((org_y + sa_origin_y) - ((int16_t)sixteenth_ref_pic_ptr->height - 1));

    }

    if ((org_y + sa_origin_y + sa_height > (int16_t)sixteenth_ref_pic_ptr->height)) {

        sa_height = MAX(1, sa_height - ((org_y + sa_origin_y + sa_height) - (int16_t)sixteenth_ref_pic_ptr->height));

    }

    // Move to the top left of the search region

    int16_t x_top_left_search_region = (org_x) + sa_origin_x;

    int16_t y_top_left_search_region = (org_y) + sa_origin_y;

    int32_t search_region_index = x_top_left_search_region + y_top_left_search_region * sixteenth_ref_pic_ptr->y_stride;

    // Put the first search location into level0 results

    svt_sad_loop_kernel(

        &sixteenth_b64_buffer[0],

        (hme_search_method == FULL_SAD_SEARCH) ? sixteenth_b64_buffer_stride : sixteenth_b64_buffer_stride * 2,

        &sixteenth_ref_pic_ptr->y_buffer[search_region_index],

        (hme_search_method == FULL_SAD_SEARCH) ? sixteenth_ref_pic_ptr->y_stride : sixteenth_ref_pic_ptr->y_stride * 2,

        (hme_search_method == FULL_SAD_SEARCH) ? block_height : block_height >> 1,

        block_width,

        /* results */

        best_sad,

        &sr_center->x,

        &sr_center->y,

        /* range */

        sixteenth_ref_pic_ptr->y_stride,

        0, // skip search line

        sa_width,

        sa_height);

    *best_sad = (hme_search_method == FULL_SAD_SEARCH)

        ? *best_sad

        : *best_sad * 2; // Multiply by 2 because considered only ever other line

    sr_center->x += sa_origin_x;

    sr_center->x *= 4; // Multiply by 4 because operating on 1/4 resolution

    sr_center->y += sa_origin_y;

    sr_center->y *= 4; // Multiply by 4 because operating on 1/4 resolution

    return;

}

void dg_detector_hme_level0(PictureParentControlSet* ppcs, uint32_t seg_idx) {

    EbPictureBufferDesc* src_sixt_ds_pic =

        ((EbPaReferenceObject*)ppcs->pa_ref_pic_wrapper->object_ptr)->sixteenth_downsampled_picture_ptr;

    EbPictureBufferDesc* ref_sixt_ds_pic =

        ((EbPaReferenceObject*)ppcs->dg_detector->ref_pic->pa_ref_pic_wrapper->object_ptr)

            ->sixteenth_downsampled_picture_ptr;

    int16_t sa_width  = ppcs->input_resolution <= INPUT_SIZE_360p_RANGE ? 16

         : ppcs->input_resolution <= INPUT_SIZE_480p_RANGE              ? 64

                                                                        : 128;

    int16_t sa_height = ppcs->input_resolution <= INPUT_SIZE_360p_RANGE ? 16

        : ppcs->input_resolution <= INPUT_SIZE_480p_RANGE               ? 64

                                                                        : 128;

    uint64_t hme_level0_sad = (uint64_t)~0;

    Mv       sr_center      = {.as_int = 0};

    uint8_t hme_search_method = FULL_SAD_SEARCH;

    // determine the starting and ending block for each segment

    uint32_t pic_width_in_b64  = (ppcs->aligned_width + ppcs->scs->b64_size - 1) / ppcs->scs->b64_size;

    uint32_t pic_height_in_b64 = (ppcs->aligned_height + ppcs->scs->b64_size - 1) / ppcs->scs->b64_size;

    uint32_t y_seg_idx;

    uint32_t x_seg_idx;

    SEGMENT_CONVERT_IDX_TO_XY(seg_idx, x_seg_idx, y_seg_idx, ppcs->me_segments_column_count);

    uint32_t x_b64_start_idx = SEGMENT_START_IDX(x_seg_idx, pic_width_in_b64, ppcs->me_segments_column_count);

    uint32_t x_b64_end_idx   = SEGMENT_END_IDX(x_seg_idx, pic_width_in_b64, ppcs->me_segments_column_count);

    uint32_t y_b64_start_idx = SEGMENT_START_IDX(y_seg_idx, pic_height_in_b64, ppcs->me_segments_row_count);

    uint32_t y_b64_end_idx   = SEGMENT_END_IDX(y_seg_idx, pic_height_in_b64, ppcs->me_segments_row_count);

    for (uint32_t y_b64_idx = y_b64_start_idx; y_b64_idx < y_b64_end_idx; ++y_b64_idx) {

        for (uint32_t x_b64_idx = x_b64_start_idx; x_b64_idx < x_b64_end_idx; ++x_b64_idx) {

            uint32_t b64_origin_x = x_b64_idx * 64;

            uint32_t b64_origin_y = y_b64_idx * 64;

            uint32_t buffer_index = ((b64_origin_y >> 2)) * src_sixt_ds_pic->y_stride + (b64_origin_x >> 2);

            early_hme_b64(&src_sixt_ds_pic->y_buffer[buffer_index],

                          src_sixt_ds_pic->y_stride,

                          hme_search_method,

                          ((int16_t)b64_origin_x) >> 2,

                          ((int16_t)b64_origin_y) >> 2,

                          16,

                          16,

                          sa_width,

                          sa_height,

                          ref_sixt_ds_pic,

                          &hme_level0_sad,

                          &sr_center);

            // lock the dg metrics calculation using a mutex, only one segment can modify the data at a time

            svt_block_on_mutex(ppcs->dg_detector->metrics_mutex);

            ppcs->dg_detector->metrics.tot_dist += hme_level0_sad;

            ppcs->dg_detector->metrics.tot_cplx += (hme_level0_sad > (16 * 16 * 30));

            ppcs->dg_detector->metrics.tot_active += ((abs(sr_center.x) > 0) || (abs(sr_center.y) > 0));

            if (y_b64_idx < pic_height_in_b64 / 2) {

                if (sr_center.y > 0) {

                    --ppcs->dg_detector->metrics.sum_in_vectors;

                } else if (sr_center.y < 0) {

                    ++ppcs->dg_detector->metrics.sum_in_vectors;

                }

            } else if (y_b64_idx > pic_height_in_b64 / 2) {

                if (sr_center.y > 0) {

                    ++ppcs->dg_detector->metrics.sum_in_vectors;

                } else if (sr_center.y < 0) {

                    --ppcs->dg_detector->metrics.sum_in_vectors;

                }

            }

            // Does the col vector point inwards or outwards?

            if (x_b64_idx < pic_width_in_b64 / 2) {

                if (sr_center.x > 0) {

                    --ppcs->dg_detector->metrics.sum_in_vectors;

                } else if (sr_center.x < 0) {

                    ++ppcs->dg_detector->metrics.sum_in_vectors;

                }

            } else if (x_b64_idx > pic_width_in_b64 / 2) {

                if (sr_center.x > 0) {

                    ++ppcs->dg_detector->metrics.sum_in_vectors;

                } else if (sr_center.x < 0) {

                    --ppcs->dg_detector->metrics.sum_in_vectors;

                }

            }

            svt_release_mutex(ppcs->dg_detector->metrics_mutex);

        }

    }

    svt_block_on_mutex(ppcs->dg_detector->metrics_mutex);

    ppcs->dg_detector->metrics.seg_completed++;

    if (ppcs->dg_detector->metrics.seg_completed == (ppcs->me_segments_column_count * ppcs->me_segments_row_count)) {

        // signal that all the hme_level0 segments have been performed and dg metrics collected for the frame

        svt_post_semaphore(ppcs->dg_detector->frame_done_sem);

    }

    svt_release_mutex(ppcs->dg_detector->metrics_mutex);

}

static void early_hme(PictureDecisionContext* ctx, PictureParentControlSet* src_pcs, PictureParentControlSet* ref_pcs) {

    // store the ref pic so it can be used by dg detector when the src picture is sent to the motion estimation kernel

    src_pcs->dg_detector->ref_pic = ref_pcs;

    uint16_t dg_detector_seg_total_count = (uint16_t)(src_pcs->me_segments_column_count) *

        (uint16_t)(src_pcs->me_segments_row_count);

    // reset all metrics for the frame, must be performed here since the frame can be used again in a future comparison

    src_pcs->dg_detector->metrics.seg_completed  = 0;

    src_pcs->dg_detector->metrics.sum_in_vectors = 0;

    src_pcs->dg_detector->metrics.tot_dist       = 0;

    src_pcs->dg_detector->metrics.tot_cplx       = 0;

    src_pcs->dg_detector->metrics.tot_active     = 0;

#if CONFIG_SINGLE_THREAD_KERNEL

    if (src_pcs->scs->lp == 1) {

        // ST mode: run DG detector segments inline to avoid dispatching to ME

        // FIFO and blocking on the semaphore (same pattern as mctf_frame_st).

        for (uint16_t seg_idx = 0; seg_idx < dg_detector_seg_total_count; ++seg_idx) {

            dg_detector_hme_level0(src_pcs, seg_idx);

        }

        // dg_detector_hme_level0 posts frame_done_sem on the last segment — consume it.

        svt_block_on_semaphore(src_pcs->dg_detector->frame_done_sem);

    } else

#endif

    {

        // create segments for the dg detector and send them to the motion estimation kernel

        for (uint16_t seg_idx = 0; seg_idx < dg_detector_seg_total_count; ++seg_idx) {

            EbObjectWrapper*        out_results_wrp;

            PictureDecisionResults* out_results;

            svt_get_empty_object(ctx->picture_decision_results_output_fifo_ptr, &out_results_wrp);

            out_results                = (PictureDecisionResults*)out_results_wrp->object_ptr;

            out_results->pcs_wrapper   = src_pcs->p_pcs_wrapper_ptr;

            out_results->segment_index = seg_idx;

            out_results->task_type     = TASK_DG_DETECTOR_HME;

            svt_post_full_object(out_results_wrp);

        }

        // wait for all segments to complete before the frame based calculations can be performed using the dg metrics

        svt_block_on_semaphore(src_pcs->dg_detector->frame_done_sem);

    }

    // 64x64 Block Loop

    uint32_t pic_width_in_b64  = (src_pcs->aligned_width + 63) / 64;

    uint32_t pic_height_in_b64 = (src_pcs->aligned_height + 63) / 64;

    ctx->mv_in_out_count = src_pcs->dg_detector->metrics.sum_in_vectors * 100 /

        (int)(pic_height_in_b64 * pic_width_in_b64);

    ctx->norm_dist   = src_pcs->dg_detector->metrics.tot_dist / (pic_height_in_b64 * pic_width_in_b64);

    ctx->perc_cplx   = (src_pcs->dg_detector->metrics.tot_cplx * 100) / (pic_height_in_b64 * pic_width_in_b64);

    ctx->perc_active = (src_pcs->dg_detector->metrics.tot_active * 100) / (pic_height_in_b64 * pic_width_in_b64);

}

#define HIGH_DIST_TH 16 * 16 * 18

#define LOW_DIST_TH 16 * 16 * 2

static void calc_mini_gop_activity(PictureDecisionContext* ctx, EncodeContext* enc_ctx, uint64_t top_layer_idx,

                                   uint64_t top_layer_dist, uint8_t top_layer_perc_active, uint8_t top_layer_perc_cplx,

                                   uint64_t sub_layer_idx0, uint64_t sub_layer_dist0, uint8_t sub_layer0_perc_active,

                                   uint8_t sub_layer0_perc_cplx, uint64_t sub_layer_idx1, uint64_t sub_layer_dist1,

                                   uint8_t sub_layer1_perc_active, uint8_t sub_layer1_perc_cplx,

                                   int16_t top_layer_mv_in_out_count, int16_t sub_layer_mv_in_out_count1,

                                   int16_t sub_layer_mv_in_out_count2) {

    (void)top_layer_mv_in_out_count;

    // The bias is function of the previous mini-gop structure towards less switch(es) within the same gop

    // 6L will be maintained unless the presence of a significant change compared to the previous mini-gop

    // To do: make the bias function of the preset; higher is the preset, higher is the bias towards less 6L

    int bias = (enc_ctx->mini_gop_cnt_per_gop > 1 && enc_ctx->previous_mini_gop_hierarchical_levels == 5) ? 25 : 75;

    const bool cond1 = top_layer_perc_active >= 95 && !(sub_layer0_perc_active >= 95 && sub_layer1_perc_active < 75) &&

        !(sub_layer0_perc_active < 75 && sub_layer1_perc_active >= 95);

    const bool cond2 = top_layer_dist > LOW_DIST_TH && sub_layer_dist0 < HIGH_DIST_TH &&

        sub_layer_dist1 < HIGH_DIST_TH && top_layer_perc_cplx > 0 && sub_layer0_perc_cplx < 25 &&

        sub_layer1_perc_cplx < 25 && (((sub_layer_dist0 + sub_layer_dist1) / 2) < ((bias * top_layer_dist) / 100));

    const bool cond3 = MIN(sub_layer_mv_in_out_count1, sub_layer_mv_in_out_count2) > 40 &&

        MAX(sub_layer_mv_in_out_count1, sub_layer_mv_in_out_count2) > 55;

    if (cond1 && (cond2 || cond3)) {

        ctx->mini_gop_activity_array[top_layer_idx]  = true;

        ctx->mini_gop_activity_array[sub_layer_idx0] = false;

        ctx->mini_gop_activity_array[sub_layer_idx1] = false;

    }

}

static void eval_sub_mini_gop(PictureDecisionContext* ctx, EncodeContext* enc_ctx, uint64_t top_layer_idx,

                              uint64_t sub_layer_idx0, uint64_t sub_layer_idx1, PictureParentControlSet* start_pcs,

                              PictureParentControlSet* mid_pcs, PictureParentControlSet* end_pcs) {

    early_hme(ctx, end_pcs, start_pcs);

    uint64_t dist_end_start            = ctx->norm_dist;

    uint8_t  perc_cplx_end_start       = ctx->perc_cplx;

    uint8_t  perc_active_end_start     = ctx->perc_active;

    int16_t  mv_in_out_count_end_start = ctx->mv_in_out_count;

    early_hme(ctx, end_pcs, mid_pcs);

    uint64_t dist_end_mid            = ctx->norm_dist;

    uint8_t  perc_cplx_end_mid       = ctx->perc_cplx;

    uint8_t  perc_active_end_mid     = ctx->perc_active;

    int16_t  mv_in_out_count_end_mid = ctx->mv_in_out_count;

    early_hme(ctx, mid_pcs, start_pcs);

    uint64_t dist_mid_start            = ctx->norm_dist;

    uint8_t  perc_cplx_mid_start       = ctx->perc_cplx;

    uint8_t  perc_active_mid_start     = ctx->perc_active;

    int16_t  mv_in_out_count_mid_start = ctx->mv_in_out_count;

    calc_mini_gop_activity(ctx,

                           enc_ctx,

                           top_layer_idx,

                           dist_end_start,

                           perc_active_end_start,

                           perc_cplx_end_start,

                           sub_layer_idx0,

                           dist_mid_start,

                           perc_active_mid_start,

                           perc_cplx_mid_start,

                           sub_layer_idx1,

                           dist_end_mid,

                           perc_active_end_mid,

                           perc_cplx_end_mid,

                           mv_in_out_count_end_start,

                           mv_in_out_count_end_mid,

                           mv_in_out_count_mid_start);

}

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

* Initializes mini GOP activity array

*

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

static void initialize_mini_gop_activity_array(SequenceControlSet* scs, PictureParentControlSet* pcs,

                                               EncodeContext* enc_ctx, PictureDecisionContext* ctx) {

    (void)scs;

    // Loop over all mini GOPs to initialize the activity

    for (uint32_t gopindex = 0; gopindex < MINI_GOP_MAX_COUNT; ++gopindex) {

        ctx->mini_gop_activity_array[gopindex] = svt_aom_get_mini_gop_stats(gopindex)->hierarchical_levels >

            MIN_HIERARCHICAL_LEVEL;

    }

    // Assign the MGs to be used; if the MG is incomplete, the pre-assignment buffer will hold

    // fewer than (1 << scs->static_config.hierarchical_levels) pics

    if (enc_ctx->pre_assignment_buffer_count >= 32 && !(enc_ctx->pre_assignment_buffer_count == 32 && pcs->idr_flag)) {

        ctx->mini_gop_activity_array[L6_INDEX] = false;

    } else if (enc_ctx->pre_assignment_buffer_count >= 16 &&

               !(enc_ctx->pre_assignment_buffer_count == 16 && pcs->idr_flag)) {

        ctx->mini_gop_activity_array[L5_0_INDEX] = false;

        if ((enc_ctx->pre_assignment_buffer_count - 16) >= 8 &&

            !((enc_ctx->pre_assignment_buffer_count - 16) == 8 && pcs->idr_flag)) {

            ctx->mini_gop_activity_array[L4_2_INDEX] = false;

            if ((enc_ctx->pre_assignment_buffer_count - 16 - 8) >= 4 &&

                !((enc_ctx->pre_assignment_buffer_count - 16 - 8) == 4 && pcs->idr_flag)) {

                ctx->mini_gop_activity_array[L3_6_INDEX] = false;

                if ((enc_ctx->pre_assignment_buffer_count - 16 - 8 - 4) >= 2 &&

                    !((enc_ctx->pre_assignment_buffer_count - 16 - 8 - 4) == 2 && pcs->idr_flag)) {

                    ctx->mini_gop_activity_array[L2_14_INDEX] = false;

                }

            } else if ((enc_ctx->pre_assignment_buffer_count - 16 - 8) >= 2 &&

                       !((enc_ctx->pre_assignment_buffer_count - 16 - 8) == 2 && pcs->idr_flag)) {

                ctx->mini_gop_activity_array[L2_12_INDEX] = false;

            }

        } else if ((enc_ctx->pre_assignment_buffer_count - 16) >= 4 &&

                   !((enc_ctx->pre_assignment_buffer_count - 16) == 4 && pcs->idr_flag)) {

            ctx->mini_gop_activity_array[L3_4_INDEX] = false;

            if ((enc_ctx->pre_assignment_buffer_count - 16 - 4) >= 2 &&

                !((enc_ctx->pre_assignment_buffer_count - 16 - 4) == 2 && pcs->idr_flag)) {

                ctx->mini_gop_activity_array[L2_10_INDEX] = false;

            }

        } else if ((enc_ctx->pre_assignment_buffer_count - 16) >= 2 &&

                   !((enc_ctx->pre_assignment_buffer_count - 16) == 2 && pcs->idr_flag)) {

            ctx->mini_gop_activity_array[L2_8_INDEX] = false;

        }

    } else if (enc_ctx->pre_assignment_buffer_count >= 8 &&

               !(enc_ctx->pre_assignment_buffer_count == 8 && pcs->idr_flag)) {

        ctx->mini_gop_activity_array[L4_0_INDEX] = false;

        if ((enc_ctx->pre_assignment_buffer_count - 8) >= 4 &&

            !((enc_ctx->pre_assignment_buffer_count - 8) == 4 && pcs->idr_flag)) {

            ctx->mini_gop_activity_array[L3_2_INDEX] = false;

            if ((enc_ctx->pre_assignment_buffer_count - 8 - 4) >= 2 &&

                !((enc_ctx->pre_assignment_buffer_count - 8 - 4) == 2 && pcs->idr_flag)) {

                ctx->mini_gop_activity_array[L2_6_INDEX] = false;

            }

        } else if ((enc_ctx->pre_assignment_buffer_count - 8) >= 2 &&

                   !((enc_ctx->pre_assignment_buffer_count - 8) == 2 && pcs->idr_flag)) {

            ctx->mini_gop_activity_array[L2_4_INDEX] = false;

        }

    } else if (enc_ctx->pre_assignment_buffer_count >= 4 &&

               !(enc_ctx->pre_assignment_buffer_count == 4 && pcs->idr_flag)) {

        ctx->mini_gop_activity_array[L3_0_INDEX] = false;

        if ((enc_ctx->pre_assignment_buffer_count - 4) >= 2 &&

            !((enc_ctx->pre_assignment_buffer_count - 4) == 2 && pcs->idr_flag)) {

            ctx->mini_gop_activity_array[L2_2_INDEX] = false;

        }

    } else if ((enc_ctx->pre_assignment_buffer_count) >= 2 &&

               !((enc_ctx->pre_assignment_buffer_count) == 2 && pcs->idr_flag)) {

        ctx->mini_gop_activity_array[L2_0_INDEX] = false;

    }

    // 6L vs. 5L

    if (scs->enable_dg && ctx->mini_gop_activity_array[L6_INDEX] == false) {

        PictureParentControlSet* start_pcs = (PictureParentControlSet*)enc_ctx->pre_assignment_buffer[0]->object_ptr;

        PictureParentControlSet* mid_pcs =

            (PictureParentControlSet*)enc_ctx

                ->pre_assignment_buffer[((1 << scs->static_config.hierarchical_levels) >> 1) - 1]

                ->object_ptr;

        PictureParentControlSet* end_pcs = (PictureParentControlSet*)enc_ctx

                                               ->pre_assignment_buffer[enc_ctx->pre_assignment_buffer_count - 1]

                                               ->object_ptr;

        eval_sub_mini_gop(ctx, enc_ctx, L6_INDEX, L5_0_INDEX, L5_1_INDEX, start_pcs, mid_pcs, end_pcs);

    }

    ctx->list0_only = 0;

    if (scs->list0_only_base) {

        ctx->list0_only = 1;

    }

}

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

* Generates block picture map

*

*

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

static EbErrorType generate_picture_window_split(PictureDecisionContext* pd_ctx, EncodeContext* enc_ctx) {

    pd_ctx->total_number_of_mini_gops = 0;

    // Loop over all mini GOPs

    for (uint32_t gopindex = 0; gopindex < MINI_GOP_MAX_COUNT; gopindex += pd_ctx->mini_gop_activity_array[gopindex]

             ? 1

             : mini_gop_offset[svt_aom_get_mini_gop_stats(gopindex)->hierarchical_levels - MIN_HIERARCHICAL_LEVEL]) {

        // Only for a valid mini GOP

        if (svt_aom_get_mini_gop_stats(gopindex)->end_index < enc_ctx->pre_assignment_buffer_count &&

            !pd_ctx->mini_gop_activity_array[gopindex]) {

            pd_ctx->mini_gop_start_index[pd_ctx->total_number_of_mini_gops] =

                svt_aom_get_mini_gop_stats(gopindex)->start_index;

            pd_ctx->mini_gop_end_index[pd_ctx->total_number_of_mini_gops] =

                svt_aom_get_mini_gop_stats(gopindex)->end_index;

            pd_ctx->mini_gop_length[pd_ctx->total_number_of_mini_gops] = svt_aom_get_mini_gop_stats(gopindex)->length;

            pd_ctx->mini_gop_hierarchical_levels[pd_ctx->total_number_of_mini_gops] =

                svt_aom_get_mini_gop_stats(gopindex)->hierarchical_levels;

            pd_ctx->mini_gop_intra_count[pd_ctx->total_number_of_mini_gops] = 0;

            pd_ctx->mini_gop_idr_count[pd_ctx->total_number_of_mini_gops]   = 0;

            pd_ctx->total_number_of_mini_gops++;

        }

    }

    // Only in presence of at least 1 valid mini GOP

    if (pd_ctx->total_number_of_mini_gops != 0) {

        pd_ctx->mini_gop_intra_count[pd_ctx->total_number_of_mini_gops - 1] =

            enc_ctx->pre_assignment_buffer_intra_count;

        pd_ctx->mini_gop_idr_count[pd_ctx->total_number_of_mini_gops - 1] = enc_ctx->pre_assignment_buffer_idr_count;

    }

    return EB_ErrorNone;

}

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

* Handles an incomplete picture window map

*

*

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

static EbErrorType handle_incomplete_picture_window_map(uint32_t hierarchical_level, PictureDecisionContext* pd_ctx,

                                                        EncodeContext* enc_ctx) {

    EbErrorType return_error = EB_ErrorNone;

    if (pd_ctx->total_number_of_mini_gops == 0) {