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

 *

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

*

* \brief

*    Functions that facilitate selection of optimal TU tree

*

* \date

*    20/04/2016

*

* \author

*    Ittiam

*

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

#include <limits.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_enc_loop_utils.h"

#include "ihevce_tu_tree_selector.h"

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

/* Function Definitions                                                      */

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

/*!

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

* \if Function name : ihevce_tu_tree_coverage_in_cu \endif

*

* \brief

*    Determination of the area within the CU that is swept by the TU tree.

*    Input : Pointer to a node of the TU tree

*    Output : Area covered by the current TU or its children

*

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

*/

WORD32 ihevce_tu_tree_coverage_in_cu(tu_tree_node_t *ps_node)

{

    WORD32 i4_tu_tree_area = 0;

    if(ps_node->u1_is_valid_node)

    {

        i4_tu_tree_area += ps_node->s_luma_data.u1_size * ps_node->s_luma_data.u1_size;

    }

    else

    {

        if(NULL != ps_node->ps_child_node_tl)

        {

            i4_tu_tree_area += ihevce_tu_tree_coverage_in_cu(ps_node->ps_child_node_tl);

        }

        if(NULL != ps_node->ps_child_node_tr)

        {

            i4_tu_tree_area += ihevce_tu_tree_coverage_in_cu(ps_node->ps_child_node_tr);

        }

        if(NULL != ps_node->ps_child_node_bl)

        {

            i4_tu_tree_area += ihevce_tu_tree_coverage_in_cu(ps_node->ps_child_node_bl);

        }

        if(NULL != ps_node->ps_child_node_br)

        {

            i4_tu_tree_area += ihevce_tu_tree_coverage_in_cu(ps_node->ps_child_node_br);

        }

    }

    return i4_tu_tree_area;

}

static void ihevce_tu_node_data_init(

    tu_node_data_t *ps_tu_data, UWORD8 u1_size, UWORD8 u1_posx, UWORD8 u1_posy)

{

    ps_tu_data->u1_size = u1_size;

    ps_tu_data->i8_ssd = 0;

    ps_tu_data->i8_cost = 0;

#if ENABLE_INTER_ZCU_COST

    ps_tu_data->i8_not_coded_cost = 0;

#endif

    ps_tu_data->u4_sad = 0;

    ps_tu_data->i4_bits = 0;

    ps_tu_data->i4_num_bytes_used_for_ecd = 0;

    ps_tu_data->u1_cbf = 0;

    ps_tu_data->u1_reconBufId = UCHAR_MAX;

    ps_tu_data->u1_posx = u1_posx;

    ps_tu_data->u1_posy = u1_posy;

}

/*!

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

* \if Function name : ihevce_tu_node_init \endif

*

* \brief

*    This function initialises all nodes of the TU tree from the root upto and

*    including the nodes at the max tree depth. Only those nodes that lie

*    within the (max + 1) and (min - 1) depths are set as valid. Everything

*    else is invalid. The pointers to the children nodes of the leaf-most

*    nodes in the tree are assigned NULL.

*    Input : Pointer to root of the tree containing TU info.

*    Output : The memory of this node and all its progeny shall be modified

*    returns Number of nodes of the TU tree that have been modified

*

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

*/

static UWORD16 ihevce_tu_node_init(

    tu_tree_node_t *ps_root,

    UWORD8 u1_size,

    UWORD8 u1_parent_posx,

    UWORD8 u1_parent_posy,

    UWORD8 u1_cur_depth,

    UWORD8 u1_min_tree_depth,

    UWORD8 u1_max_tree_depth,

    UWORD8 u1_chroma_processing_enabled,

    UWORD8 u1_is_422,

    TU_POS_T e_tu_pos)

{

    tu_tree_node_t *ps_node;

    tu_tree_node_t *ps_childNodeTL;

    tu_tree_node_t *ps_childNodeTR;

    tu_tree_node_t *ps_childNodeBL;

    tu_tree_node_t *ps_childNodeBR;

    UWORD8 u1_start_index_for_parent = 0;

    UWORD8 u1_start_index_for_child = 0;

    UWORD16 u2_parent_offset = 0;

    UWORD16 u2_child_offset = 0;

    UWORD8 u1_posx = 0;

    UWORD8 u1_posy = 0;

    const UWORD8 u1_nxn_tu_node_start_index = 0;

    const UWORD8 u1_nBye2xnBye2_tu_node_start_index = 1;

    const UWORD8 u1_nBye4xnBye4_tu_node_start_index = 1 + 4;

    const UWORD8 u1_nBye8xnBye8_tu_node_start_index = 1 + 4 + 16;

    const UWORD8 u1_nBye16xnBye16_tu_node_start_index = 1 + 4 + 16 + 64;

    UWORD16 u2_num_nodes_initialised = 0;

    ASSERT(u1_cur_depth <= u1_max_tree_depth);

    ASSERT(u1_max_tree_depth >= u1_min_tree_depth);

    switch(e_tu_pos)

    {

    case POS_TL:

    {

        u1_posx = u1_parent_posx;

        u1_posy = u1_parent_posy;

        break;

    }

    case POS_TR:

    {

        u1_posx = u1_parent_posx + u1_size;

        u1_posy = u1_parent_posy;

        break;

    }

    case POS_BL:

    {

        u1_posx = u1_parent_posx;

        u1_posy = u1_parent_posy + u1_size;

        break;

    }

    case POS_BR:

    {

        u1_posx = u1_parent_posx + u1_size;

        u1_posy = u1_parent_posy + u1_size;

        break;

    }

    default:

    {

        /* Here be dragons */

        ASSERT(0);

    }

    }

    switch(u1_cur_depth)

    {

    case 0:

    {

        u1_start_index_for_parent = u1_nxn_tu_node_start_index;

        u1_start_index_for_child = u1_nBye2xnBye2_tu_node_start_index;

        u2_parent_offset = 0;

        u2_child_offset = 0;

        break;

    }

    case 1:

    {

        u1_start_index_for_parent = u1_nBye2xnBye2_tu_node_start_index;

        u1_start_index_for_child = u1_nBye4xnBye4_tu_node_start_index;

        u2_parent_offset = e_tu_pos;

        u2_child_offset = 4 * u1_posx / u1_size + 8 * u1_posy / u1_size;

        break;

    }

    case 2:

    {

        u1_start_index_for_parent = u1_nBye4xnBye4_tu_node_start_index;

        u1_start_index_for_child = u1_nBye8xnBye8_tu_node_start_index;

        u2_parent_offset = 2 * u1_parent_posx / u1_size + 4 * u1_parent_posy / u1_size + e_tu_pos;

        u2_child_offset = 4 * u1_posx / u1_size + 16 * u1_posy / u1_size;

        break;

    }

    case 3:

    {

        u1_start_index_for_parent = u1_nBye8xnBye8_tu_node_start_index;

        u1_start_index_for_child = u1_nBye16xnBye16_tu_node_start_index;

        u2_parent_offset = 2 * u1_parent_posx / u1_size + 8 * u1_parent_posy / u1_size + e_tu_pos;

        u2_child_offset = 4 * u1_posx / u1_size + 32 * u1_posy / u1_size;

        break;

    }

    case 4:

    {

        u1_start_index_for_parent = u1_nBye16xnBye16_tu_node_start_index;

        u1_start_index_for_child = 0;

        u2_parent_offset = 2 * u1_parent_posx / u1_size + 16 * u1_parent_posy / u1_size + e_tu_pos;

        u2_child_offset = 0;

        break;

    }

    default:

    {

        /* Here be dragons */

        ASSERT(0);

    }

    }

    ASSERT((u1_start_index_for_parent + u2_parent_offset) < (256 + 64 + 16 + 4 + 1));

    ASSERT((u1_start_index_for_child + u2_child_offset + POS_BR) < (256 + 64 + 16 + 4 + 1));

    ps_node = ps_root + u1_start_index_for_parent + u2_parent_offset;

    ps_childNodeTL = ps_root + u1_start_index_for_child + u2_child_offset + POS_TL;

    ps_childNodeTR = ps_root + u1_start_index_for_child + u2_child_offset + POS_TR;

    ps_childNodeBL = ps_root + u1_start_index_for_child + u2_child_offset + POS_BL;

    ps_childNodeBR = ps_root + u1_start_index_for_child + u2_child_offset + POS_BR;

    ihevce_tu_node_data_init(&ps_node->s_luma_data, u1_size, u1_posx, u1_posy);

    if(u1_chroma_processing_enabled)

    {

        UWORD8 i;

        if(u1_size > 4)

        {

            for(i = 0; i < (u1_is_422 + 1); i++)

            {

                ihevce_tu_node_data_init(

                    &ps_node->as_cb_data[i],

                    u1_size / 2,

                    u1_posx / 2,

                    !u1_is_422 ? u1_posy / 2 : u1_posy + i * u1_size / 2);

                ihevce_tu_node_data_init(

                    &ps_node->as_cr_data[i],

                    u1_size / 2,

                    u1_posx / 2,

                    !u1_is_422 ? u1_posy / 2 : u1_posy + i * u1_size / 2);

            }

        }

        else if(POS_TL == e_tu_pos)

        {

            for(i = 0; i < (u1_is_422 + 1); i++)

            {

                ihevce_tu_node_data_init(

                    &ps_node->as_cb_data[i],

                    u1_size,

                    u1_posx / 2,

                    !u1_is_422 ? u1_posy / 2 : u1_posy + i * u1_size);

                ihevce_tu_node_data_init(

                    &ps_node->as_cr_data[i],

                    u1_size,

                    u1_posx / 2,

                    !u1_is_422 ? u1_posy / 2 : u1_posy + i * u1_size);

            }

        }

        else

        {

            for(i = 0; i < (u1_is_422 + 1); i++)

            {

                ihevce_tu_node_data_init(

                    &ps_node->as_cb_data[i],

                    u1_size / 2,

                    u1_posx / 2,

                    !u1_is_422 ? u1_posy / 2 : u1_posy + i * u1_size);

                ihevce_tu_node_data_init(

                    &ps_node->as_cr_data[i],

                    u1_size / 2,

                    u1_posx / 2,

                    !u1_is_422 ? u1_posy / 2 : u1_posy + i * u1_size);

            }

        }

    }

    if((u1_cur_depth >= u1_min_tree_depth) && (u1_cur_depth <= u1_max_tree_depth))

    {

        ps_node->u1_is_valid_node = 1;

    }

    else

    {

        ps_node->u1_is_valid_node = 0;

    }

    u2_num_nodes_initialised++;

    if((u1_cur_depth < u1_max_tree_depth) && (u1_size > MIN_TU_SIZE))

    {

        ps_node->ps_child_node_tl = ps_childNodeTL;

        ps_node->ps_child_node_tr = ps_childNodeTR;

        ps_node->ps_child_node_bl = ps_childNodeBL;

        ps_node->ps_child_node_br = ps_childNodeBR;

        u2_num_nodes_initialised += ihevce_tu_node_init(

            ps_root,

            u1_size / 2,

            ps_node->s_luma_data.u1_posx,

            ps_node->s_luma_data.u1_posy,

            u1_cur_depth + 1,

            u1_min_tree_depth,

            u1_max_tree_depth,

            u1_chroma_processing_enabled,

            u1_is_422,

            POS_TL);

        u2_num_nodes_initialised += ihevce_tu_node_init(

            ps_root,

            u1_size / 2,

            ps_node->s_luma_data.u1_posx,

            ps_node->s_luma_data.u1_posy,

            u1_cur_depth + 1,

            u1_min_tree_depth,

            u1_max_tree_depth,

            u1_chroma_processing_enabled,

            u1_is_422,

            POS_TR);

        u2_num_nodes_initialised += ihevce_tu_node_init(

            ps_root,

            u1_size / 2,

            ps_node->s_luma_data.u1_posx,

            ps_node->s_luma_data.u1_posy,

            u1_cur_depth + 1,

            u1_min_tree_depth,

            u1_max_tree_depth,

            u1_chroma_processing_enabled,

            u1_is_422,

            POS_BL);

        u2_num_nodes_initialised += ihevce_tu_node_init(

            ps_root,

            u1_size / 2,

            ps_node->s_luma_data.u1_posx,

            ps_node->s_luma_data.u1_posy,

            u1_cur_depth + 1,

            u1_min_tree_depth,

            u1_max_tree_depth,

            u1_chroma_processing_enabled,

            u1_is_422,

            POS_BR);

    }

    else

    {

        ps_node->ps_child_node_tl = NULL;

        ps_node->ps_child_node_tr = NULL;

        ps_node->ps_child_node_bl = NULL;

        ps_node->ps_child_node_br = NULL;

    }

    return u2_num_nodes_initialised;

}

/*!

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

* \if Function name : ihevce_tu_tree_init \endif

*

* \brief

*    Initialises all relevant data within all nodes for a specified TU tree

*    Input : Pointer to root of the tree containing TU info.

*    Output : Returns the number of nodes initialised

*

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

*/

UWORD16 ihevce_tu_tree_init(

    tu_tree_node_t *ps_root,

    UWORD8 u1_cu_size,

    UWORD8 u1_min_tree_depth,

    UWORD8 u1_max_tree_depth,

    UWORD8 u1_chroma_processing_enabled,

    UWORD8 u1_is_422)

{

    UWORD16 u2_num_nodes = 0;

    ASSERT(u1_max_tree_depth >= u1_min_tree_depth);

    u2_num_nodes += ihevce_tu_node_init(

        ps_root,

        u1_cu_size,

        0,

        0,

        0,

        u1_min_tree_depth,

        u1_max_tree_depth,

        u1_chroma_processing_enabled,

        u1_is_422,

        POS_TL);

    return u2_num_nodes;

}

/*!

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

* \if Function name : ihevce_cabac_bins2Bits_converter_and_state_updater \endif

*

* \brief

*    cabac bin to bits converter

*    Input : 1. Pointer to buffer which stores the current CABAC state. This

*    buffer shall be modified by this function. 2. Index to the cabac state

*    that corresponds to the bin. 3. bin value

*    Output : Number of bits required to encode the bin

*

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

*/

static INLINE UWORD32 ihevce_cabac_bins2Bits_converter_and_state_updater(

    UWORD8 *pu1_cabac_ctxt, UWORD8 u1_cabac_state_idx, UWORD8 u1_bin_value)

{

    UWORD32 u4_bits = 0;

    u4_bits += gau2_ihevce_cabac_bin_to_bits[pu1_cabac_ctxt[u1_cabac_state_idx] ^ u1_bin_value];

    pu1_cabac_ctxt[u1_cabac_state_idx] =

        gau1_ihevc_next_state[(pu1_cabac_ctxt[u1_cabac_state_idx] << 1) | u1_bin_value];

    return u4_bits;

}

static tu_tree_node_t *

    ihevce_tu_node_parent_finder(tu_tree_node_t *ps_root, tu_tree_node_t *ps_leaf)

{

    UWORD8 u1_depth_of_leaf;

    GETRANGE(u1_depth_of_leaf, ps_root->s_luma_data.u1_size / ps_leaf->s_luma_data.u1_size);

    u1_depth_of_leaf--;

    if(0 == u1_depth_of_leaf)

    {

        return NULL;

    }

    else if(1 == u1_depth_of_leaf)

    {

        return ps_root;

    }

    else

    {

        UWORD8 u1_switch_conditional =

            (ps_leaf->s_luma_data.u1_posx >= ps_root->ps_child_node_tl->s_luma_data.u1_size) +

            (ps_leaf->s_luma_data.u1_posy >= ps_root->ps_child_node_tl->s_luma_data.u1_size) * 2;

        ASSERT(NULL != ps_root->ps_child_node_tl);

        ASSERT(NULL != ps_root->ps_child_node_tr);

        ASSERT(NULL != ps_root->ps_child_node_bl);

        ASSERT(NULL != ps_root->ps_child_node_br);

        switch(u1_switch_conditional)

        {

        case 0:

        {

            return ihevce_tu_node_parent_finder(ps_root->ps_child_node_tl, ps_leaf);

        }

        case 1:

        {

            return ihevce_tu_node_parent_finder(ps_root->ps_child_node_tr, ps_leaf);

        }

        case 2:

        {

            return ihevce_tu_node_parent_finder(ps_root->ps_child_node_bl, ps_leaf);

        }

        case 3:

        {

            return ihevce_tu_node_parent_finder(ps_root->ps_child_node_br, ps_leaf);

        }

        }

    }

    return NULL;

}

/*!

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

* \if Function name : ihevce_compute_bits_for_TUSplit_and_cbf \endif

*

* \notes

*    1. This function ought to be called before the call to 'ihevce_tu_tree_selector'

*    of children TU's in order to determine bits to encode splitFlag as 1.

*    This should also be called at the end of 'ihevce_tu_processor' in order

*    to determine bits required to encode cbf and splitFlag.

*    2. When 'ENABLE_TOP_DOWN_TU_RECURSION' = 0 and 'INCLUDE_CHROMA_DURING_TU_RECURSION' = 1,

*    it shall be assumed that parent chroma cbf is 1.

*    3. When 'INCLUDE_CHROMA_DURING_TU_RECURSION' = 0, this function works as

*    though no chroma related syntax was included in the HEVC syntax for coding

*    the transform tree

*    Input : 1. ps_root: Pointer to root of the tree containing TU info

*            2. ps_leaf: Pointer to current node of the TU tree

*            3. pu1_cabac_ctxt: Pointer to buffer which stores the current CABAC

*            state. This buffer shall be modified by this function

*    Output : Number of bits required to encode cbf and splitFlags

*

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

*/

static WORD32 ihevce_compute_bits_for_TUSplit_and_cbf(

    tu_tree_node_t *ps_root,

    tu_tree_node_t *ps_leaf,

    UWORD8 *pu1_cabac_ctxt,

    UWORD8 u1_max_tu_size,

    UWORD8 u1_min_tu_size,

    UWORD8 u1_cur_depth,

    UWORD8 u1_max_depth,

    UWORD8 u1_is_intra,

    UWORD8 u1_is_intra_nxn_pu,

    UWORD8 u1_chroma_processing_enabled,

    UWORD8 u1_is_422)

{

    UWORD8 u1_cabac_state_idx;

    UWORD8 u1_log2_tu_size;

    UWORD32 u4_num_bits = 0;

    UWORD8 u1_tu_size = ps_leaf->s_luma_data.u1_size;

    ASSERT(u1_min_tu_size >= MIN_TU_SIZE);

    ASSERT(u1_min_tu_size <= u1_max_tu_size);

    ASSERT(u1_max_tu_size <= MAX_TU_SIZE);

    ASSERT(u1_tu_size >= MIN_TU_SIZE);

    ASSERT(u1_tu_size <= MAX_TU_SIZE);

    ASSERT(u1_cur_depth <= u1_max_depth);

    GETRANGE(u1_log2_tu_size, u1_tu_size);

    if((ps_root->s_luma_data.u1_size >> u1_cur_depth) == u1_tu_size)

    {

        if((u1_tu_size <= u1_max_tu_size) && (u1_tu_size > u1_min_tu_size) &&

           (u1_cur_depth < u1_max_depth) && !(u1_is_intra_nxn_pu && !u1_cur_depth))

        {

            u1_cabac_state_idx = IHEVC_CAB_SPLIT_TFM + (5 - u1_log2_tu_size);

            u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                pu1_cabac_ctxt, u1_cabac_state_idx, 0);

        }

        if(u1_chroma_processing_enabled && (u1_tu_size > 4))

        {

            tu_tree_node_t *ps_parent = ihevce_tu_node_parent_finder(ps_root, ps_leaf);

            u1_cabac_state_idx = IHEVC_CAB_CBCR_IDX + u1_cur_depth;

            if(!u1_cur_depth || ps_parent->as_cb_data[0].u1_cbf || ps_parent->as_cb_data[1].u1_cbf)

            {

                if(u1_is_422)

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cb_data[0].u1_cbf);

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cb_data[1].u1_cbf);

                }

                else

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cb_data[0].u1_cbf);

                }

            }

            if(!u1_cur_depth || ps_parent->as_cr_data[0].u1_cbf || ps_parent->as_cr_data[1].u1_cbf)

            {

                if(u1_is_422)

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cr_data[0].u1_cbf);

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cr_data[1].u1_cbf);

                }

                else

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cr_data[0].u1_cbf);

                }

            }

        }

        if(u1_is_intra || u1_cur_depth)

        {

            u1_cabac_state_idx = IHEVC_CAB_CBF_LUMA_IDX + !u1_cur_depth;

            u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->s_luma_data.u1_cbf);

        }

    }

    else

    {

        if((u1_tu_size <= u1_max_tu_size) && (u1_tu_size > u1_min_tu_size) &&

           (u1_cur_depth < u1_max_depth) && !(u1_is_intra_nxn_pu && !u1_cur_depth))

        {

            u1_cabac_state_idx = IHEVC_CAB_SPLIT_TFM + (5 - u1_log2_tu_size);

            u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                pu1_cabac_ctxt, u1_cabac_state_idx, 1);

        }

        if(u1_chroma_processing_enabled && (u1_tu_size > 4))

        {

            tu_tree_node_t *ps_parent = ihevce_tu_node_parent_finder(ps_root, ps_leaf);

            u1_cabac_state_idx = IHEVC_CAB_CBCR_IDX + u1_cur_depth;

            if(!u1_cur_depth || ps_parent->as_cb_data[0].u1_cbf || ps_parent->as_cb_data[1].u1_cbf)

            {

                if(u1_is_422 && (8 == u1_tu_size))

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cb_data[0].u1_cbf);

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cb_data[1].u1_cbf);

                }

                else

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt,

                        u1_cabac_state_idx,

                        ps_leaf->as_cb_data[0].u1_cbf || ps_leaf->as_cb_data[1].u1_cbf);

                }

            }

            if(!u1_cur_depth || ps_parent->as_cr_data[0].u1_cbf || ps_parent->as_cr_data[1].u1_cbf)

            {

                if(u1_is_422 && (8 == u1_tu_size))

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cr_data[0].u1_cbf);

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt, u1_cabac_state_idx, ps_leaf->as_cr_data[1].u1_cbf);

                }

                else

                {

                    u4_num_bits += ihevce_cabac_bins2Bits_converter_and_state_updater(

                        pu1_cabac_ctxt,

                        u1_cabac_state_idx,

                        ps_leaf->as_cr_data[0].u1_cbf || ps_leaf->as_cr_data[1].u1_cbf);

                }

            }

        }

    }

    return u4_num_bits;

}

/*!

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

* \if Function name : ihevce_tu_processor \endif

*

* \notes

*    Input : 1. ps_ctxt: Pointer to enc-loop's context. Parts of this structure

*            shall be modified by this function. They include, au1_cu_csbf,

*            i8_cu_not_coded_cost, ai2_scratch and s_rdoq_sbh_ctxt

*            2. ps_node: Pointer to current node of the TU tree. This struct

*            shall be modified by this function

*            3. pv_src: Pointer to buffer which stores the source

*            4. pv_pred: Pointer to buffer which stores the pred

*            5. pv_recon: Pointer to buffer which stores the recon

*            This buffer shall be modified by this function

*            6. pi2_deq_data: Pointer to buffer which stores the output of IQ.

*            This buffer shall be modified by this function

*            7. pu1_ecd: Pointer to buffer which stores the data output by

*            entropy coding. This buffer shall be modified by this function

*            8. pu1_cabac_ctxt: Pointer to buffer which stores the current CABAC

*            state. This buffer shall be modified by this function

*    Output : NA

*

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

*/

static void ihevce_tu_processor(

    ihevce_enc_loop_ctxt_t *ps_ctxt,

    tu_tree_node_t *ps_node,

    buffer_data_for_tu_t *ps_buffer_data,

    UWORD8 *pu1_cabac_ctxt,

    WORD32 i4_pred_mode,

#if USE_NOISE_TERM_IN_ZERO_CODING_DECISION_ALGORITHMS

    WORD32 i4_alpha_stim_multiplier,

    UWORD8 u1_is_cu_noisy,

#endif

    UWORD8 u1_chroma_processing_enabled,

    UWORD8 u1_compute_spatial_ssd)

{

    UWORD8 u1_is_recon_available;

    void *pv_src = ps_buffer_data->s_src_pred_rec_buf_luma.pv_src;

    void *pv_pred = ps_buffer_data->s_src_pred_rec_buf_luma.pv_pred;

    void *pv_recon = ps_buffer_data->s_src_pred_rec_buf_luma.pv_recon;

    WORD16 *pi2_deq_data = ps_buffer_data->pi2_deq_data;

    UWORD8 *pu1_ecd = ps_buffer_data->ppu1_ecd[0];

    WORD32 i4_src_stride = ps_buffer_data->s_src_pred_rec_buf_luma.i4_src_stride;

    WORD32 i4_pred_stride = ps_buffer_data->s_src_pred_rec_buf_luma.i4_pred_stride;

    WORD32 i4_recon_stride = ps_buffer_data->s_src_pred_rec_buf_luma.i4_recon_stride;

    WORD32 i4_deq_data_stride = ps_buffer_data->i4_deq_data_stride;

    UWORD8 u1_size = ps_node->s_luma_data.u1_size;

    UWORD8 u1_posx = ps_node->s_luma_data.u1_posx;

    UWORD8 u1_posy = ps_node->s_luma_data.u1_posy;

    WORD32 trans_size = (64 == u1_size) ? 32 : u1_size;

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

    (void)pu1_cabac_ctxt;

    {

        pv_src = ((UWORD8 *)pv_src) + u1_posx + u1_posy * i4_src_stride;

        pv_pred = ((UWORD8 *)pv_pred) + u1_posx + u1_posy * i4_pred_stride;

        pv_recon = ((UWORD8 *)pv_recon) + u1_posx + u1_posy * i4_recon_stride;

    }

    pi2_deq_data += u1_posx + u1_posy * i4_deq_data_stride;

    /*2 Multi- dimensinal array based on trans size  of rounding factor to be added here */

    /* arrays are for rounding factor corr. to 0-1 decision and 1-2 decision */

    /* Currently the complete array will contain only single value*/

    /*The rounding factor is calculated with the formula

    Deadzone val = (((R1 - R0) * (2^(-8/3)) * lamMod) + 1)/2

    rounding factor = (1 - DeadZone Val)

    Assumption: Cabac states of All the sub-blocks in the TU are considered independent

    */

    if((ps_ctxt->i4_quant_rounding_level == TU_LEVEL_QUANT_ROUNDING) &&

       (ps_node->s_luma_data.u1_posx || ps_node->s_luma_data.u1_posy))

    {

        double i4_lamda_modifier;

        if((BSLICE == ps_ctxt->i1_slice_type) && (ps_ctxt->i4_temporal_layer_id))

        {

            i4_lamda_modifier = ps_ctxt->i4_lamda_modifier *

                                CLIP3((((double)(ps_ctxt->i4_cu_qp - 12)) / 6.0), 2.00, 4.00);

        }

        else

        {

            i4_lamda_modifier = ps_ctxt->i4_lamda_modifier;

        }

        if(ps_ctxt->i4_use_const_lamda_modifier)

        {

            if(ISLICE == ps_ctxt->i1_slice_type)

            {

                i4_lamda_modifier = ps_ctxt->f_i_pic_lamda_modifier;

            }

            else

            {

                i4_lamda_modifier = CONST_LAMDA_MOD_VAL;

            }

        }

        ps_ctxt->pi4_quant_round_factor_tu_0_1[trans_size >> 3] = &ps_ctxt->i4_quant_round_tu[0][0];

        ps_ctxt->pi4_quant_round_factor_tu_1_2[trans_size >> 3] = &ps_ctxt->i4_quant_round_tu[1][0];

        memset(

            ps_ctxt->pi4_quant_round_factor_tu_0_1[trans_size >> 3],

            0,

            trans_size * trans_size * sizeof(WORD32));

        memset(

            ps_ctxt->pi4_quant_round_factor_tu_1_2[trans_size >> 3],

            0,

            trans_size * trans_size * sizeof(WORD32));

        ihevce_quant_rounding_factor_gen(

            trans_size,

            1,

            &ps_ctxt->s_rdopt_entropy_ctxt,

            ps_ctxt->pi4_quant_round_factor_tu_0_1[trans_size >> 3],

            ps_ctxt->pi4_quant_round_factor_tu_1_2[trans_size >> 3],

            i4_lamda_modifier,

            1);

    }

    else

    {

        ps_ctxt->pi4_quant_round_factor_tu_0_1[trans_size >> 3] =

            ps_ctxt->pi4_quant_round_factor_cu_ctb_0_1[trans_size >> 3];

        ps_ctxt->pi4_quant_round_factor_tu_1_2[trans_size >> 3] =

            ps_ctxt->pi4_quant_round_factor_cu_ctb_1_2[trans_size >> 3];

    }

#if ENABLE_INTER_ZCU_COST

    ps_ctxt->i8_cu_not_coded_cost = 0;

#endif

    {

        ps_node->s_luma_data.u1_cbf = ihevce_t_q_iq_ssd_scan_fxn(

            ps_ctxt,

            (UWORD8 *)pv_pred,

            i4_pred_stride,

            (UWORD8 *)pv_src,

            i4_src_stride,

            pi2_deq_data,

            i4_deq_data_stride,

            (UWORD8 *)pv_recon,

            i4_recon_stride,

            pu1_ecd,

            ps_ctxt->au1_cu_csbf,

            ps_ctxt->i4_cu_csbf_strd,

            u1_size,

            i4_pred_mode,

            &ps_node->s_luma_data.i8_ssd,

            &ps_node->s_luma_data.i4_num_bytes_used_for_ecd,

            &ps_node->s_luma_data.i4_bits,

            &ps_node->s_luma_data.u4_sad,

            &ps_node->s_luma_data.i4_zero_col,

            &ps_node->s_luma_data.i4_zero_row,

            &u1_is_recon_available,

            ps_ctxt->s_rdoq_sbh_ctxt.i4_perform_all_cand_rdoq,

            ps_ctxt->s_rdoq_sbh_ctxt.i4_perform_all_cand_sbh,

#if USE_NOISE_TERM_IN_ZERO_CODING_DECISION_ALGORITHMS

            i4_alpha_stim_multiplier,

            u1_is_cu_noisy,

#endif

            u1_compute_spatial_ssd ? SPATIAL_DOMAIN_SSD : FREQUENCY_DOMAIN_SSD,

            1);

    }

#if ENABLE_INTER_ZCU_COST

    ps_node->s_luma_data.i8_not_coded_cost = ps_ctxt->i8_cu_not_coded_cost;

#endif

    if(u1_compute_spatial_ssd && u1_is_recon_available)

    {

        ps_node->s_luma_data.u1_reconBufId = 0;

    }

    else

    {

        ps_node->s_luma_data.u1_reconBufId = UCHAR_MAX;

    }

    ps_node->s_luma_data.i8_cost =

        ps_node->s_luma_data.i8_ssd +

        COMPUTE_RATE_COST_CLIP30(

            ps_node->s_luma_data.i4_bits, ps_ctxt->i8_cl_ssd_lambda_qf, LAMBDA_Q_SHIFT);

    pu1_ecd += ps_node->s_luma_data.i4_num_bytes_used_for_ecd;

    if(u1_chroma_processing_enabled &&

       ((!(u1_posx % 8) && !(u1_posy % 8) && (4 == u1_size)) || (u1_size > 4)))

    {

        UWORD8 i;

        void *pv_chroma_src;

        void *pv_chroma_pred;

        void *pv_chroma_recon;

        WORD16 *pi2_deq_data_chroma;

        WORD32 i4_chroma_src_stride = ps_buffer_data->s_src_pred_rec_buf_chroma.i4_src_stride;

        WORD32 i4_chroma_pred_stride = ps_buffer_data->s_src_pred_rec_buf_chroma.i4_pred_stride;

        WORD32 i4_chroma_recon_stride = ps_buffer_data->s_src_pred_rec_buf_chroma.i4_recon_stride;

        WORD32 i4_deq_data_stride_chroma = ps_buffer_data->i4_deq_data_stride_chroma;

        /* SubTU loop */

        for(i = 0; i < u1_is_422 + 1; i++)

        {

            UWORD8 u1_chroma_size = ps_node->as_cb_data[i].u1_size;

            UWORD8 u1_chroma_posx = ps_node->as_cb_data[i].u1_posx;

            UWORD8 u1_chroma_posy = ps_node->as_cb_data[i].u1_posy;

#if ENABLE_INTER_ZCU_COST

            ps_ctxt->i8_cu_not_coded_cost = 0;

#endif

            pi2_deq_data_chroma = ps_buffer_data->pi2_deq_data_chroma + (u1_chroma_posx * 2) +

                                  u1_chroma_posy * i4_deq_data_stride_chroma;

            {

                pv_chroma_src = ((UWORD8 *)ps_buffer_data->s_src_pred_rec_buf_chroma.pv_src) +

                                (u1_chroma_posx * 2) + u1_chroma_posy * i4_chroma_src_stride;

                pv_chroma_pred = ((UWORD8 *)ps_buffer_data->s_src_pred_rec_buf_chroma.pv_pred) +

                                 (u1_chroma_posx * 2) + u1_chroma_posy * i4_chroma_pred_stride;

                pv_chroma_recon = ((UWORD8 *)ps_buffer_data->s_src_pred_rec_buf_chroma.pv_recon) +

                                  (u1_chroma_posx * 2) + u1_chroma_posy * i4_chroma_recon_stride;

                ps_node->as_cb_data[i].u1_cbf = ihevce_chroma_t_q_iq_ssd_scan_fxn(

                    ps_ctxt,

                    (UWORD8 *)pv_chroma_pred,

                    i4_chroma_pred_stride,

                    (UWORD8 *)pv_chroma_src,

                    i4_chroma_src_stride,

                    pi2_deq_data_chroma,

                    i4_deq_data_stride_chroma,

                    (UWORD8 *)pv_chroma_recon,

                    i4_chroma_recon_stride,

                    pu1_ecd,

                    ps_ctxt->au1_cu_csbf,

                    ps_ctxt->i4_cu_csbf_strd,

                    u1_chroma_size,

                    SCAN_DIAG_UPRIGHT,

                    0,

                    &ps_node->as_cb_data[i].i4_num_bytes_used_for_ecd,

                    &ps_node->as_cb_data[i].i4_bits,

                    &ps_node->as_cb_data[i].i4_zero_col,

                    &ps_node->as_cb_data[i].i4_zero_row,

                    &u1_is_recon_available,

                    ps_ctxt->s_rdoq_sbh_ctxt.i4_perform_all_cand_rdoq,

                    ps_ctxt->s_rdoq_sbh_ctxt.i4_perform_all_cand_sbh,

                    &ps_node->as_cb_data[i].i8_ssd,

#if USE_NOISE_TERM_IN_ZERO_CODING_DECISION_ALGORITHMS

                    i4_alpha_stim_multiplier,

                    u1_is_cu_noisy,

#endif

                    i4_pred_mode == PRED_MODE_SKIP,

                    u1_compute_spatial_ssd ? SPATIAL_DOMAIN_SSD : FREQUENCY_DOMAIN_SSD,