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

 *

 * Copyright (C) 2022 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

*  isvce_intra_modes_eval.c

*

* @brief

*  This file contains definitions of routines that perform rate distortion

*  analysis on a macroblock if they are to be coded as intra.

*

* @author

*  ittiam

*

* @par List of Functions:

*  - isvce_derive_neighbor_availability_of_mbs()

*  - isvce_derive_ngbr_avbl_of_mb_partitions()

*  - isvce_evaluate_intra16x16_modes_for_least_cost_rdoptoff()

*  - isvce_evaluate_intra8x8_modes_for_least_cost_rdoptoff()

*  - isvce_evaluate_intra4x4_modes_for_least_cost_rdoptoff()

*  - isvce_evaluate_intra4x4_modes_for_least_cost_rdopton()

*  - isvce_evaluate_chroma_intra8x8_modes_for_least_cost_rdoptoff()

*  - isvce_evaluate_intra16x16_modes()

*  - isvce_evaluate_intra4x4_modes()

*  - isvce_evaluate_intra_chroma_modes()

*

* @remarks

*  None

*

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <limits.h>

#include <assert.h>

/* User include files */

#include "ih264e_config.h"

#include "ih264_typedefs.h"

#include "iv2.h"

#include "ive2.h"

#include "ih264_debug.h"

#include "isvc_defs.h"

#include "isvc_macros.h"

#include "ih264_intra_pred_filters.h"

#include "isvc_structs.h"

#include "isvc_common_tables.h"

#include "isvc_trans_quant_itrans_iquant.h"

#include "isvc_inter_pred_filters.h"

#include "isvc_mem_fns.h"

#include "ih264_padding.h"

#include "ih264_size_defs.h"

#include "ih264_deblk_edge_filters.h"

#include "isvc_cabac_tables.h"

#include "isvce_defs.h"

#include "ime_distortion_metrics.h"

#include "ih264e_error.h"

#include "ih264e_bitstream.h"

#include "ime_defs.h"

#include "ime_structs.h"

#include "irc_cntrl_param.h"

#include "irc_frame_info_collector.h"

#include "isvce_rate_control.h"

#include "isvce_cabac_structs.h"

#include "isvce_structs.h"

#include "ih264e_intra_modes_eval.h"

#include "isvce_globals.h"

#include "ime_platform_macros.h"

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

/* Function Definitions                                                      */

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

/**

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

*

* @brief

*  derivation process for subblock/partition availability

*

* @par   Description

*  Calculates the availability of the left, top, topright and topleft subblock

*  or partitions.

*

* @param[in]    ps_proc_ctxt

*  pointer to macroblock context (handle)

*

* @param[in]    i1_pel_pos_x

*  column position of the pel wrt the current block

*

* @param[in]    i1_pel_pos_y

*  row position of the pel in wrt current block

*

* @remarks     Assumptions: before calling this function it is assumed that

*   the neighbor availability of the current macroblock is already derived.

*   Based on table 6-3 of H264 specification

*

* @return      availability status (yes or no)

*

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

*/

UWORD8 isvce_derive_ngbr_avbl_of_mb_partitions(block_neighbors_t *ps_ngbr_avbl, WORD8 i1_pel_pos_x,

                                               WORD8 i1_pel_pos_y)

{

    UWORD8 u1_neighbor_avail = 0;

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

    /* values of i1_pel_pos_x in the range 0-15 inclusive correspond to   */

    /* various columns of a macroblock                                    */

    /*                                                                    */

    /* values of i1_pel_pos_y in the range 0-15 inclusive correspond to   */

    /* various rows of a macroblock                                       */

    /*                                                                    */

    /* other values of i1_pel_pos_x & i1_pel_pos_y represents elements    */

    /* outside the bound of an mb ie., represents its neighbors.          */

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

    if(i1_pel_pos_x < 0)

    { /* column(-1) */

        if(i1_pel_pos_y < 0)

        {                                              /* row(-1) */

            u1_neighbor_avail = ps_ngbr_avbl->u1_mb_d; /* current mb topleft availability */

        }

        else if(i1_pel_pos_y >= 0 && i1_pel_pos_y < 16)

        {                                              /* all rows of a macroblock */

            u1_neighbor_avail = ps_ngbr_avbl->u1_mb_a; /* current mb left availability */

        }

        else                       /* if (i1_pel_pos_y >= 16) */

        {                          /* rows(+16) */

            u1_neighbor_avail = 0; /* current mb bottom left availability */

        }

    }

    else if(i1_pel_pos_x >= 0 && i1_pel_pos_x < 16)

    { /* all columns of a macroblock */

        if(i1_pel_pos_y < 0)

        {                                              /* row(-1) */

            u1_neighbor_avail = ps_ngbr_avbl->u1_mb_b; /* current mb top availability */

        }

        else if(i1_pel_pos_y >= 0 && i1_pel_pos_y < 16)

        {                          /* all rows of a macroblock */

            u1_neighbor_avail = 1; /* current mb availability */

            /* availability of the partition is dependent on the position of the

             * partition inside the mb */

            /* although the availability is declared as 1 in all cases these needs to

             * be corrected somewhere else and this is not done in here */

        }

        else                       /* if (i1_pel_pos_y >= 16) */

        {                          /* rows(+16) */

            u1_neighbor_avail = 0; /* current mb bottom availability */

        }

    }

    else if(i1_pel_pos_x >= 16)

    { /* column(+16) */

        if(i1_pel_pos_y < 0)

        {                                              /* row(-1) */

            u1_neighbor_avail = ps_ngbr_avbl->u1_mb_c; /* current mb top right availability */

        }

        else                       /* if (i1_pel_pos_y >= 0) */

        {                          /* all other rows */

            u1_neighbor_avail = 0; /* current mb right & bottom right availability */

        }

    }

    return u1_neighbor_avail;

}

/**

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

*

* @brief

*  evaluate best intra 16x16 mode (rate distortion opt off)

*

* @par Description

*  This function evaluates all the possible intra 16x16 modes and finds the mode

*  that best represents the macro-block (least distortion) and occupies fewer

*  bits in the bit-stream.

*

* @param[in]   ps_proc_ctxt

*  pointer to process context (handle)

*

* @remarks

*  Ideally the cost of encoding a macroblock is calculated as

*  (distortion + lambda*rate). Where distortion is SAD/SATD,... between the

*  input block and the reconstructed block and rate is the number of bits taken

*  to place the macroblock in the bit-stream. In this routine the rate does not

*  exactly point to the total number of bits it takes, rather it points to

*header bits necessary for encoding the macroblock. Assuming the deltaQP, cbp

*bits and residual bits fall in to texture bits the number of bits taken to

*encoding mbtype is considered as rate, we compute cost. Further we will

*approximate the distortion as the deviation b/w input and the predicted block

*as opposed to input and reconstructed block.

*

*  NOTE: As per the Document JVT-O079, for intra 16x16 macroblock,

*  the SAD and cost are one and the same.

*

* @return     none

*

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

*/

void isvce_evaluate_intra16x16_modes_for_least_cost_rdoptoff(isvce_process_ctxt_t *ps_proc)

{

    /* Codec Context */

    isvce_codec_t *ps_codec = ps_proc->ps_codec;

    isa_dependent_fxns_t *ps_isa_dependent_fxns = &ps_codec->s_isa_dependent_fxns;

    mem_fxns_t *ps_mem_fxns = &ps_isa_dependent_fxns->s_mem_fxns;

    /* SAD(distortion metric) of an 8x8 block */

    WORD32 i4_mb_distortion = INT_MAX, i4_mb_distortion_least = INT_MAX;

    /* lambda */

    UWORD32 u4_lambda = ps_proc->u4_lambda;

    /* cost = distortion + lambda*rate */

    WORD32 i4_mb_cost = INT_MAX, i4_mb_cost_least = INT_MAX;

    /* intra mode */

    UWORD32 u4_intra_mode, u4_best_intra_16x16_mode = DC_I16x16;

    /* neighbor pels for intra prediction */

    UWORD8 *pu1_ngbr_pels_i16 = ps_proc->au1_ngbr_pels;

    /* neighbor availability */

    WORD32 i4_ngbr_avbl;

    /* pointer to src macro block */

    UWORD8 *pu1_curr_mb = ps_proc->s_src_buf_props.as_component_bufs[0].pv_data;

    UWORD8 *pu1_ref_mb = ps_proc->s_rec_buf_props.as_component_bufs[0].pv_data;

    /* pointer to prediction macro block */

    UWORD8 *pu1_pred_mb_intra_16x16 = ps_proc->pu1_pred_mb_intra_16x16;

    UWORD8 *pu1_pred_mb_intra_16x16_plane = ps_proc->pu1_pred_mb_intra_16x16_plane;

    /* strides */

    WORD32 i4_src_strd = ps_proc->s_src_buf_props.as_component_bufs[0].i4_data_stride;

    WORD32 i4_pred_strd = ps_proc->i4_pred_strd;

    WORD32 i4_rec_strd = ps_proc->s_rec_buf_props.as_component_bufs[0].i4_data_stride;

    /* pointer to neighbors left, top, topleft */

    UWORD8 *pu1_mb_a = pu1_ref_mb - 1;

    UWORD8 *pu1_mb_b = pu1_ref_mb - i4_rec_strd;

    UWORD8 *pu1_mb_d = pu1_mb_b - 1;

    UWORD8 u1_mb_a, u1_mb_b, u1_mb_d;

    /* valid intra modes map */

    UWORD32 u4_valid_intra_modes;

    /* lut for valid intra modes */

    const UWORD8 u1_valid_intra_modes[8] = {4, 6, 4, 6, 5, 7, 5, 15};

    UWORD32 i, u4_enable_fast_sad = 0, offset = 0;

    isvce_mb_info_t *ps_top_mb_syn_ele = ps_proc->s_nbr_info.ps_top_row_mb_info + ps_proc->i4_mb_x;

    UWORD32 u4_constrained_intra_pred =

        ps_codec->au4_constrained_intra_pred[ps_proc->u1_spatial_layer_id];

    if(ps_proc->i4_slice_type != ISLICE)

    {

        /* Offset for MBtype */

        offset = (ps_proc->i4_slice_type == PSLICE) ? 5 : 23;

        u4_enable_fast_sad = ps_proc->s_me_ctxt.u4_enable_fast_sad;

    }

    /* locating neighbors that are available for prediction */

    /* gather prediction pels from the neighbors, if particular set is not

     * available it is set to zero*/

    /* left pels */

    u1_mb_a =

        ((ps_proc->ps_ngbr_avbl->u1_mb_a) &&

         (u4_constrained_intra_pred ? (ps_proc->s_nbr_info.ps_left_mb_info->u1_is_intra &&

                                       !ps_proc->s_nbr_info.ps_left_mb_info->u1_base_mode_flag)

                                    : 1));

    if(u1_mb_a)

    {

        for(i = 0; i < 16; i++) pu1_ngbr_pels_i16[16 - 1 - i] = pu1_mb_a[i * i4_rec_strd];

    }

    else

    {

        ps_mem_fxns->pf_mem_set_mul8(pu1_ngbr_pels_i16, 0, MB_SIZE);

    }

    /* top pels */

    u1_mb_b = ((ps_proc->ps_ngbr_avbl->u1_mb_b) &&

               (u4_constrained_intra_pred

                    ? (ps_top_mb_syn_ele->u1_is_intra && !ps_top_mb_syn_ele->u1_base_mode_flag)

                    : 1));

    if(u1_mb_b)

    {

        ps_mem_fxns->pf_mem_cpy_mul8(pu1_ngbr_pels_i16 + 16 + 1, pu1_mb_b, 16);

    }

    else

    {

        ps_mem_fxns->pf_mem_set_mul8(pu1_ngbr_pels_i16 + 16 + 1, 0, MB_SIZE);

    }

    /* topleft pels */

    u1_mb_d = ((ps_proc->ps_ngbr_avbl->u1_mb_d) &&

               (u4_constrained_intra_pred ? (ps_top_mb_syn_ele[-1].u1_is_intra &&

                                             !ps_top_mb_syn_ele[-1].u1_base_mode_flag)

                                          : 1));

    if(u1_mb_d)

    {

        pu1_ngbr_pels_i16[16] = *pu1_mb_d;

    }

    else

    {

        pu1_ngbr_pels_i16[16] = 0;

    }

    i4_ngbr_avbl = (u1_mb_a) + (u1_mb_b << 2) + (u1_mb_d << 1);

    ps_proc->i4_ngbr_avbl_16x16_mb = i4_ngbr_avbl;

    /* set valid intra modes for evaluation */

    u4_valid_intra_modes = u1_valid_intra_modes[i4_ngbr_avbl];

    if(ps_codec->s_cfg.u4_enc_speed_preset == IVE_FAST ||

       ps_codec->s_cfg.u4_enc_speed_preset == IVE_FASTEST)

        u4_valid_intra_modes &= ~(1 << PLANE_I16x16);

    /* evaluate b/w HORZ_I16x16, VERT_I16x16 & DC_I16x16 */

    ps_codec->pf_ih264e_evaluate_intra16x16_modes(

        pu1_curr_mb, pu1_ngbr_pels_i16, pu1_pred_mb_intra_16x16, i4_src_strd, i4_pred_strd,

        i4_ngbr_avbl, &u4_intra_mode, &i4_mb_distortion_least, u4_valid_intra_modes);

    /* cost = distortion + lambda*rate */

    i4_mb_cost_least = i4_mb_distortion_least;

    if(((u4_valid_intra_modes >> 3) & 1) != 0)

    {

        /* intra prediction for PLANE mode*/

        (ps_codec->apf_intra_pred_16_l)[PLANE_I16x16](

            pu1_ngbr_pels_i16, pu1_pred_mb_intra_16x16_plane, 0, i4_pred_strd, i4_ngbr_avbl);

        /* evaluate distortion between the actual blk and the estimated blk for the

         * given mode */

        ps_codec->apf_compute_sad_16x16[u4_enable_fast_sad](

            pu1_curr_mb, pu1_pred_mb_intra_16x16_plane, i4_src_strd, i4_pred_strd, i4_mb_cost_least,

            &i4_mb_distortion);

        /* cost = distortion + lambda*rate */

        i4_mb_cost = i4_mb_distortion;

        /* update the least cost information if necessary */

        if(i4_mb_cost < i4_mb_distortion_least)

        {

            u4_intra_mode = PLANE_I16x16;

            i4_mb_cost_least = i4_mb_cost;

            i4_mb_distortion_least = i4_mb_distortion;

        }

    }

    u4_best_intra_16x16_mode = u4_intra_mode;

    DEBUG("%d partition cost, %d intra mode\n", i4_mb_cost_least * 32, u4_best_intra_16x16_mode);

    ps_proc->u1_l_i16_mode = u4_best_intra_16x16_mode;

    /* cost = distortion + lambda*rate */

    i4_mb_cost_least =

        i4_mb_distortion_least + u4_lambda * u1_uev_codelength[offset + u4_best_intra_16x16_mode];

    /* update the type of the mb if necessary */

    if(i4_mb_cost_least < ps_proc->i4_mb_cost)

    {

        ps_proc->i4_mb_cost = i4_mb_cost_least;

        ps_proc->i4_mb_distortion = i4_mb_distortion_least;

        ps_proc->ps_mb_info->u2_mb_type = I16x16;

    }

}

/**

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

*

* @brief

*  evaluate best intra 8x8 mode (rate distortion opt on)

*

* @par Description

*  This function evaluates all the possible intra 8x8 modes and finds the mode

*  that best represents the macro-block (least distortion) and occupies fewer

*  bits in the bit-stream.

*

* @param[in]    ps_proc_ctxt

*  pointer to proc ctxt

*

* @remarks Ideally the cost of encoding a macroblock is calculated as

*  (distortion + lambda*rate). Where distortion is SAD/SATD,... between the

*  input block and the reconstructed block and rate is the number of bits taken

*  to place the macroblock in the bit-stream. In this routine the rate does not

*  exactly point to the total number of bits it takes, rather it points to

*header bits necessary for encoding the macroblock. Assuming the deltaQP, cbp

*bits and residual bits fall in to texture bits the number of bits taken to

*encoding mbtype is considered as rate, we compute cost. Further we will

*approximate the distortion as the deviation b/w input and the predicted block

*as opposed to input and reconstructed block.

*

*  NOTE: TODO: This function needs to be tested

*

*  @return      none

*

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

*/

void isvce_evaluate_intra8x8_modes_for_least_cost_rdoptoff(isvce_process_ctxt_t *ps_proc)

{

    /* Codec Context */

    isvce_codec_t *ps_codec = ps_proc->ps_codec;

    /* SAD(distortion metric) of an 4x4 block */

    WORD32 i4_partition_distortion, i4_partition_distortion_least = INT_MAX,

                                    i4_total_distortion = 0;

    /* lambda */

    UWORD32 u4_lambda = ps_proc->u4_lambda;

    /* cost = distortion + lambda*rate */

    WORD32 i4_partition_cost, i4_partition_cost_least, i4_total_cost = u4_lambda;

    /* cost due to mbtype */

    UWORD32 u4_cost_one_bit = u4_lambda, u4_cost_four_bits = 4 * u4_lambda;

    /* intra mode */

    UWORD32 u4_intra_mode, u4_best_intra_8x8_mode = DC_I8x8, u4_estimated_intra_8x8_mode;

    /* neighbor pels for intra prediction */

    UWORD8 *pu1_ngbr_pels_i8 = ps_proc->au1_ngbr_pels;

    /* pointer to curr partition */

    UWORD8 *pu1_mb_curr;

    /* pointer to prediction macro block */

    UWORD8 *pu1_pred_mb = ps_proc->pu1_pred_mb;

    /* strides */

    WORD32 i4_src_strd = ps_proc->s_src_buf_props.as_component_bufs[0].i4_data_stride;

    WORD32 i4_pred_strd = ps_proc->i4_pred_strd;

    /* neighbors left, top, top right, top left */

    UWORD8 *pu1_mb_a;

    UWORD8 *pu1_mb_b;

    UWORD8 *pu1_mb_d;

    /* neighbor availability */

    WORD32 i4_ngbr_avbl;

    block_neighbors_t s_ngbr_avbl;

    /* temp vars */

    UWORD32 b8, u4_pix_x, u4_pix_y;

    UWORD32 u4_constrained_intra_pred =

        ps_codec->au4_constrained_intra_pred[ps_proc->u1_spatial_layer_id];

    block_neighbors_t s_ngbr_avbl_MB;

    /* ngbr mb syntax information */

    UWORD8 *pu1_top_mb_intra_modes =

        ps_proc->s_nbr_info.ps_top_mb_intra_modes[ps_proc->i4_mb_x].au1_intra_modes;

    isvce_mb_info_t *ps_top_mb_syn_ele = ps_proc->s_nbr_info.ps_top_row_mb_info + ps_proc->i4_mb_x;

    isvce_mb_info_t *ps_top_right_mb_syn_ele = ps_top_mb_syn_ele + 1;

    /* valid intra modes map */

    UWORD32 u4_valid_intra_modes;

    if(ps_proc->ps_ngbr_avbl->u1_mb_c)

    {

        ps_top_right_mb_syn_ele = ps_top_mb_syn_ele + 1;

    }

    /* left pels */

    s_ngbr_avbl_MB.u1_mb_a =

        ((ps_proc->ps_ngbr_avbl->u1_mb_a) &&

         (u4_constrained_intra_pred ? (ps_proc->s_nbr_info.ps_left_mb_info->u1_is_intra &&

                                       !ps_proc->s_nbr_info.ps_left_mb_info->u1_base_mode_flag)

                                    : 1));

    /* top pels */

    s_ngbr_avbl_MB.u1_mb_b = ((ps_proc->ps_ngbr_avbl->u1_mb_b) &&

                              (u4_constrained_intra_pred ? (ps_top_mb_syn_ele->u1_is_intra &&

                                                            !ps_top_mb_syn_ele->u1_base_mode_flag)

                                                         : 1));

    /* topleft pels */

    s_ngbr_avbl_MB.u1_mb_d =

        ((ps_proc->ps_ngbr_avbl->u1_mb_d) &&

         (u4_constrained_intra_pred

              ? (ps_top_mb_syn_ele[-1].u1_is_intra && !ps_top_mb_syn_ele[-1].u1_base_mode_flag)

              : 1));

    /* top right */

    s_ngbr_avbl_MB.u1_mb_c =

        ((ps_proc->ps_ngbr_avbl->u1_mb_c) &&

         (u4_constrained_intra_pred ? (ps_top_right_mb_syn_ele->u1_is_intra &&

                                       !ps_top_right_mb_syn_ele->u1_base_mode_flag)

                                    : 1));

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

    {

        u4_pix_x = (b8 & 0x01) << 3;

        u4_pix_y = (b8 >> 1) << 3;

        pu1_mb_curr = ((UWORD8 *) ps_proc->s_src_buf_props.as_component_bufs[0].pv_data) +

                      u4_pix_x + (u4_pix_y * i4_src_strd);

        /* when rdopt is off, we use the input as reference for constructing

         * prediction buffer */

        /* as opposed to using the recon pels. (open loop intra prediction) */

        pu1_mb_a = pu1_mb_curr - 1;           /* pointer to left macro block */

        pu1_mb_b = pu1_mb_curr - i4_src_strd; /* pointer to top macro block */

        pu1_mb_d = pu1_mb_b - 1;              /* pointer to top left macro block */

        /* locating neighbors that are available for prediction */

        /* TODO : update the neighbor availability information basing on constrained

         * intra pred information */

        /* TODO : i4_ngbr_avbl is only being used in DC mode. Can the DC mode be

         * split in to distinct routines */

        /* basing on neighbors available and hence evade the computation of neighbor

         * availability totally. */

        s_ngbr_avbl.u1_mb_a = isvce_derive_ngbr_avbl_of_mb_partitions(

            &s_ngbr_avbl_MB, u4_pix_x - 1, u4_pix_y); /* xD = -1, yD = 0 */

        s_ngbr_avbl.u1_mb_b = isvce_derive_ngbr_avbl_of_mb_partitions(

            &s_ngbr_avbl_MB, u4_pix_x, u4_pix_y - 1); /* xD = 0, yD = -1 */

        s_ngbr_avbl.u1_mb_c = isvce_derive_ngbr_avbl_of_mb_partitions(

            &s_ngbr_avbl_MB, u4_pix_x + 8, u4_pix_y - 1); /* xD = BLK_8x8_SIZE, yD = -1 */

        s_ngbr_avbl.u1_mb_d = isvce_derive_ngbr_avbl_of_mb_partitions(

            &s_ngbr_avbl_MB, u4_pix_x - 1, u4_pix_y - 1); /* xD = -1, yD = -1 */

        /* i4_ngbr_avbl = blk_a * LEFT_MB_AVAILABLE_MASK + blk_b *

         * TOP_MB_AVAILABLE_MASK + blk_c * TOP_RIGHT_MB_AVAILABLE_MASK + blk_d *

         * TOP_LEFT_MB_AVAILABLE_MASK */

        i4_ngbr_avbl = (s_ngbr_avbl.u1_mb_a) + (s_ngbr_avbl.u1_mb_d << 1) +

                       (s_ngbr_avbl.u1_mb_b << 2) + (s_ngbr_avbl.u1_mb_c << 3) +

                       (s_ngbr_avbl.u1_mb_a << 4);

        /* if top partition is available and top right is not available for intra

         * prediction, then */

        /* padd top right samples using top sample and make top right also available

         */

        /* i4_ngbr_avbl = (s_ngbr_avbl.u1_mb_a) + (s_ngbr_avbl.u1_mb_d << 1) +

         * (s_ngbr_avbl.u1_mb_b << 2) +  ((s_ngbr_avbl.u1_mb_b |

         * s_ngbr_avbl.u1_mb_c) << 3); */

        ps_proc->ai4_neighbor_avail_8x8_subblks[b8] = i4_ngbr_avbl;

        ih264_intra_pred_luma_8x8_mode_ref_filtering(pu1_mb_a, pu1_mb_b, pu1_mb_d, pu1_ngbr_pels_i8,

                                                     i4_src_strd, i4_ngbr_avbl);

        i4_partition_cost_least = INT_MAX;

        /* set valid intra modes for evaluation */

        u4_valid_intra_modes = 0x1ff;

        if(!s_ngbr_avbl.u1_mb_b)

        {

            u4_valid_intra_modes &= ~(1 << VERT_I4x4);

            u4_valid_intra_modes &= ~(1 << DIAG_DL_I4x4);

            u4_valid_intra_modes &= ~(1 << VERT_L_I4x4);

        }

        if(!s_ngbr_avbl.u1_mb_a)

        {

            u4_valid_intra_modes &= ~(1 << HORZ_I4x4);

            u4_valid_intra_modes &= ~(1 << HORZ_U_I4x4);

        }

        if(!s_ngbr_avbl.u1_mb_a || !s_ngbr_avbl.u1_mb_b || !s_ngbr_avbl.u1_mb_d)

        {

            u4_valid_intra_modes &= ~(1 << DIAG_DR_I4x4);

            u4_valid_intra_modes &= ~(1 << VERT_R_I4x4);

            u4_valid_intra_modes &= ~(1 << HORZ_D_I4x4);

        }

        /* estimate the intra 8x8 mode for the current partition (for evaluating

         * cost) */

        if(!s_ngbr_avbl.u1_mb_a || !s_ngbr_avbl.u1_mb_b)

        {

            u4_estimated_intra_8x8_mode = DC_I8x8;

        }

        else

        {

            UWORD32 u4_left_intra_8x8_mode = DC_I8x8;

            UWORD32 u4_top_intra_8x8_mode = DC_I8x8;

            if(u4_pix_x == 0)

            {

                if(ps_proc->s_nbr_info.ps_left_mb_info->u2_mb_type == I8x8)

                {

                    u4_left_intra_8x8_mode =

                        ps_proc->s_nbr_info.ps_left_mb_intra_modes->au1_intra_modes[b8 + 1];

                }

                else if(ps_proc->s_nbr_info.ps_left_mb_info->u2_mb_type == I4x4)

                {

                    u4_left_intra_8x8_mode = ps_proc->s_nbr_info.ps_left_mb_intra_modes

                                                 ->au1_intra_modes[(b8 + 1) * 4 + 2];

                }

            }

            else

            {

                u4_left_intra_8x8_mode = ps_proc->au1_intra_luma_mb_8x8_modes[b8 - 1];

            }

            if(u4_pix_y == 0)

            {

                if(ps_top_mb_syn_ele->u2_mb_type == I8x8)

                {

                    u4_top_intra_8x8_mode = pu1_top_mb_intra_modes[b8 + 2];

                }

                else if(ps_top_mb_syn_ele->u2_mb_type == I4x4)

                {

                    u4_top_intra_8x8_mode = pu1_top_mb_intra_modes[(b8 + 2) * 4 + 2];

                }

            }

            else

            {

                u4_top_intra_8x8_mode = ps_proc->au1_intra_luma_mb_8x8_modes[b8 - 2];

            }

            u4_estimated_intra_8x8_mode = MIN(u4_left_intra_8x8_mode, u4_top_intra_8x8_mode);

        }

        /* perform intra mode 8x8 evaluation */

        for(u4_intra_mode = VERT_I8x8; u4_valid_intra_modes != 0;

            u4_intra_mode++, u4_valid_intra_modes >>= 1)

        {

            if((u4_valid_intra_modes & 1) == 0) continue;

            /* intra prediction */

            (ps_codec->apf_intra_pred_8_l)[u4_intra_mode](pu1_ngbr_pels_i8, pu1_pred_mb, 0,

                                                          i4_pred_strd, i4_ngbr_avbl);

            /* evaluate distortion between the actual blk and the estimated blk for

             * the given mode */

            ime_compute_sad_8x8(pu1_mb_curr, pu1_pred_mb, i4_src_strd, i4_pred_strd,

                                i4_partition_cost_least, &i4_partition_distortion);

            i4_partition_cost =

                i4_partition_distortion + ((u4_estimated_intra_8x8_mode == u4_intra_mode)

                                               ? u4_cost_one_bit

                                               : u4_cost_four_bits);

            /* update the least cost information if necessary */

            if(i4_partition_cost < i4_partition_cost_least)

            {

                i4_partition_cost_least = i4_partition_cost;

                i4_partition_distortion_least = i4_partition_distortion;

                u4_best_intra_8x8_mode = u4_intra_mode;

            }

        }

        /* macroblock distortion */

        i4_total_cost += i4_partition_cost_least;

        i4_total_distortion += i4_partition_distortion_least;

        /* mb partition mode */

        ps_proc->au1_intra_luma_mb_8x8_modes[b8] = u4_best_intra_8x8_mode;

    }

    /* update the type of the mb if necessary */

    if(i4_total_cost < ps_proc->i4_mb_cost)

    {

        ps_proc->i4_mb_cost = i4_total_cost;

        ps_proc->i4_mb_distortion = i4_total_distortion;

        ps_proc->ps_mb_info->u2_mb_type = I8x8;

    }

}

/**

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

*

* @brief

*  evaluate best intra 4x4 mode (rate distortion opt off)

*

* @par Description

*  This function evaluates all the possible intra 4x4 modes and finds the mode

*  that best represents the macro-block (least distortion) and occupies fewer

*  bits in the bit-stream.

*

* @param[in]    ps_proc_ctxt

*  pointer to proc ctxt

*

* @remarks

*  Ideally the cost of encoding a macroblock is calculated as

*  (distortion + lambda*rate). Where distortion is SAD/SATD,... between the

*  input block and the reconstructed block and rate is the number of bits taken

*  to place the macroblock in the bit-stream. In this routine the rate does not

*  exactly point to the total number of bits it takes, rather it points to

*header bits necessary for encoding the macroblock. Assuming the deltaQP, cbp

*bits and residual bits fall in to texture bits the number of bits taken to

*encoding mbtype is considered as rate, we compute cost. Further we will

*approximate the distortion as the deviation b/w input and the predicted block

*as opposed to input and reconstructed block.

*

*  NOTE: As per the Document JVT-O079, for the whole intra 4x4 macroblock,

*  24*lambda is added to the SAD before comparison with the best SAD for

*  inter prediction. This is an empirical value to prevent using too many intra

*  blocks.

*

* @return      none

*

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

*/

void isvce_evaluate_intra4x4_modes_for_least_cost_rdoptoff(isvce_process_ctxt_t *ps_proc)

{

    /* Codec Context */

    isvce_codec_t *ps_codec = ps_proc->ps_codec;

    /* SAD(distortion metric) of an 4x4 block */

    WORD32 i4_partition_distortion_least = INT_MAX, i4_total_distortion = 0;

    /* lambda */

    UWORD32 u4_lambda = ps_proc->u4_lambda;

    /* cost = distortion + lambda*rate */

    WORD32 i4_partition_cost_least, i4_total_cost = (24 + 1) * u4_lambda;

    /* cost due to mbtype */

    UWORD32 u4_cost_one_bit = u4_lambda, u4_cost_four_bits = 4 * u4_lambda;

    /* intra mode */

    UWORD32 u4_best_intra_4x4_mode = DC_I4x4, u4_estimated_intra_4x4_mode;

    /* neighbor pels for intra prediction */

    UWORD8 *pu1_ngbr_pels_i4 = ps_proc->au1_ngbr_pels;

    /* pointer to curr partition */

    UWORD8 *pu1_mb_curr;

    /* pointer to prediction macro block */

    UWORD8 *pu1_pred_mb = ps_proc->pu1_pred_mb;

    /* strides */

    WORD32 i4_src_strd = ps_proc->s_src_buf_props.as_component_bufs[0].i4_data_stride;

    WORD32 i4_pred_strd = ps_proc->i4_pred_strd;

    /* neighbors left, top, top right, top left */

    UWORD8 *pu1_mb_a;

    UWORD8 *pu1_mb_b;

    UWORD8 *pu1_mb_c;

    UWORD8 *pu1_mb_d;

    /* neighbor availability */

    WORD32 i4_ngbr_avbl;

    block_neighbors_t s_ngbr_avbl;

    /* temp vars */

    UWORD32 i, b8, b4, u4_blk_x, u4_blk_y, u4_pix_x, u4_pix_y;

    /* ngbr sub mb modes */

    UWORD8 *pu1_top_mb_intra_modes =

        ps_proc->s_nbr_info.ps_top_mb_intra_modes[ps_proc->i4_mb_x].au1_intra_modes;

    isvce_mb_info_t *ps_top_mb_syn_ele = ps_proc->s_nbr_info.ps_top_row_mb_info + ps_proc->i4_mb_x;

    isvce_mb_info_t *ps_top_right_mb_syn_ele = ps_top_mb_syn_ele + 1;

    /* valid intra modes map */

    UWORD32 u4_valid_intra_modes;

    UWORD16 u2_valid_modes[8] = {4, 262, 4, 262, 141, 399, 141, 511};

    UWORD32 u4_constrained_intra_pred =

        ps_codec->au4_constrained_intra_pred[ps_proc->u1_spatial_layer_id];

    UWORD8 u1_mb_a, u1_mb_b, u1_mb_c, u1_mb_d;

    if(ps_proc->ps_ngbr_avbl->u1_mb_c)

    {

        ps_top_right_mb_syn_ele = ps_top_mb_syn_ele + 1;

    }

    /* left pels */

    u1_mb_a =

        ((ps_proc->ps_ngbr_avbl->u1_mb_a) &&

         (u4_constrained_intra_pred ? (ps_proc->s_nbr_info.ps_left_mb_info->u1_is_intra &&

                                       !ps_proc->s_nbr_info.ps_left_mb_info->u1_base_mode_flag)

                                    : 1));

    /* top pels */

    u1_mb_b = ((ps_proc->ps_ngbr_avbl->u1_mb_b) &&

               (u4_constrained_intra_pred

                    ? (ps_top_mb_syn_ele->u1_is_intra && !ps_top_mb_syn_ele->u1_base_mode_flag)

                    : 1));

    /* topleft pels */

    u1_mb_d = ((ps_proc->ps_ngbr_avbl->u1_mb_d) &&

               (u4_constrained_intra_pred ? (ps_top_mb_syn_ele[-1].u1_is_intra &&

                                             !ps_top_mb_syn_ele[-1].u1_base_mode_flag)

                                          : 1));

    /* top right */

    u1_mb_c = ((ps_proc->ps_ngbr_avbl->u1_mb_c) &&

               (u4_constrained_intra_pred ? (ps_top_right_mb_syn_ele->u1_is_intra &&

                                             !ps_top_right_mb_syn_ele->u1_base_mode_flag)

                                          : 1));

    i4_ngbr_avbl = (u1_mb_a) + (u1_mb_d << 1) + (u1_mb_b << 2) + (u1_mb_c << 3);

    memcpy(ps_proc->au1_ngbr_avbl_4x4_subblks, gau1_ih264_4x4_ngbr_avbl[i4_ngbr_avbl], 16);

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

    {

        u4_blk_x = (b8 & 0x01) << 3;

        u4_blk_y = (b8 >> 1) << 3;

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

        {

            u4_pix_x = u4_blk_x + ((b4 & 0x01) << 2);

            u4_pix_y = u4_blk_y + ((b4 >> 1) << 2);

            pu1_mb_curr = ((UWORD8 *) ps_proc->s_src_buf_props.as_component_bufs[0].pv_data) +

                          u4_pix_x + (u4_pix_y * i4_src_strd);

            /* when rdopt is off, we use the input as reference for constructing

             * prediction buffer */

            /* as opposed to using the recon pels. (open loop intra prediction) */

            pu1_mb_a = pu1_mb_curr - 1;           /* pointer to left macro block */

            pu1_mb_b = pu1_mb_curr - i4_src_strd; /* pointer to top macro block */

            pu1_mb_c = pu1_mb_b + 4;              /* pointer to top macro block */

            pu1_mb_d = pu1_mb_b - 1;              /* pointer to top left macro block */

            /* locating neighbors that are available for prediction */

            /* TODO : update the neighbor availability information basing on

             * constrained intra pred information */

            /* TODO : i4_ngbr_avbl is only being used in DC mode. Can the DC mode be

             * split in to distinct routines */

            /* basing on neighbors available and hence evade the computation of

             * neighbor availability totally. */

            i4_ngbr_avbl = ps_proc->au1_ngbr_avbl_4x4_subblks[(b8 << 2) + b4];

            s_ngbr_avbl.u1_mb_a = (i4_ngbr_avbl & 0x1);

            s_ngbr_avbl.u1_mb_d = (i4_ngbr_avbl & 0x2) >> 1;

            s_ngbr_avbl.u1_mb_b = (i4_ngbr_avbl & 0x4) >> 2;

            s_ngbr_avbl.u1_mb_c = (i4_ngbr_avbl & 0x8) >> 3;

            /* set valid intra modes for evaluation */

            u4_valid_intra_modes = u2_valid_modes[i4_ngbr_avbl & 0x7];

            /* if top partition is available and top right is not available for intra

             * prediction, then */

            /* padd top right samples using top sample and make top right also

             * available */

            /* i4_ngbr_avbl = (s_ngbr_avbl.u1_mb_a) + (s_ngbr_avbl.u1_mb_d << 1) +

             * (s_ngbr_avbl.u1_mb_b << 2) + ((s_ngbr_avbl.u1_mb_b |

             * s_ngbr_avbl.u1_mb_c) << 3); */

            /* gather prediction pels from the neighbors */

            if(s_ngbr_avbl.u1_mb_a)

            {

                for(i = 0; i < 4; i++) pu1_ngbr_pels_i4[4 - 1 - i] = pu1_mb_a[i * i4_src_strd];

            }

            else

            {

                memset(pu1_ngbr_pels_i4, 0, 4);

            }

            if(s_ngbr_avbl.u1_mb_b)

            {

                memcpy(pu1_ngbr_pels_i4 + 4 + 1, pu1_mb_b, 4);

            }

            else

            {

                memset(pu1_ngbr_pels_i4 + 5, 0, 4);

            }

            if(s_ngbr_avbl.u1_mb_d)

                pu1_ngbr_pels_i4[4] = *pu1_mb_d;

            else

                pu1_ngbr_pels_i4[4] = 0;

            if(s_ngbr_avbl.u1_mb_c)

            {

                memcpy(pu1_ngbr_pels_i4 + 8 + 1, pu1_mb_c, 4);

            }

            else if(s_ngbr_avbl.u1_mb_b)

            {

                memset(pu1_ngbr_pels_i4 + 8 + 1, pu1_ngbr_pels_i4[8], 4);

                s_ngbr_avbl.u1_mb_c = s_ngbr_avbl.u1_mb_b;

            }

            i4_partition_cost_least = INT_MAX;

            /* predict the intra 4x4 mode for the current partition (for evaluating

             * cost) */

            if(!s_ngbr_avbl.u1_mb_a || !s_ngbr_avbl.u1_mb_b)

            {

                u4_estimated_intra_4x4_mode = DC_I4x4;

            }

            else

            {

                UWORD32 u4_left_intra_4x4_mode = DC_I4x4;

                UWORD32 u4_top_intra_4x4_mode = DC_I4x4;

                if(u4_pix_x == 0)

                {

                    if(ps_proc->s_nbr_info.ps_left_mb_info->u2_mb_type == I4x4)

                    {

                        u4_left_intra_4x4_mode =

                            ps_proc->s_nbr_info.ps_left_mb_intra_modes

                                ->au1_intra_modes[gau1_raster_to_zscan_map[3 + u4_pix_y]];

                    }

                    else if(ps_proc->s_nbr_info.ps_left_mb_info->u2_mb_type == I8x8)

                    {

                        u4_left_intra_4x4_mode =

                            ps_proc->s_nbr_info.ps_left_mb_intra_modes->au1_intra_modes[b8 + 1];

                    }

                }

                else

                {

                    u4_left_intra_4x4_mode =

                        ps_proc->au1_intra_luma_mb_4x4_modes

                            [gau1_raster_to_zscan_map[(u4_pix_x >> 2) + u4_pix_y - 1]];

                }

                if(u4_pix_y == 0)

                {

                    if(ps_top_mb_syn_ele->u2_mb_type == I4x4)

                    {

                        u4_top_intra_4x4_mode =

                            pu1_top_mb_intra_modes[gau1_raster_to_zscan_map[12 + (u4_pix_x >> 2)]];

                    }

                    else if(ps_top_mb_syn_ele->u2_mb_type == I8x8)

                    {

                        u4_top_intra_4x4_mode = pu1_top_mb_intra_modes[b8 + 2];

                    }

                }

                else

                {

                    u4_top_intra_4x4_mode =

                        ps_proc->au1_intra_luma_mb_4x4_modes

                            [gau1_raster_to_zscan_map[(u4_pix_x >> 2) + u4_pix_y - 4]];

                }

                u4_estimated_intra_4x4_mode = MIN(u4_left_intra_4x4_mode, u4_top_intra_4x4_mode);

            }

            ps_proc->au1_predicted_intra_luma_mb_4x4_modes[(b8 << 2) + b4] =

                u4_estimated_intra_4x4_mode;

            /* mode evaluation and prediction */

            ps_codec->pf_ih264e_evaluate_intra_4x4_modes(

                pu1_mb_curr, pu1_ngbr_pels_i4, pu1_pred_mb, i4_src_strd, i4_pred_strd, i4_ngbr_avbl,

                &u4_best_intra_4x4_mode, &i4_partition_cost_least, u4_valid_intra_modes, u4_lambda,

                u4_estimated_intra_4x4_mode);

            i4_partition_distortion_least =

                i4_partition_cost_least - ((u4_estimated_intra_4x4_mode == u4_best_intra_4x4_mode)

                                               ? u4_cost_one_bit

                                               : u4_cost_four_bits);

            DEBUG("%d partition cost, %d intra mode\n", i4_partition_cost_least,

                  u4_best_intra_4x4_mode);

            /* macroblock distortion */

            i4_total_distortion += i4_partition_distortion_least;

            i4_total_cost += i4_partition_cost_least;

            /* mb partition mode */

            ps_proc->au1_intra_luma_mb_4x4_modes[(b8 << 2) + b4] = u4_best_intra_4x4_mode;

        }

    }

    /* update the type of the mb if necessary */

    if(i4_total_cost < ps_proc->i4_mb_cost)

    {

        ps_proc->i4_mb_cost = i4_total_cost;

        ps_proc->i4_mb_distortion = i4_total_distortion;

        ps_proc->ps_mb_info->u2_mb_type = I4x4;

    }

}

/**

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

*

* @brief evaluate best intra 4x4 mode (rate distortion opt on)

*

* @par Description

*  This function evaluates all the possible intra 4x4 modes and finds the mode

*  that best represents the macro-block (least distortion) and occupies fewer

*  bits in the bit-stream.

*

* @param[in]    ps_proc_ctxt

*  pointer to proc ctxt

*

* @remarks

*  Ideally the cost of encoding a macroblock is calculated as

*  (distortion + lambda*rate). Where distortion is SAD/SATD,... between the

*  input block and the reconstructed block and rate is the number of bits taken

*  to place the macroblock in the bit-stream. In this routine the rate does not

*  exactly point to the total number of bits it takes, rather it points to

*header bits necessary for encoding the macroblock. Assuming the deltaQP, cbp

*bits and residual bits fall in to texture bits the number of bits taken to

*encoding mbtype is considered as rate, we compute cost. Further we will

*approximate the distortion as the deviation b/w input and the predicted block

*as opposed to input and reconstructed block.

*

*  NOTE: As per the Document JVT-O079, for the whole intra 4x4 macroblock,

*  24*lambda is added to the SAD before comparison with the best SAD for

*  inter prediction. This is an empirical value to prevent using too many intra

*  blocks.

*

* @return      none

*

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

*/

void isvce_evaluate_intra4x4_modes_for_least_cost_rdopton(isvce_process_ctxt_t *ps_proc)

{

    block_neighbors_t s_ngbr_avbl;

    buffer_container_t s_src;

    buffer_container_t s_pred;

    buffer_container_t s_recon;

    buffer_container_t s_quant_coeffs;

    buffer_container_t s_res_pred;

    /* neighbors left, top, top right, top left */

    UWORD8 *pu1_mb_a;