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

 *

 * Copyright (C) 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 *****************************************************************************

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

*/

/*!

******************************************************************************

* \file ihevce_recur_bracketing.c

*

* \brief

*    This file contains interface functions of recursive bracketing

*    module

* \date

*    12/02/2012

*

* \author

*    Ittiam

*

* List of Functions

*

*

******************************************************************************

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

/* User include files */

#include "ihevc_typedefs.h"

#include "itt_video_api.h"

#include "ihevce_api.h"

#include "rc_cntrl_param.h"

#include "rc_frame_info_collector.h"

#include "rc_look_ahead_params.h"

#include "ihevc_defs.h"

#include "ihevc_structs.h"

#include "ihevc_platform_macros.h"

#include "ihevc_deblk.h"

#include "ihevc_itrans_recon.h"

#include "ihevc_chroma_itrans_recon.h"

#include "ihevc_chroma_intra_pred.h"

#include "ihevc_intra_pred.h"

#include "ihevc_inter_pred.h"

#include "ihevc_mem_fns.h"

#include "ihevc_padding.h"

#include "ihevc_weighted_pred.h"

#include "ihevc_sao.h"

#include "ihevc_resi_trans.h"

#include "ihevc_quant_iquant_ssd.h"

#include "ihevc_cabac_tables.h"

#include "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_me_common_defs.h"

#include "ihevce_had_satd.h"

#include "ihevce_error_codes.h"

#include "ihevce_bitstream.h"

#include "ihevce_cabac.h"

#include "ihevce_rdoq_macros.h"

#include "ihevce_function_selector.h"

#include "ihevce_enc_structs.h"

#include "ihevce_entropy_structs.h"

#include "ihevce_cmn_utils_instr_set_router.h"

#include "ihevce_enc_loop_structs.h"

#include "ihevce_ipe_instr_set_router.h"

#include "ihevce_ipe_structs.h"

#include "ihevce_ipe_pass.h"

#include "ihevce_recur_bracketing.h"

#include "ihevce_nbr_avail.h"

#include "ihevc_common_tables.h"

#include "ihevce_decomp_pre_intra_structs.h"

#include "ihevce_decomp_pre_intra_pass.h"

#include "cast_types.h"

#include "osal.h"

#include "osal_defaults.h"

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

/* Constant Macros                                                           */

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

#define IP_DBG_L1_l2 0

#define CHILD_BIAS 12

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

/* Globals                                                                   */

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

extern pf_intra_pred g_apf_lum_ip[10];

extern WORD32 g_i4_ip_funcs[MAX_NUM_IP_MODES];

UWORD8 gau1_cu_pos_x[64] = { 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 4, 5, 6, 7,

                             6, 7, 4, 5, 4, 5, 6, 7, 6, 7, 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1,

                             2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 6, 7, 4, 5, 4, 5, 6, 7, 6, 7 };

UWORD8 gau1_cu_pos_y[64] = { 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3, 0, 0, 1, 1, 0, 0,

                             1, 1, 2, 2, 3, 3, 2, 2, 3, 3, 4, 4, 5, 5, 4, 4, 5, 5, 6, 6, 7, 7,

                             6, 6, 7, 7, 4, 4, 5, 5, 4, 4, 5, 5, 6, 6, 7, 7, 6, 6, 7, 7 };

#define RESET_BIT(x, bit) (x = x & ~((WORD32)1 << bit))

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

/* Function Definitions                                                      */

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

/*!

******************************************************************************

* \if Function name : ihevce_update_cand_list \endif

*

* \brief

*    Final Candidate list population, nbr flag andd nbr mode update function

*

* \param[in] ps_row_cu : pointer to cu analyse struct

* \param[in] ps_cu_node : pointer to cu node info buffer

* \param[in] ps_ed_blk_l1 : pointer to level 1 and 2 decision buffer

* \param[in] pu1_cand_mode_list  : pointer to candidate list buffer

*

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void ihevce_update_cand_list(

    ihevce_ipe_cu_tree_t *ps_cu_node, ihevce_ed_blk_t *ps_ed_blk_l1, ihevce_ipe_ctxt_t *ps_ctxt)

{

    WORD32 row, col, x, y, size;

    /* Candidate mode Update */

    (void)ps_ed_blk_l1;

    /* Update CTB mode map for the finalised CU */

    x = ((ps_cu_node->u2_x0 << 3) >> 2) + 1;

    y = ((ps_cu_node->u2_y0 << 3) >> 2) + 1;

    size = ps_cu_node->u1_cu_size >> 2;

    for(row = y; row < (y + size); row++)

    {

        for(col = x; col < (x + size); col++)

        {

            ps_ctxt->au1_ctb_mode_map[row][col] = ps_cu_node->best_mode;

        }

    }

    return;

}

/*!

******************************************************************************

* \if Function name : ihevce_intra_populate_mode_bits_cost_bracketing \endif

*

* \brief

*    Mpm indx calc function based on left and top available modes

*

* \param[in] top_intra_mode : Top available intra mode

* \param[in] left_intra_mode : Left available intra mode

* \param[in] available_top : Top availability flag

* \param[in] available_left : Left availability flag

* \param[in] cu_pos_y : cu position wrt to CTB

* \param[in] mode_bits_cost : pointer to mode bits buffer

* \param[in] lambda : Lambda value (SAD/SATD)

* \param[in] cand_mode_list  : pointer to candidate list buffer

*

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void ihevce_intra_populate_mode_bits_cost_bracketing(

    WORD32 top_intra_mode,

    WORD32 left_intra_mode,

    WORD32 available_top,

    WORD32 available_left,

    WORD32 cu_pos_y,

    UWORD16 *mode_bits_cost,

    UWORD16 *mode_bits,

    WORD32 lambda,

    WORD32 *cand_mode_list)

{

    /* local variables */

    WORD32 i;

    WORD32 cand_intra_pred_mode_left, cand_intra_pred_mode_top;

    UWORD16 one_bits_cost =

        COMPUTE_RATE_COST_CLIP30(4, lambda, (LAMBDA_Q_SHIFT + 1));  //1.5 * lambda

    UWORD16 two_bits_cost =

        COMPUTE_RATE_COST_CLIP30(6, lambda, (LAMBDA_Q_SHIFT + 1));  //2.5 * lambda

    UWORD16 five_bits_cost =

        COMPUTE_RATE_COST_CLIP30(12, lambda, (LAMBDA_Q_SHIFT + 1));  //5.5 * lambda

    for(i = 0; i < 35; i++)

    {

        mode_bits_cost[i] = five_bits_cost;

        mode_bits[i] = 5;

    }

    /* EIID: set availability flag to zero if modes are invalid.

       Required since some CU's might be skipped (though available)

       and their modes will be set to 255 (-1)*/

    if(35 < top_intra_mode || 0 > top_intra_mode)

        available_top = 0;

    if(35 < left_intra_mode || 0 > left_intra_mode)

        available_left = 0;

    /* Calculate cand_intra_pred_mode_N as per sec. 8.4.2 in JCTVC-J1003_d7 */

    /* N = top */

    if(0 == available_top)

    {

        cand_intra_pred_mode_top = INTRA_DC;

    }

    /* for neighbour != INTRA, setting DC is done outside */

    else if(0 == cu_pos_y) /* It's on the CTB boundary */

    {

        cand_intra_pred_mode_top = INTRA_DC;

    }

    else

    {

        cand_intra_pred_mode_top = top_intra_mode;

    }

    /* N = left */

    if(0 == available_left)

    {

        cand_intra_pred_mode_left = INTRA_DC;

        //cand_intra_pred_mode_left = cand_intra_pred_mode_top;

    }

    /* for neighbour != INTRA, setting DC is done outside */

    else

    {

        cand_intra_pred_mode_left = left_intra_mode;

    }

    /* Calculate cand_mode_list as per sec. 8.4.2 in JCTVC-J1003_d7 */

    if(cand_intra_pred_mode_left == cand_intra_pred_mode_top)

    {

        if(cand_intra_pred_mode_left < 2)

        {

            cand_mode_list[0] = INTRA_PLANAR;

            cand_mode_list[1] = INTRA_DC;

            cand_mode_list[2] = INTRA_ANGULAR(26); /* angular 26 = Vertical */

        }

        else

        {

            cand_mode_list[0] = cand_intra_pred_mode_left;

            cand_mode_list[1] = 2 + ((cand_intra_pred_mode_left + 29) % 32);

            cand_mode_list[2] = 2 + ((cand_intra_pred_mode_left - 2 + 1) % 32);

        }

    }

    else

    {

        if(0 == available_left)

        {

            cand_mode_list[0] = cand_intra_pred_mode_top;

            cand_mode_list[1] = cand_intra_pred_mode_left;

        }

        else

        {

            cand_mode_list[0] = cand_intra_pred_mode_left;

            cand_mode_list[1] = cand_intra_pred_mode_top;

        }

        if((cand_intra_pred_mode_left != INTRA_PLANAR) &&

           (cand_intra_pred_mode_top != INTRA_PLANAR))

        {

            cand_mode_list[2] = INTRA_PLANAR;

        }

        else if((cand_intra_pred_mode_left != INTRA_DC) && (cand_intra_pred_mode_top != INTRA_DC))

        {

            cand_mode_list[2] = INTRA_DC;

        }

        else

        {

            cand_mode_list[2] = INTRA_ANGULAR(26);

        }

    }

    mode_bits_cost[cand_mode_list[0]] = one_bits_cost;

    mode_bits_cost[cand_mode_list[1]] = two_bits_cost;

    mode_bits_cost[cand_mode_list[2]] = two_bits_cost;

    mode_bits[cand_mode_list[0]] = 2;

    mode_bits[cand_mode_list[1]] = 3;

    mode_bits[cand_mode_list[2]] = 3;

}

/*!

******************************************************************************

* \if Function name : ihevce_pu_calc_4x4_blk \endif

*

* \brief

*    4x4 pu (8x8 CU) mode decision using step 8421 method

*

* \param[in] ps_cu_node : pointer to cu node info buffer

* \param[in] pu1_src : pointer to src pixels

* \param[in] src_stride : frm source stride

* \param[in] ref : pointer to reference pixels for prediction

* \param[in] cand_mode_list  : pointer to candidate list buffer

* \param[in] best_costs_4x4  : pointer to 3 best cost buffer

* \param[in] best_modes_4x4  : pointer to 3 best mode buffer

*

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void ihevce_pu_calc_4x4_blk(

    ihevce_ipe_ctxt_t *ps_ctxt,

    ihevce_ipe_cu_tree_t *ps_cu_node,

    UWORD8 *pu1_src,

    WORD32 src_stride,

    UWORD8 *ref,

    UWORD16 *mode_bits_cost,

    WORD32 *best_costs_4x4,

    UWORD8 *best_modes_4x4,

    func_selector_t *ps_func_selector)

{

    WORD16 *pi2_trans_tmp = ps_ctxt->pi2_trans_tmp;

    WORD16 *pi2_trans_out = ps_ctxt->pi2_trans_out;

    UWORD8 u1_use_satd = ps_ctxt->u1_use_satd;

    UWORD8 u1_level_1_refine_on = ps_ctxt->u1_level_1_refine_on;

    WORD32 i, j = 0, i_end;

    UWORD8 mode, best_amode = 255;

    UWORD8 pred[16];

    UWORD16 sad;

    WORD32 sad_cost = 0;

    WORD32 best_asad_cost = 0xFFFFF;

    WORD32 temp;

    UWORD8 modes_to_eval[5];

    WORD32 costs_4x4[5];

    UWORD8 modes_4x4[5] = { 0, 1, 2, 3, 4 };

    /* LO resolution hence low resolution disable */

    WORD32 u1_low_resol = 0;

    UWORD8 au1_best_modes[1] = { 0 };

    WORD32 ai4_best_sad_costs[1] = { 0 };

    WORD16 *pi2_tmp = &pi2_trans_tmp[0];

    ihevce_ipe_optimised_function_list_t *ps_ipe_optimised_function_list =

        &ps_ctxt->s_ipe_optimised_function_list;

    //apf_resd_trns[0] = &ihevc_resi_trans_4x4_ttype1;

    //apf_resd_trns[0] = &ihevc_HAD_4x4_8bit;

    for(i = 0; i < 5; i++)

    {

        costs_4x4[i] = MAX_INTRA_COST_IPE;

    }

    ps_ipe_optimised_function_list->pf_ed_4x4_find_best_modes(

        pu1_src,

        src_stride,

        ref,

        mode_bits_cost,

        au1_best_modes,

        ai4_best_sad_costs,

        u1_low_resol,

        ps_ipe_optimised_function_list->pf_4x4_sad_computer);

    best_amode = au1_best_modes[0];

    best_asad_cost = ai4_best_sad_costs[0];

    ASSERT(best_amode != 255);

    /* Around best level 4 angular mode, search for best level 2 mode */

    modes_to_eval[0] = best_amode - 2;

    modes_to_eval[1] = best_amode + 2;

    i = 0;

    i_end = 2;

    if(best_amode == 2)

        i = 1;

    else if(best_amode == 34)

        i_end = 1;

    for(; i < i_end; i++)

    {

        mode = modes_to_eval[i];

        g_apf_lum_ip[g_i4_ip_funcs[mode]](&ref[0], 0, &pred[0], 4, 4, mode);

        sad = ps_ipe_optimised_function_list->pf_4x4_sad_computer(pu1_src, &pred[0], src_stride, 4);

        sad_cost = sad;

        sad_cost += mode_bits_cost[mode];

        if(sad_cost < best_asad_cost)

        {

            best_amode = mode;

            best_asad_cost = sad_cost;

        }

    }

    /* Around best level 2 angular mode, search for best level 1 mode */

    /* Also evaluate for non-angular mode */

    i = 0;

    /*Level 1 refinement is disabled for ES preset */

    if(1 == u1_level_1_refine_on)

    {

        if(best_amode != 2)

            modes_to_eval[i++] = best_amode - 1;

        modes_to_eval[i++] = best_amode;

    }

    modes_to_eval[i++] = 0;

    modes_to_eval[i++] = 1;

    if(1 == u1_level_1_refine_on)

    {

        if(best_amode != 34)

            modes_to_eval[i++] = best_amode + 1;

    }

    i_end = i;

    i = 0;

    for(; i < i_end; i++)

    {

        mode = modes_to_eval[i];

        g_apf_lum_ip[g_i4_ip_funcs[mode]](&ref[0], 0, &pred[0], 4, 4, mode);

        /* Hard coding to use SATD */

        if(u1_use_satd)

        {

            ps_func_selector->ihevc_resi_trans_4x4_ttype1_fptr(

                pu1_src, &pred[0], (WORD32 *)pi2_tmp, pi2_trans_out, src_stride, 4, 4, NULL_PLANE);

            sad = ihevce_ipe_pass_satd(pi2_trans_out, 4, 4);

        }

        else

        {

            sad = ps_ipe_optimised_function_list->pf_4x4_sad_computer(

                pu1_src, &pred[0], src_stride, 4);

        }

        sad_cost = sad;

        sad_cost += mode_bits_cost[mode];

        costs_4x4[i] = sad_cost;

    }

    /* Arrange the reference array in ascending order */

    for(i = 0; i < (i_end - 1); i++)

    {

        for(j = i + 1; j < i_end; j++)

        {

            if(costs_4x4[i] > costs_4x4[j])

            {

                temp = costs_4x4[i];

                costs_4x4[i] = costs_4x4[j];

                costs_4x4[j] = temp;

                temp = modes_4x4[i];

                modes_4x4[i] = modes_4x4[j];

                modes_4x4[j] = temp;

            }

        }

    }

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

    {

        best_costs_4x4[i] = costs_4x4[i];

        best_modes_4x4[i] = modes_to_eval[modes_4x4[i]];

    }

    {

        ps_cu_node->best_mode = best_modes_4x4[0];

        ps_cu_node->best_cost = best_costs_4x4[0];

        ps_cu_node->best_satd = best_costs_4x4[0] - mode_bits_cost[ps_cu_node->best_mode];

    }

}

/*!

******************************************************************************

* \if Function name : ihevce_pu_calc_8x8_blk \endif

*

* \brief

*    4x4 pu (8x8 CU) mode decision loop using step 8421 method

*

* \param[in] ps_curr_src : pointer to src pixels struct

* \param[in] ps_ctxt : pointer to IPE context struct

* \param[in] ps_cu_node : pointer to cu node info buffer

*

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void ihevce_pu_calc_8x8_blk(

    iv_enc_yuv_buf_t *ps_curr_src,

    ihevce_ipe_ctxt_t *ps_ctxt,

    ihevce_ipe_cu_tree_t *ps_cu_node,

    func_selector_t *ps_func_selector)

{

    WORD32 i, j;

    WORD32 nbr_flags;

    nbr_avail_flags_t s_nbr;

    WORD32 trans_size = ps_cu_node->ps_parent->u1_cu_size >> 1;

    UWORD8 *pu1_src_4x4;

    WORD32 xA, xB, yA, yB;

    //WORD32 x, y, size;

    WORD32 top_intra_mode;

    WORD32 left_intra_mode;

    //    WORD8 *top_intra_mode_ptr;

    //  WORD8 *left_intra_mode_ptr;

    UWORD8 *pu1_orig;

    WORD32 src_strd = ps_curr_src->i4_y_strd;

    WORD32 cu_pos_x = ps_cu_node->ps_parent->u2_x0 << 1;

    WORD32 cu_pos_y = ps_cu_node->ps_parent->u2_y0 << 1;

    ihevc_intra_pred_luma_ref_substitution_ft *ihevc_intra_pred_luma_ref_substitution_fptr;

    ihevc_intra_pred_luma_ref_substitution_fptr =

        ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_ref_substitution_fptr;

    pu1_orig = (UWORD8 *)(ps_curr_src->pv_y_buf) +

               ((ps_cu_node->ps_parent->u2_y0 << 3) * src_strd) +

               (ps_cu_node->ps_parent->u2_x0 << 3);

    for(i = 0; i < 2; i++)

    {

        for(j = 0; j < 2; j++)

        {

            WORD32 cand_mode_list[3];

            pu1_src_4x4 = pu1_orig + (i * trans_size * src_strd) + (j * trans_size);

            /* get the neighbour availability flags */

            nbr_flags = ihevce_get_nbr_intra(

                &s_nbr,

                ps_ctxt->pu1_ctb_nbr_map,

                ps_ctxt->i4_nbr_map_strd,

                cu_pos_x + ((j) * (trans_size >> 2)),

                cu_pos_y + ((i) * (trans_size >> 2)),

                trans_size >> 2);

            /* call the function which populates sad cost for all the modes */

            xA = ((ps_cu_node->ps_parent->u2_x0 << 3) >> 2) + j;

            yA = ((ps_cu_node->ps_parent->u2_y0 << 3) >> 2) + 1 + i;

            xB = xA + 1;

            yB = yA - 1;

            left_intra_mode = ps_ctxt->au1_ctb_mode_map[yA][xA];

            top_intra_mode = ps_ctxt->au1_ctb_mode_map[yB][xB];

            ihevce_intra_populate_mode_bits_cost_bracketing(

                top_intra_mode,

                left_intra_mode,

                s_nbr.u1_top_avail,

                s_nbr.u1_left_avail,

                ps_cu_node->ps_parent->u2_y0,

                &ps_ctxt->au2_mode_bits_cost_8x8pu[i * 2 + j][0],

                &ps_ctxt->au2_mode_bits_8x8_pu[0],

                ps_ctxt->i4_ol_sad_lambda,

                cand_mode_list);

            /* call the function which populates ref data for intra predicion */

            ihevc_intra_pred_luma_ref_substitution_fptr(

                pu1_src_4x4 - src_strd - 1,

                pu1_src_4x4 - src_strd,

                pu1_src_4x4 - 1,

                src_strd,

                4,

                nbr_flags,

                &ps_ctxt->au1_ref_8x8pu[i * 2 + j][0],

                0);

            ihevce_pu_calc_4x4_blk(

                ps_ctxt,

                ps_cu_node->ps_sub_cu[(i * 2) + j],

                pu1_src_4x4,

                src_strd,

                &ps_ctxt->au1_ref_8x8pu[i * 2 + j][0],

                &ps_ctxt->au2_mode_bits_cost_8x8pu[i * 2 + j][0],

                &ps_cu_node->ps_sub_cu[(i * 2) + j]->au4_best_cost_1tu[0],

                &ps_cu_node->ps_sub_cu[(i * 2) + j]->au1_best_mode_1tu[0],

                ps_func_selector);

            /*&au4_cost_4x4[i*2 + j][0],

                &au1_modes_4x4[i*2 + j][0]);*/ //TTODO : mode will change for the four partition

            ihevce_set_nbr_map(

                ps_ctxt->pu1_ctb_nbr_map,

                ps_ctxt->i4_nbr_map_strd,

                cu_pos_x + ((j) * (trans_size >> 2)),

                cu_pos_y + ((i) * (trans_size >> 2)),

                (trans_size >> 2),

                1);

            xA = ((ps_cu_node->ps_parent->u2_x0 << 3) >> 2) + 1 + j;

            yA = ((ps_cu_node->ps_parent->u2_y0 << 3) >> 2) + 1 + i;

            ps_ctxt->au1_ctb_mode_map[yA][xA] = ps_cu_node->ps_sub_cu[i * 2 + j]->best_mode;

            ps_cu_node->ps_sub_cu[i * 2 + j]->u2_mode_bits_cost =

                ps_ctxt->au2_mode_bits_8x8_pu[ps_cu_node->ps_sub_cu[i * 2 + j]->best_mode];

        }

    }

}

/*!

******************************************************************************

* \if Function name : ihevce_bracketing_analysis \endif

*

* \brief

*    Interface function that evaluates MAX cu and MAX - 1 cu, with MAX cu size

*    info decided coarse resolution mode decision. Compares the SATD/SAD cost btwn

*    2 CUS and determines the actual CU size and best 3 modes to be given to rdopt

*

* \param[in] ps_ctxt : pointer to IPE context struct

* \param[in] ps_cu_node : pointer to cu node info buffer

* \param[in] ps_curr_src : pointer to src pixels struct

* \param[in] ps_ctb_out : pointer to ip ctb out struct

* \param[in] ps_row_cu : pointer to cu analyse struct

* \param[in] ps_ed_l1_ctb : pointer to level 1 early deci struct

* \param[in] ps_ed_l2_ctb : pointer to level 2 early deci struct

* \param[in] ps_l0_ipe_out_ctb : pointer to ipe_l0_ctb_analyse_for_me_t struct

*

* \return

*    None

*

* \author

*  Ittiam

*

*****************************************************************************

*/

void ihevce_bracketing_analysis(

    ihevce_ipe_ctxt_t *ps_ctxt,

    ihevce_ipe_cu_tree_t *ps_cu_node,

    iv_enc_yuv_buf_t *ps_curr_src,

    ctb_analyse_t *ps_ctb_out,

    //cu_analyse_t         *ps_row_cu,

    ihevce_ed_blk_t *ps_ed_l1_ctb,

    ihevce_ed_blk_t *ps_ed_l2_ctb,

    ihevce_ed_ctb_l1_t *ps_ed_ctb_l1,

    ipe_l0_ctb_analyse_for_me_t *ps_l0_ipe_out_ctb)

{

    WORD32 cu_pos_x = 0;

    WORD32 cu_pos_y = 0;

    UWORD8 u1_curr_ctb_wdt = ps_cu_node->u1_width;

    UWORD8 u1_curr_ctb_hgt = ps_cu_node->u1_height;

    WORD32 num_8x8_blks_x = (u1_curr_ctb_wdt >> 3);

    WORD32 num_8x8_blks_y = (u1_curr_ctb_hgt >> 3);

    ihevce_ed_blk_t *ps_ed_blk_l1 = ps_ed_l1_ctb;

    ihevce_ed_blk_t *ps_ed_blk_l2 = ps_ed_l2_ctb;

    WORD32 i;

    WORD32 cand_mode_list[3];

    //cu_analyse_t *ps_curr_cu = ps_row_cu;

    WORD32 blk_cnt = 0;

    WORD32 j = 0;

    WORD32 merge_32x32_l1, merge_32x32_l2;

    WORD32 i4_skip_intra_eval_32x32_l1;

    //EIID: flag indicating number of 16x16 blocks to be skipped for intra evaluation within 32x32 block

    WORD32 parent_cost = 0;

    WORD32 child_cost[4] = { 0 };

    WORD32 child_cost_least = 0;

    WORD32 child_satd[4] = { 0 };

    WORD32 x, y, size;

    WORD32 merge_64x64 = 1;

    UWORD8 au1_best_32x32_modes[4];

    WORD32 au4_best_32x32_cost[4];

    WORD32 parent_best_mode;

    UWORD8 best_mode;

    WORD32 i4_quality_preset = ps_ctxt->i4_quality_preset;

    /* flag to control 1CU-4TU modes based on quality preset                */

    /* if set 1CU-4TU are explicity evaluated else 1CU-1TU modes are copied */

    WORD32 i4_enable_1cu_4tu = (i4_quality_preset == IHEVCE_QUALITY_P2) ||

                               (i4_quality_preset == IHEVCE_QUALITY_P0);

    /* flag to control 4CU-16TU mode based on quality preset                */

    /* if set 4CU-16TU are explicity evaluated else 4CU-4TU modes are copied*/

    WORD32 i4_enable_4cu_16tu = (i4_quality_preset == IHEVCE_QUALITY_P2) ||

                                (i4_quality_preset == IHEVCE_QUALITY_P0);

    WORD32 i4_mod_factor_num, i4_mod_factor_den = QP_MOD_FACTOR_DEN;  //2;

    float f_strength;

    /* Accumalte satd */

    LWORD64 i8_frame_acc_satd_cost = 0, i8_frame_acc_satd_by_modqp_q10 = 0;

    WORD32 i4_ctb_acc_satd = 0;

    /* Accumalate Mode bits cost */

    LWORD64 i8_frame_acc_mode_bits_cost = 0;

    /* Step2 is bypassed for parent, uses children modes*/

    WORD32 step2_bypass = 1;

    if(1 == ps_ctxt->u1_disable_child_cu_decide)

        step2_bypass = 0;

    ps_cu_node->ps_parent = ps_ctxt->ps_ipe_cu_tree;

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

    {

        ps_cu_node->ps_sub_cu[i] = ps_ctxt->ps_ipe_cu_tree + 1 + i;

    }

    /* Loop for all 8x8 block in a CTB */

    ps_ctb_out->u4_cu_split_flags = 0x1;

    /* Initialize intra 64x64, 32x32 and 16x16 costs to max value */

    for(i = 0; i < (MAX_CU_IN_CTB >> 4); i++)

    {

        ps_l0_ipe_out_ctb->ai4_best32x32_intra_cost[i] = MAX_INTRA_COST_IPE;

    }

    for(i = 0; i < (MAX_CU_IN_CTB >> 2); i++)

    {

        ps_l0_ipe_out_ctb->ai4_best16x16_intra_cost[i] = MAX_INTRA_COST_IPE;

    }

    for(i = 0; i < (MAX_CU_IN_CTB); i++)

    {

        ps_l0_ipe_out_ctb->ai4_best8x8_intra_cost[i] = MAX_INTRA_COST_IPE;

    }

    ps_l0_ipe_out_ctb->i4_best64x64_intra_cost = MAX_INTRA_COST_IPE;

    /* by default 64x64 modes are set to default values DC and Planar */

    ps_l0_ipe_out_ctb->au1_best_modes_32x32_tu[0] = 0;

    ps_l0_ipe_out_ctb->au1_best_modes_32x32_tu[1] = 1;

    ps_l0_ipe_out_ctb->au1_best_modes_32x32_tu[2] = 255;

    /* by default 64x4 split is set to 1 */

    ps_l0_ipe_out_ctb->u1_split_flag = 1;

    /* Modulation factor calculated based on spatial variance instead of hardcoded val*/

    i4_mod_factor_num = ps_ctxt->ai4_mod_factor_derived_by_variance[1];  //16;

    f_strength = ps_ctxt->f_strength;

    /* ------------------------------------------------ */

    /* populate the early decisions done by L1 analysis */

    /* ------------------------------------------------ */

    for(i = 0; i < (MAX_CU_IN_CTB >> 2); i++)

    {

        ps_l0_ipe_out_ctb->ai4_best_sad_8x8_l1_ipe[i] = ps_ed_ctb_l1->i4_best_sad_8x8_l1_ipe[i];

        ps_l0_ipe_out_ctb->ai4_best_sad_cost_8x8_l1_ipe[i] = ps_ed_ctb_l1->i4_best_sad_cost_8x8_l1_ipe[i];

        ps_l0_ipe_out_ctb->ai4_best_sad_8x8_l1_me[i] = ps_ed_ctb_l1->i4_best_sad_8x8_l1_me[i];

        ps_l0_ipe_out_ctb->ai4_best_sad_cost_8x8_l1_me[i] = ps_ed_ctb_l1->i4_best_sad_cost_8x8_l1_me[i];

    }

    /* Init CTB level accumalated SATD and MPM bits */

    ps_l0_ipe_out_ctb->i4_ctb_acc_satd = 0;

    ps_l0_ipe_out_ctb->i4_ctb_acc_mpm_bits = 0;

    /* ------------------------------------------------ */

    /* Loop over all the blocks in current CTB          */

    /* ------------------------------------------------ */

    {

        /* 64 8x8 blocks should be encountered for the do,while loop to exit */

        do

        {

            intra32_analyse_t *ps_intra32_analyse;

            intra16_analyse_t *ps_intra16_analyse;

            WORD32 *pi4_intra_32_cost;

            WORD32 *pi4_intra_16_cost;

            WORD32 *pi4_intra_8_cost;

            WORD32 merge_16x16_l1;

            /* Given the blk_cnt, get the CU's top-left 8x8 block's x and y positions within the CTB */

            cu_pos_x = gau1_cu_pos_x[blk_cnt];

            cu_pos_y = gau1_cu_pos_y[blk_cnt];

            /* default value for 32x32 best mode - blk_cnt increases by 16 for each 32x32 */

            au1_best_32x32_modes[blk_cnt >> 4] = 255;

            /* get the corresponding intra 32 analyse pointer  use (blk_cnt / 16) */

            /* blk cnt is in terms of 8x8 units so a 32x32 will have 16 8x8 units */

            ps_intra32_analyse = &ps_l0_ipe_out_ctb->as_intra32_analyse[blk_cnt >> 4];

            /* get the corresponding intra 16 analyse pointer use (blk_cnt & 0xF / 4)*/

            /* blk cnt is in terms of 8x8 units so a 16x16 will have 4 8x8 units */

            ps_intra16_analyse = &ps_intra32_analyse->as_intra16_analyse[(blk_cnt & 0xF) >> 2];

            /* Line below assumes min_cu_size of 8 - checks whether CU starts are within picture */

            if((cu_pos_x < num_8x8_blks_x) && (cu_pos_y < num_8x8_blks_y))

            {

                /* Reset to zero for every cu decision */

                merge_32x32_l1 = 0;

                child_cost_least = 0;

                /* At L2, each 4x4 corresponds to 16x16 at L0. Every 4 16x16 stores a merge_success flag */

                ps_ed_blk_l2 = ps_ed_l2_ctb + (blk_cnt >> 2);

                pi4_intra_32_cost = &ps_l0_ipe_out_ctb->ai4_best32x32_intra_cost[blk_cnt >> 4];

                /* by default 32x32 modes are set to default values DC and Planar */

                ps_intra32_analyse->au1_best_modes_32x32_tu[0] = 0;

                ps_intra32_analyse->au1_best_modes_32x32_tu[1] = 1;

                ps_intra32_analyse->au1_best_modes_32x32_tu[2] = 255;

                /* By default 32x32 split is set to 1 */

                ps_intra32_analyse->b1_split_flag = 1;

                ps_intra32_analyse->au1_best_modes_16x16_tu[0] = 0;

                ps_intra32_analyse->au1_best_modes_16x16_tu[1] = 1;

                ps_intra32_analyse->au1_best_modes_16x16_tu[2] = 255;

                /* 16x16 cost & 8x8 cost are stored in Raster scan order */

                /* stride of 16x16 buffer is MAX_CU_IN_CTB_ROW >> 1      */

                /* stride of 8x8 buffer is MAX_CU_IN_CTB_ROW             */

                {

                    WORD32 pos_x_8x8, pos_y_8x8;

                    pos_x_8x8 = gau1_cu_pos_x[blk_cnt];

                    pos_y_8x8 = gau1_cu_pos_y[blk_cnt];

                    pi4_intra_16_cost = &ps_l0_ipe_out_ctb->ai4_best16x16_intra_cost[0];

                    pi4_intra_16_cost +=

                        ((pos_x_8x8 >> 1) + ((pos_y_8x8 >> 1) * (MAX_CU_IN_CTB_ROW >> 1)));

                    pi4_intra_8_cost = &ps_l0_ipe_out_ctb->ai4_best8x8_intra_cost[0];

                    pi4_intra_8_cost += (pos_x_8x8 + (pos_y_8x8 * MAX_CU_IN_CTB_ROW));

                }

                merge_32x32_l1 = 0;

                merge_32x32_l2 = 0;

                i4_skip_intra_eval_32x32_l1 = 0;

                /* Enable 16x16 merge iff sufficient 8x8 blocks remain in the current CTB */

                merge_16x16_l1 = 0;

                if(((num_8x8_blks_x - cu_pos_x) >= 2) && ((num_8x8_blks_y - cu_pos_y) >= 2))

                {

#if !ENABLE_UNIFORM_CU_SIZE_8x8

                    merge_16x16_l1 = ps_ed_blk_l1->merge_success;

#else

                    merge_16x16_l1 = 0;

#endif

                }

                /* Enable 32x32 merge iff sufficient 8x8 blocks remain in the current CTB */

                if(((num_8x8_blks_x - cu_pos_x) >= 4) && ((num_8x8_blks_y - cu_pos_y) >= 4))

                {

                    /* Check 4 flags of L1(8x8) say merge */

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

                    {

                        merge_32x32_l1 += (ps_ed_blk_l1 + (i * 4))->merge_success;

                        //EIDD: num 16x16 blocks for which inter_intra flag says eval only inter, i.e. skip intra eval

                        i4_skip_intra_eval_32x32_l1 +=

                            ((ps_ed_blk_l1 + (i * 4))->intra_or_inter == 2) ? 1 : 0;

                    }

#if !ENABLE_UNIFORM_CU_SIZE_8x8

                    /* Check 1 flag from L2(16x16) say merge */

                    merge_32x32_l2 = ps_ed_blk_l2->merge_success;

#else

                    merge_32x32_l1 = 0;

                    merge_32x32_l2 = 0;

#endif

                }

#if DISABLE_L2_IPE_IN_PB_L1_IN_B

                if((i4_quality_preset == IHEVCE_QUALITY_P6) && (ps_ctxt->i4_slice_type != ISLICE))

                {

                    merge_32x32_l2 = 0;

                    ps_ed_blk_l2->merge_success = 0;

                }

#endif

                ps_intra32_analyse->b1_valid_cu = 1;

                /* If Merge success from all 4 L1 and L2, max CU size 32x32 is chosen */

                /* EIID: if all blocks to be skipped then skip entire 32x32 for intra eval,

                if no blocks to be skipped then eval entire 32x32,

                else break the merge and go to 16x16 level eval */

                if((merge_32x32_l1 == 4) && merge_32x32_l2 &&

                   ((i4_skip_intra_eval_32x32_l1 == 0) ||

                    (i4_skip_intra_eval_32x32_l1 == 4))  //comment this line to disable break-merge

                )

                {

#if IP_DBG_L1_l2

                    /* Populate params for 32x32 block analysis */

                    ps_cu_node->ps_parent->best_cost = MAX_INTRA_COST_IPE;

                    ps_cu_node->ps_parent->u1_cu_size = 32;

                    ps_cu_node->ps_parent->u2_x0 = gau1_cu_pos_x[blk_cnt]; /* Populate properly */

                    ps_cu_node->ps_parent->u2_y0 = gau1_cu_pos_y[blk_cnt]; /* Populate properly */

                    ps_cu_node->ps_parent->best_mode = ps_ed_blk_l2->best_merge_mode;

                    /* CU size 32x32 and fill the final cu params */

                    ihevce_update_cand_list(ps_cu_node->ps_parent, ps_ed_blk_l1, ps_ctxt);

                    /* Increment pointers */

                    ps_ed_blk_l1 += 16;

                    blk_cnt += 16;

                    ps_row_cu++;

                    merge_64x64 &= 1;

#else

                    /* EIID: dont evaluate if all 4 blocks at L1 said inter is winning*/

                    if(4 == i4_skip_intra_eval_32x32_l1 && (ps_ctxt->i4_slice_type != ISLICE))

                    {

                        WORD32 i4_local_ctr1, i4_local_ctr2;

                        ps_cu_node->ps_parent->best_cost = MAX_INTRA_COST_IPE;

                        ps_cu_node->ps_parent->u1_cu_size = 32;

                        ps_cu_node->ps_parent->u2_x0 =

                            gau1_cu_pos_x[blk_cnt]; /* Populate properly */

                        ps_cu_node->ps_parent->u2_y0 =

                            gau1_cu_pos_y[blk_cnt]; /* Populate properly */

                        ps_cu_node->ps_parent->best_mode =

                            INTRA_DC;  //ps_ed_blk_l2->best_merge_mode;

                        /* CU size 32x32 and fill the final cu params */

                        /* fill in the first modes as invalid */

                        ps_cu_node->ps_parent->au1_best_mode_1tu[0] = INTRA_DC;

                        ps_cu_node->ps_parent->au1_best_mode_1tu[1] =

                            INTRA_DC;  //for safery. Since update_cand_list will set num_modes as 3

                        ps_cu_node->ps_parent->au1_best_mode_1tu[2] = INTRA_DC;

                        ps_cu_node->ps_parent->au1_best_mode_4tu[0] = INTRA_DC;

                        ps_cu_node->ps_parent->au1_best_mode_4tu[1] = INTRA_DC;

                        ps_cu_node->ps_parent->au1_best_mode_4tu[2] = INTRA_DC;

                        ihevce_update_cand_list(ps_cu_node->ps_parent, ps_ed_blk_l1, ps_ctxt);

                        //ps_row_cu->s_cu_intra_cand.b6_num_intra_cands = 0;

                        //ps_row_cu->u1_num_intra_rdopt_cands = 0;

                        ps_intra32_analyse->b1_valid_cu = 0;

                        ps_intra32_analyse->b1_split_flag = 0;

                        ps_intra32_analyse->b1_merge_flag = 0;

                        /*memset (&ps_intra32_analyse->au1_best_modes_32x32_tu,

                        255,

                        NUM_BEST_MODES);

                        memset (&ps_intra32_analyse->au1_best_modes_16x16_tu,

                        255,

                        NUM_BEST_MODES);*/

                        //set only first mode since if it's 255. it wont go ahead

                        ps_intra32_analyse->au1_best_modes_32x32_tu[0] = 255;

                        ps_intra32_analyse->au1_best_modes_16x16_tu[0] = 255;

                        *pi4_intra_32_cost = MAX_INTRA_COST_IPE;

                        /*since ME will start evaluating from bottom up, set the lower

                        cu size data invalid */

                        for(i4_local_ctr1 = 0; i4_local_ctr1 < 4; i4_local_ctr1++)

                        {

                            WORD32 *pi4_intra_8_cost_curr16;

                            ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                .au1_best_modes_16x16_tu[0] = 255;

                            ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                .au1_best_modes_8x8_tu[0] = 255;

                            ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1].b1_merge_flag = 0;

                            ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1].b1_valid_cu = 0;

                            ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1].b1_split_flag = 0;

                            pi4_intra_16_cost

                                [(i4_local_ctr1 & 1) + ((MAX_CU_IN_CTB_ROW >> 1) *

                                                        (i4_local_ctr1 >> 1))] = MAX_INTRA_COST_IPE;

                            pi4_intra_8_cost_curr16 = pi4_intra_8_cost + ((i4_local_ctr1 & 1) << 1);

                            pi4_intra_8_cost_curr16 +=

                                ((i4_local_ctr1 >> 1) << 1) * MAX_CU_IN_CTB_ROW;

                            for(i4_local_ctr2 = 0; i4_local_ctr2 < 4; i4_local_ctr2++)

                            {

                                ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                    .as_intra8_analyse[i4_local_ctr2]

                                    .au1_4x4_best_modes[0][0] = 255;

                                ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                    .as_intra8_analyse[i4_local_ctr2]

                                    .au1_4x4_best_modes[1][0] = 255;

                                ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                    .as_intra8_analyse[i4_local_ctr2]

                                    .au1_4x4_best_modes[2][0] = 255;

                                ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                    .as_intra8_analyse[i4_local_ctr2]

                                    .au1_4x4_best_modes[3][0] = 255;

                                ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                    .as_intra8_analyse[i4_local_ctr2]

                                    .au1_best_modes_8x8_tu[0] = 255;

                                ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                    .as_intra8_analyse[i4_local_ctr2]

                                    .au1_best_modes_4x4_tu[0] = 255;

                                ps_intra32_analyse->as_intra16_analyse[i4_local_ctr1]

                                    .as_intra8_analyse[i4_local_ctr2]

                                    .b1_valid_cu = 0;

                                pi4_intra_8_cost_curr16

                                    [(i4_local_ctr2 & 1) +

                                     (MAX_CU_IN_CTB_ROW * (i4_local_ctr2 >> 1))] =

                                        MAX_INTRA_COST_IPE;

                            }

                        }

                        /* set neighbours even if intra is not evaluated, since source is always available. */

                        ihevce_set_nbr_map(

                            ps_ctxt->pu1_ctb_nbr_map,

                            ps_ctxt->i4_nbr_map_strd,

                            ps_cu_node->ps_parent->u2_x0 << 1,

                            ps_cu_node->ps_parent->u2_y0 << 1,

                            (ps_cu_node->ps_parent->u1_cu_size >> 2),

                            1);

                        /* cost accumalation of best cu size candiate */

                        /*i8_frame_acc_satd_cost += parent_cost;*/

                        /* Mode bits cost accumalation for best cu size and cu mode */

                        /*i8_frame_acc_mode_bits_cost += ps_cu_node->ps_parent->u2_mode_bits_cost;*/

                        /*satd/mod_qp accumulation of best cu */

                        /*i8_frame_acc_satd_by_modqp_q10 += ((LWORD64)ps_cu_node->ps_parent->best_satd << (SATD_BY_ACT_Q_FAC + QSCALE_Q_FAC_3))/i4_q_scale_q3_mod;*/

                        /* Increment pointers */

                        ps_ed_blk_l1 += 16;

                        blk_cnt += 16;

                        //ps_row_cu++;

                        merge_64x64 = 0;

                        /* increment for stat purpose only. Increment is valid only on single thread */

                        ps_ctxt->u4_num_16x16_skips_at_L0_IPE += 4;

                    }

                    else

                    {

                        /* Revaluation of 4 16x16 blocks at 8x8 prediction level */

                        //memcpy(ps_ctxt->ai1_ctb_mode_map_temp, ps_ctxt->ai1_ctb_mode_map, sizeof(ps_ctxt->ai1_ctb_mode_map));

                        if((ps_ctxt->i4_quality_preset == IHEVCE_QUALITY_P6) &&

                           (ps_ctxt->i4_slice_type == PSLICE))

                        {

                            ps_ctxt->u1_disable_child_cu_decide = 1;

                            step2_bypass = 0;

                        }

                        /* Based on the flag, Child modes decision can be disabled*/

                        if(0 == ps_ctxt->u1_disable_child_cu_decide)