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

 *

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

*

* \brief

*    This file contains Encoder normative loop pass related functions

*

* \date

*    18/09/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_macros.h"

#include "ihevc_debug.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_hle_interface.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_multi_thrd_funcs.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_ipe_instr_set_router.h"

#include "ihevce_decomp_pre_intra_structs.h"

#include "ihevce_decomp_pre_intra_pass.h"

#include "ihevce_enc_loop_structs.h"

#include "ihevce_global_tables.h"

#include "ihevce_nbr_avail.h"

#include "ihevce_enc_loop_utils.h"

#include "ihevce_bs_compute_ctb.h"

#include "ihevce_cabac_rdo.h"

#include "ihevce_dep_mngr_interface.h"

#include "ihevce_enc_loop_pass.h"

#include "ihevce_rc_enc_structs.h"

#include "ihevce_enc_cu_recursion.h"

#include "ihevce_stasino_helpers.h"

#include "cast_types.h"

#include "osal.h"

#include "osal_defaults.h"

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

/* Macros                                                                    */

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

#define NUM_CTB_QUANT_ROUNDING 6

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

/* Function Definitions                                                      */

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

/**

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

* Function name : ihevce_store_cu_final

*

* \brief

*    This function store cu info to the enc loop cu context

*

* \param[in] ps_ctxt : pointer to enc loop context structure

* \param[in] ps_cu_final  : pointer to enc loop output CU structure

* \param[in] pu1_ecd_data : ecd data pointer

* \param[in] ps_enc_out_ctxt : pointer to CU information structure

* \param[in] ps_cu_prms : pointer to  cu level parameters for SATD / RDOPT

*

* \return

*    None

*

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

void ihevce_store_cu_final(

    ihevce_enc_loop_ctxt_t *ps_ctxt,

    cu_enc_loop_out_t *ps_cu_final,

    UWORD8 *pu1_ecd_data,

    ihevce_enc_cu_node_ctxt_t *ps_enc_out_ctxt,

    enc_loop_cu_prms_t *ps_cu_prms)

{

    enc_loop_cu_final_prms_t *ps_enc_loop_bestprms;

    WORD32 i4_8x8_blks_in_cu;

    WORD32 i4_br_id, i4_enc_frm_id;

    WORD32 u4_tex_bits, u4_hdr_bits;

    WORD32 i4_qscale, i4_qscale_ctb;

    ps_enc_loop_bestprms = ps_enc_out_ctxt->ps_cu_prms;

    i4_qscale = ((ps_ctxt->ps_rc_quant_ctxt->pi4_qp_to_qscale

                      [ps_enc_out_ctxt->i1_cu_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset]));

    i4_qscale_ctb = ((

        ps_ctxt->ps_rc_quant_ctxt

            ->pi4_qp_to_qscale[ps_ctxt->i4_frame_mod_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset]));

    /* All texture bits accumulated */

    u4_tex_bits = ps_enc_loop_bestprms->u4_cu_luma_res_bits +

                  ps_enc_loop_bestprms->u4_cu_chroma_res_bits +

                  ps_enc_loop_bestprms->u4_cu_cbf_bits;

    u4_hdr_bits = ps_enc_loop_bestprms->u4_cu_hdr_bits;

    i4_br_id = ps_ctxt->i4_bitrate_instance_num;

    i4_enc_frm_id = ps_ctxt->i4_enc_frm_id;

    i4_8x8_blks_in_cu = ((ps_enc_out_ctxt->u1_cu_size >> 3) * (ps_enc_out_ctxt->u1_cu_size >> 3));

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->i8_frame_open_loop_ssd +=

        ps_enc_loop_bestprms

            ->i8_cu_ssd;  // + (((float)(ps_ctxt->i8_cl_ssd_lambda_qf/ (1<< LAMBDA_Q_SHIFT))) * ps_enc_loop_bestprms->u4_cu_hdr_bits);

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->u4_frame_open_loop_intra_sad +=

        (UWORD32)(

            ps_enc_loop_bestprms->u4_cu_open_intra_sad +

            (((float)(ps_ctxt->i4_sad_lamda) / (1 << LAMBDA_Q_SHIFT)) *

             ps_enc_loop_bestprms->u4_cu_hdr_bits));

    if(1 == ps_enc_loop_bestprms->u1_intra_flag)

    {

        ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->u4_frame_intra_sad_acc +=

            ps_enc_loop_bestprms->u4_cu_sad;

        ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->i8_frame_intra_cost_acc +=

            ps_enc_loop_bestprms->i8_best_rdopt_cost;

    }

    else

    {

        ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->u4_frame_inter_sad_acc +=

            ps_enc_loop_bestprms->u4_cu_sad;

        ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->i8_frame_inter_cost_acc +=

            ps_enc_loop_bestprms->i8_best_rdopt_cost;

    }

    /*accumulating the frame level stats across frame*/

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->u4_frame_sad_acc +=

        ps_enc_loop_bestprms->u4_cu_sad;

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->i8_frame_cost_acc +=

        ps_enc_loop_bestprms->i8_best_rdopt_cost;

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->u4_frame_rdopt_bits +=

        (u4_tex_bits + u4_hdr_bits);

    /*Total bits and header bits accumalted here for CTB*/

    ps_ctxt->u4_total_cu_bits += (u4_tex_bits + u4_hdr_bits);

    ps_ctxt->u4_total_cu_bits_mul_qs +=

        ((ULWORD64)((u4_tex_bits + u4_hdr_bits) * (i4_qscale_ctb)) + (1 << (QSCALE_Q_FAC_3 - 1))) >>

        QSCALE_Q_FAC_3;

    ps_ctxt->u4_total_cu_hdr_bits += u4_hdr_bits;

    ps_ctxt->u4_cu_tot_bits_into_qscale +=

        ((ULWORD64)((u4_tex_bits + u4_hdr_bits) * (i4_qscale)) + (1 << (QSCALE_Q_FAC_3 - 1))) >>

        QSCALE_Q_FAC_3;

    ps_ctxt->u4_cu_tot_bits += (u4_tex_bits + u4_hdr_bits);

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]->u4_frame_rdopt_header_bits +=

        u4_hdr_bits;

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]

        ->i8_sad_by_qscale[ps_enc_loop_bestprms->u1_intra_flag] +=

        ((((LWORD64)ps_enc_loop_bestprms->u4_cu_sad) << SAD_BY_QSCALE_Q) / i4_qscale);

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]

        ->i4_qp_normalized_8x8_cu_sum[ps_enc_loop_bestprms->u1_intra_flag] +=

        (i4_8x8_blks_in_cu * i4_qscale);

    ps_ctxt->aaps_enc_loop_rc_params[i4_enc_frm_id][i4_br_id]

        ->i4_8x8_cu_sum[ps_enc_loop_bestprms->u1_intra_flag] += i4_8x8_blks_in_cu;

    /* PCM not supported */

    ps_cu_final->b1_pcm_flag = 0;

    ps_cu_final->b1_pred_mode_flag = ps_enc_loop_bestprms->u1_intra_flag;

    ps_cu_final->b1_skip_flag = ps_enc_loop_bestprms->u1_skip_flag;

    ps_cu_final->b1_tq_bypass_flag = 0;

    ps_cu_final->b3_part_mode = ps_enc_loop_bestprms->u1_part_mode;

    ps_cu_final->pv_coeff = pu1_ecd_data;

    ps_cu_final->i1_cu_qp = ps_enc_out_ctxt->i1_cu_qp;

    if(ps_enc_loop_bestprms->u1_is_cu_coded)

    {

        ps_ctxt->i4_last_cu_qp_from_prev_ctb = ps_enc_out_ctxt->i1_cu_qp;

    }

    else

    {

        ps_ctxt->i4_last_cu_qp_from_prev_ctb = ps_ctxt->i4_pred_qp;

    }

    ps_cu_final->b1_first_cu_in_qg = ps_enc_out_ctxt->b1_first_cu_in_qg;

    /* Update the no residue flag. Needed for inter cu. */

    /* Needed for deblocking inter/intra both           */

    //if(ps_cu_final->b1_pred_mode_flag == PRED_MODE_INTER)

    {

        ps_cu_final->b1_no_residual_syntax_flag = !ps_enc_loop_bestprms->u1_is_cu_coded;

    }

    /* store the number of TUs */

    ps_cu_final->u2_num_tus_in_cu = ps_enc_loop_bestprms->u2_num_tus_in_cu;

    /* ---- copy the TUs to final structure ----- */

    memcpy(

        ps_cu_final->ps_enc_tu,

        &ps_enc_loop_bestprms->as_tu_enc_loop[0],

        ps_enc_loop_bestprms->u2_num_tus_in_cu * sizeof(tu_enc_loop_out_t));

    /* ---- copy the PUs to final structure ----- */

    memcpy(

        ps_cu_final->ps_pu,

        &ps_enc_loop_bestprms->as_pu_enc_loop[0],

        ps_enc_loop_bestprms->u2_num_pus_in_cu * sizeof(pu_t));

    /* --- copy reminder and prev_flags ----- */

    /* only required for intra */

    if(PRED_MODE_INTRA == ps_cu_final->b1_pred_mode_flag)

    {

        memcpy(

            &ps_cu_final->as_prev_rem[0],

            &ps_enc_loop_bestprms->as_intra_prev_rem[0],

            ps_enc_loop_bestprms->u2_num_tus_in_cu * sizeof(intra_prev_rem_flags_t));

        ps_cu_final->b3_chroma_intra_pred_mode = ps_enc_loop_bestprms->u1_chroma_intra_pred_mode;

    }

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

    /* ---- Boundary Strength Calculation at CU level ---- */

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

    if(ps_ctxt->i4_deblk_pad_hpel_cur_pic)

    {

        WORD32 num_4x4_in_ctb;

        nbr_4x4_t *ps_left_nbr_4x4;

        nbr_4x4_t *ps_top_nbr_4x4;

        nbr_4x4_t *ps_curr_nbr_4x4;

        WORD32 nbr_4x4_left_strd;

        num_4x4_in_ctb = (ps_cu_prms->i4_ctb_size >> 2);

        ps_curr_nbr_4x4 = &ps_ctxt->as_ctb_nbr_arr[0];

        ps_curr_nbr_4x4 += (ps_enc_out_ctxt->b3_cu_pos_x << 1);

        ps_curr_nbr_4x4 += ((ps_enc_out_ctxt->b3_cu_pos_y << 1) * num_4x4_in_ctb);

        /* CU left */

        if(0 == ps_enc_out_ctxt->b3_cu_pos_x)

        {

            ps_left_nbr_4x4 = &ps_ctxt->as_left_col_nbr[0];

            ps_left_nbr_4x4 += ps_enc_out_ctxt->b3_cu_pos_y << 1;

            nbr_4x4_left_strd = 1;

        }

        else

        {

            /* inside CTB */

            ps_left_nbr_4x4 = ps_curr_nbr_4x4 - 1;

            nbr_4x4_left_strd = num_4x4_in_ctb;

        }

        /* CU top */

        if(0 == ps_enc_out_ctxt->b3_cu_pos_y)

        {

            /* CTB boundary */

            ps_top_nbr_4x4 = ps_ctxt->ps_top_row_nbr;

            ps_top_nbr_4x4 += (ps_cu_prms->i4_ctb_pos * (ps_cu_prms->i4_ctb_size >> 2));

            ps_top_nbr_4x4 += (ps_enc_out_ctxt->b3_cu_pos_x << 1);

        }

        else

        {

            /* inside CTB */

            ps_top_nbr_4x4 = ps_curr_nbr_4x4 - num_4x4_in_ctb;

        }

        ihevce_bs_compute_cu(

            ps_cu_final,

            ps_top_nbr_4x4,

            ps_left_nbr_4x4,

            ps_curr_nbr_4x4,

            nbr_4x4_left_strd,

            num_4x4_in_ctb,

            &ps_ctxt->s_deblk_bs_prms);

    }

}

/**

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

* Function name : ihevce_store_cu_results

*

* \brief

*    This function store cu result to cu info context

*

* \param[in] ps_ctxt : pointer to enc loop context structure

* \param[out] ps_cu_prms : pointer to  cu level parameters for SATD / RDOPT

*

* \return

*    None

*

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

void ihevce_store_cu_results(

    ihevce_enc_loop_ctxt_t *ps_ctxt,

    enc_loop_cu_prms_t *ps_cu_prms,

    final_mode_state_t *ps_final_state)

{

    ihevce_enc_cu_node_ctxt_t *ps_enc_tmp_out_ctxt;

    nbr_4x4_t *ps_nbr_4x4, *ps_tmp_nbr_4x4, *ps_curr_nbr_4x4;

    UWORD8 *pu1_recon, *pu1_final_recon;

    WORD32 num_4x4_in_ctb, ctr;

    WORD32 num_4x4_in_cu;

    UWORD8 u1_is_422 = (ps_ctxt->u1_chroma_array_type == 2);

    WORD32 cu_depth, log2_ctb_size, log2_cu_size;

    ps_enc_tmp_out_ctxt = ps_ctxt->ps_enc_out_ctxt;

    (void)ps_final_state;

#if PROCESS_GT_1CTB_VIA_CU_RECUR_IN_FAST_PRESETS

    {

        /* ---- copy the child luma recon back to curr. recon -------- */

        pu1_recon = (UWORD8 *)ps_ctxt->pv_cu_luma_recon;

        /* based on CU position derive the luma pointers */

        pu1_final_recon = ps_cu_prms->pu1_luma_recon + (ps_enc_tmp_out_ctxt->b3_cu_pos_x << 3);

        pu1_final_recon +=

            ((ps_enc_tmp_out_ctxt->b3_cu_pos_y << 3) * ps_cu_prms->i4_luma_recon_stride);

        ps_ctxt->s_cmn_opt_func.pf_copy_2d(

            pu1_final_recon,

            ps_cu_prms->i4_luma_recon_stride,

            pu1_recon,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            ps_enc_tmp_out_ctxt->u1_cu_size);

        /* ---- copy the child chroma recon back to curr. recon -------- */

        pu1_recon = (UWORD8 *)ps_ctxt->pv_cu_chrma_recon;

        /* based on CU position derive the chroma pointers */

        pu1_final_recon = ps_cu_prms->pu1_chrm_recon + (ps_enc_tmp_out_ctxt->b3_cu_pos_x << 3);

        pu1_final_recon +=

            ((ps_enc_tmp_out_ctxt->b3_cu_pos_y << (u1_is_422 + 2)) *

             ps_cu_prms->i4_chrm_recon_stride);

        /* Cb and Cr pixel interleaved */

        ps_ctxt->s_cmn_opt_func.pf_copy_2d(

            pu1_final_recon,

            ps_cu_prms->i4_chrm_recon_stride,

            pu1_recon,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            (ps_enc_tmp_out_ctxt->u1_cu_size >> (0 == u1_is_422)));

    }

#else

    if(ps_ctxt->i4_quality_preset < IHEVCE_QUALITY_P2)

    {

        /* ---- copy the child luma recon back to curr. recon -------- */

        pu1_recon = (UWORD8 *)ps_ctxt->pv_cu_luma_recon;

        /* based on CU position derive the luma pointers */

        pu1_final_recon = ps_cu_prms->pu1_luma_recon + (ps_enc_tmp_out_ctxt->b3_cu_pos_x << 3);

        pu1_final_recon +=

            ((ps_enc_tmp_out_ctxt->b3_cu_pos_y << 3) * ps_cu_prms->i4_luma_recon_stride);

        ps_ctxt->s_cmn_opt_func.pf_copy_2d(

            pu1_final_recon,

            ps_cu_prms->i4_luma_recon_stride,

            pu1_recon,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            ps_enc_tmp_out_ctxt->u1_cu_size);

        /* ---- copy the child chroma recon back to curr. recon -------- */

        pu1_recon = (UWORD8 *)ps_ctxt->pv_cu_chrma_recon;

        /* based on CU position derive the chroma pointers */

        pu1_final_recon = ps_cu_prms->pu1_chrm_recon + (ps_enc_tmp_out_ctxt->b3_cu_pos_x << 3);

        pu1_final_recon +=

            ((ps_enc_tmp_out_ctxt->b3_cu_pos_y << (u1_is_422 + 2)) *

             ps_cu_prms->i4_chrm_recon_stride);

        ps_ctxt->s_cmn_opt_func.pf_copy_2d(

            pu1_final_recon,

            ps_cu_prms->i4_chrm_recon_stride,

            pu1_recon,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            ps_enc_tmp_out_ctxt->u1_cu_size,

            (ps_enc_tmp_out_ctxt->u1_cu_size >> (0 == u1_is_422)));

    }

#endif

    /*copy qp for qg*/

    {

        WORD32 i4_num_8x8, i4_x, i4_y;

        WORD32 i4_cu_pos_x, i4_cu_pox_y;

        i4_num_8x8 = ps_enc_tmp_out_ctxt->u1_cu_size >> 3;

        i4_cu_pos_x = ps_enc_tmp_out_ctxt->b3_cu_pos_x;

        i4_cu_pox_y = ps_enc_tmp_out_ctxt->b3_cu_pos_y;

        for(i4_y = 0; i4_y < i4_num_8x8; i4_y++)

        {

            for(i4_x = 0; i4_x < i4_num_8x8; i4_x++)

            {

                if(ps_enc_tmp_out_ctxt->ps_cu_prms->u1_is_cu_coded)

                {

                    ps_ctxt->ai4_qp_qg[((i4_cu_pox_y + i4_y) * 8) + (i4_cu_pos_x + i4_x)] =

                        ps_ctxt->i4_cu_qp;

                }

                else

                {

                    ps_ctxt->ai4_qp_qg[((i4_cu_pox_y + i4_y) * 8) + (i4_cu_pos_x + i4_x)] =

                        ps_ctxt->i4_pred_qp;

                }

            }

        }

    }

    /* ------ copy the nbr 4x4 to final output ------ */

    num_4x4_in_cu = ps_enc_tmp_out_ctxt->u1_cu_size >> 2;

    num_4x4_in_ctb = (ps_cu_prms->i4_ctb_size >> 2);

    ps_curr_nbr_4x4 = &ps_ctxt->as_ctb_nbr_arr[0];

    ps_curr_nbr_4x4 += (ps_enc_tmp_out_ctxt->b3_cu_pos_x << 1);

    ps_curr_nbr_4x4 += ((ps_enc_tmp_out_ctxt->b3_cu_pos_y << 1) * num_4x4_in_ctb);

    ps_tmp_nbr_4x4 = ps_curr_nbr_4x4;

    ps_nbr_4x4 = ps_ctxt->ps_cu_recur_nbr;

    GETRANGE(log2_ctb_size, ps_cu_prms->i4_ctb_size);

    GETRANGE(log2_cu_size, ps_enc_tmp_out_ctxt->u1_cu_size);

    cu_depth = log2_ctb_size - log2_cu_size;

    ASSERT(cu_depth <= 3);

    ASSERT(cu_depth >= 0);

    /*assign qp for all 4x4 nbr blocks*/

    for(ctr = 0; ctr < num_4x4_in_cu * num_4x4_in_cu; ctr++, ps_nbr_4x4++)

    {

        ps_nbr_4x4->b1_skip_flag = ps_enc_tmp_out_ctxt->s_cu_prms.u1_skip_flag;

        ps_nbr_4x4->b2_cu_depth = cu_depth;

        ps_nbr_4x4->b8_qp = ps_ctxt->i4_cu_qp;

    }

    ps_nbr_4x4 = ps_ctxt->ps_cu_recur_nbr;

    for(ctr = 0; ctr < num_4x4_in_cu; ctr++)

    {

        memcpy(ps_tmp_nbr_4x4, ps_nbr_4x4, num_4x4_in_cu * sizeof(nbr_4x4_t));

        ps_tmp_nbr_4x4 += num_4x4_in_ctb;

        ps_nbr_4x4 += num_4x4_in_cu;

    }

}

/**

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

* Function name : ihevce_populate_cu_struct

*

* \brief

*    This function populate cu struct

*

* \param[in] ps_ctxt : pointer to enc loop context structure

* \param[in] ps_cur_ipe_ctb : pointer to  IPE L0 analyze structure

* \param[in] ps_cu_tree_analyse : pointer to  Structure for CU recursion

* \param[in] ps_best_results : pointer to  strcuture  contain result for partition type of CU

* \param[in] ps_cu_out : pointer to  structre contain  mode analysis info

* \param[in] i4_32x32_id : noise estimation id

* \param[in] u1_num_best_results : num best result value

*

* \return

*    None

*

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

void ihevce_populate_cu_struct(

    ihevce_enc_loop_ctxt_t *ps_ctxt,

    ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb,

    cur_ctb_cu_tree_t *ps_cu_tree_analyse,

    part_type_results_t *ps_best_results,

    cu_analyse_t *ps_cu_out,

    WORD32 i4_32x32_id,

#if DISABLE_INTRA_WHEN_NOISY && USE_NOISE_TERM_IN_ENC_LOOP

    UWORD8 u1_is_cu_noisy,

#endif

    UWORD8 u1_num_best_results)

{

    cu_inter_cand_t *ps_cu_candt;

    WORD32 j;

    /* open loop intra cost by IPE */

    WORD32 intra_cost_ol;

    /* closed loop intra cost based on empirical coding noise estimate */

    WORD32 intra_cost_cl_est = 0;

    /* closed loop intra coding noise estimate */

    WORD32 intra_noise_cl_est;

    WORD32 num_results_to_copy = 0;

    WORD32 found_intra = 0;

    WORD32 quality_preset = ps_ctxt->i4_quality_preset;

    WORD32 frm_qp = ps_ctxt->i4_frame_qp;

    WORD32 frm_qstep_multiplier = gau4_frame_qstep_multiplier[frm_qp - 1];

    WORD32 frm_qstep = ps_ctxt->i4_frame_qstep;

    UWORD8 u1_cu_size = ps_cu_tree_analyse->u1_cu_size;

    UWORD8 u1_x_off = ps_cu_tree_analyse->b3_cu_pos_x << 3;

    UWORD8 u1_y_off = ps_cu_tree_analyse->b3_cu_pos_y << 3;

    UWORD8 u1_threshold_multi;

    switch(quality_preset)

    {

    case IHEVCE_QUALITY_P0:

    case IHEVCE_QUALITY_P2:

    {

        num_results_to_copy =

            MIN(MAX_NUMBER_OF_INTER_RDOPT_CANDS_IN_PQ_AND_HQ, u1_num_best_results);

        break;

    }

    case IHEVCE_QUALITY_P3:

    {

        num_results_to_copy = MIN(MAX_NUMBER_OF_INTER_RDOPT_CANDS_IN_MS, u1_num_best_results);

        break;

    }

    case IHEVCE_QUALITY_P4:

    case IHEVCE_QUALITY_P5:

    case IHEVCE_QUALITY_P6:

    {

        num_results_to_copy =

            MIN(MAX_NUMBER_OF_INTER_RDOPT_CANDS_IN_HS_AND_XS, u1_num_best_results);

        break;

    }

    }

    ps_cu_out->u1_num_inter_cands = 0;

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

    /* Depending CU size that has won in ME,                       */

    /*     Estimate the closed loop intra cost for enabling intra  */

    /*     evaluation in rdopt stage based on preset               */

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

    switch(u1_cu_size)

    {

    case 64:

    {

        /* coding noise estimate for intra closed loop cost */

        intra_cost_ol = ps_cur_ipe_ctb->i4_best64x64_intra_cost - frm_qstep * 256;

        intra_noise_cl_est = (frm_qstep * frm_qstep_multiplier) + (intra_cost_ol >> 4);

        intra_noise_cl_est = MIN(intra_noise_cl_est, (frm_qstep * 16)) * 16;

        intra_cost_cl_est = intra_cost_ol + intra_noise_cl_est;

        break;

    }

    case 32:

    {

        /* coding noise estimate for intra closed loop cost */

        intra_cost_ol = ps_cur_ipe_ctb->ai4_best32x32_intra_cost[i4_32x32_id] - frm_qstep * 64;

        intra_noise_cl_est = (frm_qstep * frm_qstep_multiplier) + (intra_cost_ol >> 4);

        intra_noise_cl_est = MIN(intra_noise_cl_est, (frm_qstep * 16)) * 4;

        intra_cost_cl_est = intra_cost_ol + intra_noise_cl_est;

        break;

    }

    case 16:

    {

        /* coding noise estimate for intra closed loop cost */

        intra_cost_ol =

            ps_cur_ipe_ctb->ai4_best16x16_intra_cost[(u1_x_off >> 4) + ((u1_y_off >> 4) << 2)] -

            frm_qstep * 16;

        intra_noise_cl_est = (frm_qstep * frm_qstep_multiplier) + (intra_cost_ol >> 4);

        intra_noise_cl_est = MIN(intra_noise_cl_est, (frm_qstep * 16));

        intra_cost_cl_est = intra_cost_ol + intra_noise_cl_est;

        break;

    }

    case 8:

    {

        /* coding noise estimate for intra closed loop cost */

        intra_cost_ol =

            ps_cur_ipe_ctb->ai4_best8x8_intra_cost[(u1_x_off >> 3) + u1_y_off] - frm_qstep * 4;

        intra_noise_cl_est = (frm_qstep * frm_qstep_multiplier) + (intra_cost_ol >> 4);

        intra_noise_cl_est = MIN(intra_noise_cl_est, (frm_qstep * 16)) >> 2;

        intra_cost_cl_est = intra_cost_ol + intra_noise_cl_est;

        break;

    }

    }

#if DISABLE_INTER_CANDIDATES

    return;

#endif

    u1_threshold_multi = 1;

#if DISABLE_INTRA_WHEN_NOISY && USE_NOISE_TERM_IN_ENC_LOOP

    if(u1_is_cu_noisy)

    {

        intra_cost_cl_est = INT_MAX;

    }

#endif

    ps_cu_candt = ps_cu_out->as_cu_inter_cand;

    /* Check if the first best candidate is inter or intra */

    if(ps_best_results[0].as_pu_results[0].pu.b1_intra_flag)

    {

        ps_cu_out->u1_best_is_intra = 1;

    }

    else

    {

        ps_cu_out->u1_best_is_intra = 0;

    }

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

    {

        part_type_results_t *ps_best = &ps_best_results[j];

        if(ps_best->as_pu_results[0].pu.b1_intra_flag)

        {

            found_intra = 1;

        }

        else

        {

            /* populate the TU split flags, 4 flags copied as max cu can be 64 */

            memcpy(ps_cu_candt->ai4_tu_split_flag, ps_best->ai4_tu_split_flag, 4 * sizeof(WORD32));

            /* populate the TU early CBF flags, 4 flags copied as max cu can be 64 */

            memcpy(ps_cu_candt->ai4_tu_early_cbf, ps_best->ai4_tu_early_cbf, 4 * sizeof(WORD32));

            /* Note: the enums of part size and me part types shall match */

            ps_cu_candt->b3_part_size = ps_best->u1_part_type;

            /* ME will always set the skip flag to 0            */

            /* in closed loop skip will be added as a candidate */

            ps_cu_candt->b1_skip_flag = 0;

            /* copy the inter pus : Note: assuming NxN part type is not supported */

            ps_cu_candt->as_inter_pu[0] = ps_best->as_pu_results[0].pu;

            ps_cu_candt->as_inter_pu[0].b1_merge_flag = 0;

            /* Copy the total cost of the CU candt */

            ps_cu_candt->i4_total_cost = ps_best->i4_tot_cost;

            ps_cu_out->ai4_mv_cost[ps_cu_out->u1_num_inter_cands][0] =

                ps_best->as_pu_results[0].i4_mv_cost;

#if REUSE_ME_COMPUTED_ERROR_FOR_INTER_CAND_SIFTING

            ps_cu_out->ai4_err_metric[ps_cu_out->u1_num_inter_cands][0] =

                ps_best->as_pu_results[0].i4_tot_cost - ps_best->as_pu_results[0].i4_mv_cost;

#endif

            if(ps_best->u1_part_type)

            {

                ps_cu_candt->as_inter_pu[1] = ps_best->as_pu_results[1].pu;

                ps_cu_out->ai4_mv_cost[ps_cu_out->u1_num_inter_cands][1] =

                    ps_best->as_pu_results[1].i4_mv_cost;

#if REUSE_ME_COMPUTED_ERROR_FOR_INTER_CAND_SIFTING

                ps_cu_out->ai4_err_metric[ps_cu_out->u1_num_inter_cands][1] =

                    ps_best->as_pu_results[1].i4_tot_cost - ps_best->as_pu_results[1].i4_mv_cost;

#endif

                ps_cu_candt->as_inter_pu[1].b1_merge_flag = 0;

            }

            ps_cu_candt++;

            ps_cu_out->u1_num_inter_cands++;

            if(intra_cost_cl_est < ((ps_best->i4_tot_cost * u1_threshold_multi) >> 0))

            {

                /* The rationale - */

                /* Artefacts were being observed in some sequences, */

                /* Brooklyn_1080p in particular - where it was readily */

                /* apparent. The cause was coding of CU's as inter CU's */

                /* when they actually needed to be coded as intra CU's. */

                /* This was observed during either fade-outs aor flashes. */

                /* After tinkering with the magnitude of the coding noise */

                /* factor that was added to the intra cost to see when the */

                /* artefacts in Brooklyn vanished, it was observed that the */

                /* factor multiplied with the frame_qstep followed a pattern. */

                /* When the pattern was subjected to a regression analysis, the */

                /* formula seen below emerged. Also note the fact that the coding */

                /* noise factor is the product of the frame_qstep and a constant */

                /* multiplier */

                /*UWORD32 frm_qstep_multiplier =

                -3.346 * log((float)frm_qstep) + 15.925;*/

                found_intra = 1;

            }

            if(ps_cu_out->u1_num_inter_cands >= num_results_to_copy)

            {

                break;

            }

        }

    }

    if(quality_preset < IHEVCE_QUALITY_P4)

    {

        found_intra = 1;

    }

    if(!found_intra)

    {

        /* rdopt evaluation of intra disabled as inter is clear winner */

        ps_cu_out->u1_num_intra_rdopt_cands = 0;

        /* all the modes invalidated */

        ps_cu_out->s_cu_intra_cand.au1_intra_luma_modes_2nx2n_tu_eq_cu[0] = 255;

        ps_cu_out->s_cu_intra_cand.au1_intra_luma_modes_2nx2n_tu_eq_cu_by_2[0] = 255;

        ps_cu_out->s_cu_intra_cand.au1_intra_luma_modes_nxn[0][0] = 255;

        ps_cu_out->u1_chroma_intra_pred_mode = 255;

        /* no intra candt to verify */

        ps_cu_out->s_cu_intra_cand.b6_num_intra_cands = 0;

    }

}

/**

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

* Function name : ihevce_create_child_nodes_cu_tree

*

* \brief

*    This function create child node from cu tree

*

* \param[in] ps_cu_tree_root : pointer to Structure for CU recursion

* \param[out] ps_cu_tree_cur_node : pointer to  Structure for CU recursion

* \param[in] ai4_child_node_enable : child node enable flag

* \param[in] nodes_already_created : already created node value

* \return

*    None

*

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

WORD32 ihevce_create_child_nodes_cu_tree(

    cur_ctb_cu_tree_t *ps_cu_tree_root,

    cur_ctb_cu_tree_t *ps_cu_tree_cur_node,

    WORD32 *ai4_child_node_enable,

    WORD32 nodes_already_created)

{

    cur_ctb_cu_tree_t *ps_tl;

    cur_ctb_cu_tree_t *ps_tr;

    cur_ctb_cu_tree_t *ps_bl;

    cur_ctb_cu_tree_t *ps_br;

    ps_tl = ps_cu_tree_root + nodes_already_created;

    ps_tr = ps_tl + 1;

    ps_bl = ps_tr + 1;

    ps_br = ps_bl + 1;

    if(1 == ps_cu_tree_cur_node->is_node_valid)

    {

        ps_tl = (ai4_child_node_enable[0]) ? ps_tl : NULL;

        ps_tr = (ai4_child_node_enable[1]) ? ps_tr : NULL;

        ps_bl = (ai4_child_node_enable[2]) ? ps_bl : NULL;

        ps_br = (ai4_child_node_enable[3]) ? ps_br : NULL;

        /* In incomplete CTB, if any of the child nodes are assigned to NULL */

        /* then parent node ceases to be valid */

        if((ps_tl == NULL) || (ps_tr == NULL) || (ps_br == NULL) || (ps_bl == NULL))

        {

            ps_cu_tree_cur_node->is_node_valid = 0;

        }

    }

    ps_cu_tree_cur_node->ps_child_node_tl = ps_tl;

    ps_cu_tree_cur_node->ps_child_node_tr = ps_tr;

    ps_cu_tree_cur_node->ps_child_node_bl = ps_bl;

    ps_cu_tree_cur_node->ps_child_node_br = ps_br;

    return 4;

}

/**

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

* Function name : ihevce_populate_cu_tree

*

* \brief

*    This function create child node from cu tree

*

* \param[in] ps_cur_ipe_ctb : pointer to Structure for CU recursion

* \param[out] ps_cu_tree : pointer to  Structure for CU recursion

* \param[in] tree_depth : child node enable flag

* \param[in] e_quality_preset : already created node value

* \param[in] e_grandparent_blk_pos : already created node value

* \param[in] e_parent_blk_pos : already created node value

* \param[in] e_cur_blk_pos : already created node value

*

* \return

*    None

*

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

void ihevce_populate_cu_tree(

    ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb,

    cur_ctb_cu_tree_t *ps_cu_tree,

    WORD32 tree_depth,

    IHEVCE_QUALITY_CONFIG_T e_quality_preset,

    CU_POS_T e_grandparent_blk_pos,

    CU_POS_T e_parent_blk_pos,

    CU_POS_T e_cur_blk_pos)

{

    WORD32 ai4_child_enable[4];

    WORD32 children_nodes_required = 0;

    WORD32 cu_pos_x = 0;

    WORD32 cu_pos_y = 0;

    WORD32 cu_size = 0;

    WORD32 i;

    WORD32 node_validity = 0;

    if(NULL == ps_cu_tree)

    {

        return;

    }

    switch(tree_depth)

    {

    case 0:

    {

        /* 64x64 block */

        intra32_analyse_t *ps_intra32_analyse = ps_cur_ipe_ctb->as_intra32_analyse;

        children_nodes_required = 1;

        cu_size = 64;

        cu_pos_x = 0;

        cu_pos_y = 0;

        node_validity = !ps_cur_ipe_ctb->u1_split_flag;

        if(e_quality_preset >= IHEVCE_QUALITY_P2)

        {

            if(node_validity == 1)

            {

                children_nodes_required = 0;

            }

        }

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

        {

            ai4_child_enable[i] = ps_intra32_analyse[i].b1_valid_cu;

        }

        break;

    }

    case 1:

    {

        /* 32x32 block */

        WORD32 valid_flag_32 = (ps_cur_ipe_ctb->as_intra32_analyse[e_cur_blk_pos].b1_valid_cu);

        intra16_analyse_t *ps_intra16_analyse =

            ps_cur_ipe_ctb->as_intra32_analyse[e_cur_blk_pos].as_intra16_analyse;

        cu_size = 32;

        /* Explanation for logic below - */

        /* * pos_x and pos_y are in units of 8x8 CU's */

        /* * pos_x = 0 for TL and BL children */

        /* * pos_x = 4 for TR and BR children */

        /* * pos_y = 0 for TL and TR children */

        /* * pos_y = 4 for BL and BR children */

        cu_pos_x = (e_cur_blk_pos & 1) << 2;

        cu_pos_y = (e_cur_blk_pos & 2) << 1;

        {

            node_validity = (ps_cur_ipe_ctb->as_intra32_analyse[e_cur_blk_pos].b1_merge_flag);

            if(e_quality_preset >= IHEVCE_QUALITY_P2)

            {

                node_validity = (!ps_cur_ipe_ctb->as_intra32_analyse[e_cur_blk_pos].b1_split_flag);

            }

            node_validity = node_validity && valid_flag_32;

            children_nodes_required = !node_validity || ps_cur_ipe_ctb->u1_split_flag;

        }

        if(e_quality_preset >= IHEVCE_QUALITY_P2)

        {

            if(node_validity == 1)

            {

                children_nodes_required = 0;

            }

            else

            {

                children_nodes_required =

                    (ps_cur_ipe_ctb->as_intra32_analyse[e_cur_blk_pos].b1_split_flag);

            }

        }

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

        {

            ai4_child_enable[i] = ps_intra16_analyse[i].b1_valid_cu;

        }

        break;

    }

    case 2:

    {

        /* 16x16 block */

        WORD32 cu_pos_x_parent;

        WORD32 cu_pos_y_parent;

        WORD32 merge_flag_16;

        WORD32 merge_flag_32;

        intra8_analyse_t *ps_intra8_analyse = ps_cur_ipe_ctb->as_intra32_analyse[e_parent_blk_pos]

                                                  .as_intra16_analyse[e_cur_blk_pos]

                                                  .as_intra8_analyse;

        WORD32 valid_flag_16 = (ps_cur_ipe_ctb->as_intra32_analyse[e_parent_blk_pos]

                                    .as_intra16_analyse[e_cur_blk_pos]

                                    .b1_valid_cu);

        cu_size = 16;

        /* Explanation for logic below - */

        /* See similar explanation above */

        cu_pos_x_parent = (e_parent_blk_pos & 1) << 2;

        cu_pos_y_parent = (e_parent_blk_pos & 2) << 1;

        cu_pos_x = cu_pos_x_parent + ((e_cur_blk_pos & 1) << 1);

        cu_pos_y = cu_pos_y_parent + (e_cur_blk_pos & 2);

        merge_flag_16 = (ps_cur_ipe_ctb->as_intra32_analyse[e_parent_blk_pos]

                             .as_intra16_analyse[e_cur_blk_pos]

                             .b1_merge_flag);

        merge_flag_32 = (ps_cur_ipe_ctb->as_intra32_analyse[e_parent_blk_pos].b1_merge_flag);

#if !ENABLE_UNIFORM_CU_SIZE_8x8

        node_validity = (merge_flag_16) || ((ps_cur_ipe_ctb->u1_split_flag) && (!merge_flag_32));

#else

        node_validity = 0;

#endif

        node_validity = (merge_flag_16) || ((ps_cur_ipe_ctb->u1_split_flag) && (!merge_flag_32));

        if(e_quality_preset >= IHEVCE_QUALITY_P2)

        {

            node_validity = (!ps_cur_ipe_ctb->as_intra32_analyse[e_parent_blk_pos]

                                  .as_intra16_analyse[e_cur_blk_pos]

                                  .b1_split_flag);

        }

        node_validity = node_validity && valid_flag_16;

        children_nodes_required = ((ps_cur_ipe_ctb->u1_split_flag) && (!merge_flag_32)) ||

                                  !merge_flag_16;

        if(e_quality_preset >= IHEVCE_QUALITY_P2)

        {

            children_nodes_required = !node_validity;

        }

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

        {

            ai4_child_enable[i] = ps_intra8_analyse[i].b1_valid_cu;

        }

        break;

    }

    case 3:

    {

        /* 8x8 block */

        WORD32 cu_pos_x_grandparent;

        WORD32 cu_pos_y_grandparent;

        WORD32 cu_pos_x_parent;

        WORD32 cu_pos_y_parent;

        WORD32 valid_flag_8 = (ps_cur_ipe_ctb->as_intra32_analyse[e_grandparent_blk_pos]

                                   .as_intra16_analyse[e_parent_blk_pos]

                                   .as_intra8_analyse[e_cur_blk_pos]

                                   .b1_valid_cu);

        cu_size = 8;

        cu_pos_x_grandparent = (e_grandparent_blk_pos & 1) << 2;

        cu_pos_y_grandparent = (e_grandparent_blk_pos & 2) << 1;

        cu_pos_x_parent = cu_pos_x_grandparent + ((e_parent_blk_pos & 1) << 1);

        cu_pos_y_parent = cu_pos_y_grandparent + (e_parent_blk_pos & 2);

        cu_pos_x = cu_pos_x_parent + (e_cur_blk_pos & 1);

        cu_pos_y = cu_pos_y_parent + ((e_cur_blk_pos & 2) >> 1);

        node_validity = 1 && valid_flag_8;

        children_nodes_required = 0;

        break;

    }

    }

    /* Fill the current cu_tree node */

    ps_cu_tree->is_node_valid = node_validity;

    ps_cu_tree->u1_cu_size = cu_size;

    ps_cu_tree->b3_cu_pos_x = cu_pos_x;

    ps_cu_tree->b3_cu_pos_y = cu_pos_y;

    if(children_nodes_required)

    {

        tree_depth++;

        ps_cur_ipe_ctb->nodes_created_in_cu_tree += ihevce_create_child_nodes_cu_tree(

            ps_cur_ipe_ctb->ps_cu_tree_root,

            ps_cu_tree,

            ai4_child_enable,

            ps_cur_ipe_ctb->nodes_created_in_cu_tree);

        ihevce_populate_cu_tree(

            ps_cur_ipe_ctb,

            ps_cu_tree->ps_child_node_tl,

            tree_depth,

            e_quality_preset,