/src/libavc/common/ih264_luma_intra_pred_filters.c

Source (jump to first uncovered line)
/******************************************************************************
 *
 * Copyright (C) 2015 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
*  ih264_luma_intra_pred_filters.c
*
* @brief
*  Contains function definitions for intra prediction  filters
*
* @author
*  ittiam
*
* @par List of Functions:
*  - ih264_intra_pred_luma_4x4_mode_vert
*  - ih264_intra_pred_luma_4x4_mode_horz
*  - ih264_intra_pred_luma_4x4_mode_dc
*  - ih264_intra_pred_luma_4x4_mode_diag_dl
*  - ih264_intra_pred_luma_4x4_mode_diag_dr
*  - ih264_intra_pred_luma_4x4_mode_vert_r
*  - ih264_intra_pred_luma_4x4_mode_horz_d
*  - ih264_intra_pred_luma_4x4_mode_vert_l
*  - ih264_intra_pred_luma_4x4_mode_horz_u
*  - ih264_intra_pred_luma_8x8_mode_ref_filtering
*  - ih264_intra_pred_luma_8x8_mode_vert
*  - ih264_intra_pred_luma_8x8_mode_horz
*  - ih264_intra_pred_luma_8x8_mode_dc
*  - ih264_intra_pred_luma_8x8_mode_diag_dl
*  - ih264_intra_pred_luma_8x8_mode_diag_dr
*  - ih264_intra_pred_luma_8x8_mode_vert_r
*  - ih264_intra_pred_luma_8x8_mode_horz_d
*  - ih264_intra_pred_luma_8x8_mode_vert_l
*  - ih264_intra_pred_luma_8x8_mode_horz_u
*  - ih264_intra_pred_luma_16x16_mode_vert
*  - ih264_intra_pred_luma_16x16_mode_horz
*  - ih264_intra_pred_luma_16x16_mode_dc
*  - ih264_intra_pred_luma_16x16_mode_plane
*
* @remarks
*  none
*
******************************************************************************
*/

/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/
/* System include files */
#include <stdio.h>
#include <stddef.h>
#include <string.h>

/* User include files */
#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_defs.h"
#include "ih264_intra_pred_filters.h"
#include "ih264_platform_macros.h"

/*****************************************************************************/
/* Global definitions                                                        */
/*****************************************************************************/
/* Note: Global variables used only in assembly files */
const WORD8 ih264_gai1_intrapred_luma_plane_coeffs[] =
{
    0x01, 0x02, 0x03, 0x04,
    0x05, 0x06, 0x07, 0x08,
    0x09, 0x0A, 0x0B, 0x0C,
    0x0D, 0x0E, 0x0F, 0x10,
};

const WORD8  ih264_gai1_intrapred_luma_8x8_horz_u[] =
{
   0x06, 0x15, 0x05, 0x14,
   0x04, 0x13, 0x03, 0x12,
   0x02, 0x11, 0x01, 0x10,
   0x00, 0x1F, 0x0F, 0x0F,
};


/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:vertical
*
* @par Description:
* Perform Intra prediction for luma_4x4 mode:vertical, described in sec 8.3.1.2.1
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_vert(UWORD8 *pu1_src,
                                         UWORD8 *pu1_dst,
                                         WORD32 src_strd,
                                         WORD32 dst_strd,
                                         WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK_SIZE + 1;
    memcpy(pu1_dst, pu1_top, 4);
    memcpy(pu1_dst + dst_strd, pu1_top, 4);
    memcpy(pu1_dst + 2 * dst_strd, pu1_top, 4);
    memcpy(pu1_dst + 3 * dst_strd, pu1_top, 4);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:horizontal
*
* @par Description:
*  Perform Intra prediction for luma_4x4 mode:horizontal, described in
*  sec 8.3.1.2.2
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_horz(UWORD8 *pu1_src,
                                         UWORD8 *pu1_dst,
                                         WORD32 src_strd,
                                         WORD32 dst_strd,
                                         WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_left = pu1_src + BLK_SIZE - 1;
    memset(pu1_dst, *pu1_left, 4);
    memset(pu1_dst + dst_strd, *(pu1_left - 1), 4);
    memset(pu1_dst + 2 * dst_strd, *(pu1_left - 2), 4);
    memset(pu1_dst + 3 * dst_strd, *(pu1_left - 3), 4);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:DC
*
* @par Description:
*  Perform Intra prediction for luma_4x4 mode:DC, described in sec 8.3.1.2.3
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_dc(UWORD8 *pu1_src,
                                       UWORD8 *pu1_dst,
                                       WORD32 src_strd,
                                       WORD32 dst_strd,
                                       WORD32 ngbr_avail)
{
    UWORD8 u1_useleft; /* availability of left predictors (only for DC) */
    UWORD8 u1_usetop; /* availability of top predictors (only for DC) */
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    WORD32 val = 0;

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK);
    u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK);
    pu1_top = pu1_src + BLK_SIZE + 1;
    pu1_left = pu1_src + BLK_SIZE - 1;

    if(u1_useleft)
    {
        val += *pu1_left--;
        val += *pu1_left--;
        val += *pu1_left--;
        val += *pu1_left + 2;
    }
    if(u1_usetop)
    {
        val += *pu1_top + *(pu1_top + 1) + *(pu1_top + 2) + *(pu1_top + 3)
                        + 2;
    }
    /* Since 2 is added if either left/top pred is there,
     val still being zero implies both preds are not there */
    val = (val) ? (val >> (1 + u1_useleft + u1_usetop)) : 128;
    /* 4 bytes are copied from src to dst */
    memset(pu1_dst, val, 4);
    memset(pu1_dst + dst_strd, val, 4);
    memset(pu1_dst + 2 * dst_strd, val, 4);
    memset(pu1_dst + 3 * dst_strd, val, 4);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Left
*
* @par Description:
*  Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Left, described in
*  sec 8.3.1.2.4
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_diag_dl(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
                                            WORD32 dst_strd,
                                            WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h;
    UWORD8 predicted_pixels[7];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src +BLK_SIZE + 1;

    ui4_a = *pu1_top++;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_e = *pu1_top++;
    ui4_f = *pu1_top++;
    ui4_g = *pu1_top++;
    ui4_h = *pu1_top;

    predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e);
    predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f);
    predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g);
    predicted_pixels[5] = FILT121(ui4_f, ui4_g, ui4_h);
    predicted_pixels[6] = FILT121(ui4_g, ui4_h, ui4_h);

    memcpy(pu1_dst, predicted_pixels, 4);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 4);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 4);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 3, 4);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Right
*
* @par Description:
*  Perform Intra prediction for luma_4x4 mode:Diagonal_Down_Right, described in
*  sec 8.3.1.2.5
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_diag_dr(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
                                            WORD32 dst_strd,
                                            WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */
    UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_i, ui4_j, ui4_k, ui4_l, ui4_m;
    UWORD8 predicted_pixels[7];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK_SIZE + 1;
    pu1_left = pu1_src + BLK_SIZE - 1;
    pu1_topleft = pu1_src +BLK_SIZE;

    ui4_a = *pu1_top++;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_i = *pu1_left--;
    ui4_j = *pu1_left--;
    ui4_k = *pu1_left--;
    ui4_l = *pu1_left;
    ui4_m = *pu1_topleft;

    predicted_pixels[2] = FILT121(ui4_j, ui4_i, ui4_m);
    predicted_pixels[1] = FILT121(ui4_k, ui4_j, ui4_i);
    predicted_pixels[0] = FILT121(ui4_l, ui4_k, ui4_j);
    predicted_pixels[3] = FILT121(ui4_i, ui4_m, ui4_a);
    predicted_pixels[4] = FILT121(ui4_m, ui4_a, ui4_b);
    predicted_pixels[5] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[6] = FILT121(ui4_b, ui4_c, ui4_d);

    memcpy(pu1_dst, predicted_pixels + 3, 4);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 2, 4);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 1, 4);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:Vertical_Right
*
* @par Description:
*  Perform Intra prediction for luma_4x4 mode:Vertical_Right, described in
*  sec 8.3.1.2.6
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_vert_r(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{

    UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_i, ui4_j, ui4_k, ui4_m;
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */
    UWORD8 predicted_pixels[10];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src +BLK_SIZE + 1;
    pu1_left = pu1_src + BLK_SIZE - 1;
    pu1_topleft = pu1_src + BLK_SIZE;

    ui4_a = *pu1_top++;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_i = *pu1_left--;
    ui4_j = *pu1_left--;
    ui4_k = *pu1_left;
    ui4_m = *pu1_topleft;

    predicted_pixels[6] = FILT11(ui4_m, ui4_a);
    predicted_pixels[7] = FILT11(ui4_a, ui4_b);
    predicted_pixels[8] = FILT11(ui4_b, ui4_c);
    predicted_pixels[9] = FILT11(ui4_c, ui4_d);
    predicted_pixels[1] = FILT121(ui4_i, ui4_m, ui4_a);
    predicted_pixels[2] = FILT121(ui4_m, ui4_a, ui4_b);
    predicted_pixels[3] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[4] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[5] = FILT121(ui4_j, ui4_i, ui4_m);
    predicted_pixels[0] = FILT121(ui4_k, ui4_j, ui4_i);

    memcpy(pu1_dst, predicted_pixels + 6, 4);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 4);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 5, 4);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4);
}

/*
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:Horizontal_Down
*
* @par Description:
*  Perform Intra prediction for luma_4x4 mode:Horizontal_Down, described in
*  sec 8.3.1.2.7
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_horz_d(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_topleft = NULL;/* Pointer to top left predictor */
    UWORD32 ui4_a, ui4_b, ui4_c, ui4_i, ui4_j, ui4_k, ui4_l, ui4_m;
    UWORD8 predicted_pixels[10];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK_SIZE + 1;
    pu1_left = pu1_src + BLK_SIZE - 1;
    pu1_topleft = pu1_src + BLK_SIZE;

    ui4_a = *pu1_top++;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_i = *pu1_left--;
    ui4_j = *pu1_left--;
    ui4_k = *pu1_left--;
    ui4_l = *pu1_left--;
    ui4_m = *pu1_topleft;

    predicted_pixels[6] = FILT11(ui4_i, ui4_m);
    predicted_pixels[7] = FILT121(ui4_i, ui4_m, ui4_a);
    predicted_pixels[8] = FILT121(ui4_m, ui4_a, ui4_b);
    predicted_pixels[9] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[1] = FILT121(ui4_l, ui4_k, ui4_j);
    predicted_pixels[2] = FILT11(ui4_k, ui4_j);
    predicted_pixels[3] = FILT121(ui4_k, ui4_j, ui4_i);
    predicted_pixels[4] = FILT11(ui4_j, ui4_i);
    predicted_pixels[5] = FILT121(ui4_j, ui4_i, ui4_m);
    predicted_pixels[0] = FILT11(ui4_l, ui4_k);

    memcpy(pu1_dst, predicted_pixels + 6, 4);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 4, 4);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 4);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels, 4);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for  luma_4x4 mode:Vertical_Left
*
* @par Description:
*  Perform Intra prediction for  luma_4x4 mode:Vertical_Left, described in
*  sec 8.3.1.2.8
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_vert_l(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g;
    UWORD8 predicted_pixels[10];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK_SIZE + 1;

    ui4_a = *pu1_top++;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_e = *pu1_top++;
    ui4_f = *pu1_top++;
    ui4_g = *pu1_top;

    predicted_pixels[5] = FILT11(ui4_a, ui4_b);
    predicted_pixels[6] = FILT11(ui4_b, ui4_c);
    predicted_pixels[7] = FILT11(ui4_c, ui4_d);
    predicted_pixels[8] = FILT11(ui4_d, ui4_e);
    predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e);
    predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f);
    predicted_pixels[9] = FILT11(ui4_e, ui4_f);
    predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g);

    memcpy(pu1_dst, predicted_pixels + 5, 4);
    memcpy(pu1_dst + dst_strd, predicted_pixels, 4);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 6, 4);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 1, 4);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_4x4 mode:Horizontal_Up
*
* @par Description:
*  Perform Intra prediction for luma_4x4 mode:Horizontal_Up, described in
*  sec 8.3.1.2.9
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_4x4_mode_horz_u(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD32 ui4_i, ui4_j, ui4_k, ui4_l;
    UWORD8 predicted_pixels[10];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_left = pu1_src + BLK_SIZE - 1;

    ui4_i = *pu1_left--;
    ui4_j = *pu1_left--;
    ui4_k = *pu1_left--;
    ui4_l = *pu1_left--;

    predicted_pixels[0] = FILT11(ui4_j, ui4_i);
    predicted_pixels[1] = FILT121(ui4_k, ui4_j, ui4_i);
    predicted_pixels[2] = FILT11(ui4_k, ui4_j);
    predicted_pixels[3] = FILT121(ui4_l, ui4_k, ui4_j);
    predicted_pixels[4] = FILT11(ui4_l, ui4_k);
    predicted_pixels[5] = FILT121(ui4_l, ui4_l, ui4_k);
    predicted_pixels[6] = ui4_l;
    predicted_pixels[7] = ui4_l;
    predicted_pixels[8] = ui4_l;
    predicted_pixels[9] = ui4_l;

    memcpy(pu1_dst, predicted_pixels, 4);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 2, 4);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 4, 4);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 6, 4);
}

/**
*******************************************************************************
*
* @brief
*  Reference sample filtering process for Intra_8x8 sample prediction
*
* @par Description:
*  Perform Reference sample filtering process for Intra_8x8 sample prediction,
*  described in sec 8.3.2.2.1
*
* @param[in] pu1_left
*  pointer to the left pixel wrt current mb
*
* @param[in] pu1_topleft
*  pointer to the topleft pixel wrt current mb
*
* @param[in] pu1_top
*  pointer to the top pixel wrt current mb
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride[Not Used]
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************/
void ih264_intra_pred_luma_8x8_mode_ref_filtering(UWORD8 *pu1_left,
                                                  UWORD8 *pu1_topleft,
                                                  UWORD8 *pu1_top,
                                                  UWORD8 *pu1_dst,
                                                  WORD32 src_strd,
                                                  WORD32 ngbr_avail)
{
    WORD32 top_avail, left_avail, top_left_avail, top_right_avail;

    left_avail = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK);
    top_avail = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK);
    top_left_avail = BOOLEAN(ngbr_avail & TOP_LEFT_MB_AVAILABLE_MASK);
    top_right_avail = BOOLEAN(ngbr_avail & TOP_RIGHT_MB_AVAILABLE_MASK);

    if(top_avail)
    {
        WORD32 i;
        UWORD32 u4_xm1;

        if(!top_right_avail)
        {
            memset(pu1_dst + 8 + 1 + 8, pu1_top[7], 8);
            top_right_avail = 1;
        }
        else
        {
            memcpy(pu1_dst + 8 + 1 + 8, pu1_top + 8, 8);
        }

        if(top_left_avail)
        {
            pu1_dst[8 + 1 + 0] = FILT121((*pu1_topleft), pu1_top[0],
                                         pu1_top[1]);
        }
        else
        {
            pu1_dst[8 + 1] = ((3 * pu1_top[0]) + pu1_top[1] + 2) >> 2;
        }

        for(i = 1; i <= 6; i++)
        {
            pu1_dst[8 + 1 + i] = FILT121(pu1_top[i - 1], pu1_top[i],
                                         pu1_top[i + 1]);
        }
        /* First byte of Top Right input is in pu1_dst[8 + 1 + 8]*/
        pu1_dst[8 + 1 + 7] = FILT121(pu1_top[6], pu1_top[7],
                                     pu1_dst[8 + 1 + 8]);

        /* filtered output and source in same buf, to prevent output(x - 1)
         being over written in process */
        u4_xm1 = pu1_top[7];

        for(i = 8; i <= 14; i++)
        {
            UWORD32 u4_x;
            u4_x = (u4_xm1 + (pu1_dst[8 + 1 + i] << 1) + pu1_dst[8 + 1 + i + 1]
                            + 2) >> 2;
            /* assigning u4_xm1 from the un-filtered values for the next iteration */
            u4_xm1 = pu1_dst[8 + 1 + i];
            pu1_dst[8 + 1 + i] = u4_x;
        }

        pu1_dst[8 + 1 + 15] = (u4_xm1 + (3 * pu1_dst[8 + 1 + 15]) + 2) >> 2;
    }

    /* pu1_topleft is overloaded. It is both: */
    /* a. A pointer for the top left pixel */
    /* b. An indicator of availability of top left. */
    /*    If it is null then top left not available */
    if(top_left_avail)
    {
        if((!top_avail) || (!left_avail))
        {
            if(top_avail)
                pu1_dst[8] = (3 * pu1_topleft[0] + pu1_top[0] + 2) >> 2;
            else if(left_avail)
                pu1_dst[8] = (3 * pu1_topleft[0] + pu1_left[0] + 2) >> 2;
        }
        else
        {
            pu1_dst[8] = FILT121(pu1_top[0], (*pu1_topleft), pu1_left[0]);
        }
    }

    if(left_avail)
    {
        UWORD32 idx;
        if(0 != pu1_topleft)
        {
            pu1_dst[7] = FILT121((*pu1_topleft), pu1_left[0],
                                 pu1_left[src_strd]);
        }
        else
        {
            pu1_dst[7] = ((3 * pu1_left[0]) + pu1_left[src_strd] + 2) >> 2;
        }

        for(idx = 1; idx <= 6; idx++)
        {
            pu1_dst[7 - idx] = FILT121(pu1_left[(idx - 1) * src_strd],
                                       pu1_left[idx * src_strd],
                                       pu1_left[(idx + 1) * src_strd]);

        }
        pu1_dst[0] = (pu1_left[6 * src_strd] + 3 * pu1_left[7 * src_strd] + 2)
                        >> 2;
    }
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:vertical
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:vertical, described in
*  sec 8.3.2.2.2
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_vert(UWORD8 *pu1_src,
                                         UWORD8 *pu1_dst,
                                         WORD32 src_strd,
                                         WORD32 dst_strd,
                                         WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL;

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK8x8SIZE + 1;

    memcpy(pu1_dst, pu1_top, 8);
    memcpy(pu1_dst + dst_strd, pu1_top, 8);
    memcpy(pu1_dst + 2 * dst_strd, pu1_top, 8);
    memcpy(pu1_dst + 3 * dst_strd, pu1_top, 8);
    memcpy(pu1_dst + 4 * dst_strd, pu1_top, 8);
    memcpy(pu1_dst + 5 * dst_strd, pu1_top, 8);
    memcpy(pu1_dst + 6 * dst_strd, pu1_top, 8);
    memcpy(pu1_dst + 7 * dst_strd, pu1_top, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:horizontal
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:horizontal, described in
*  sec 8.3.2.2.2
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_horz(UWORD8 *pu1_src,
                                         UWORD8 *pu1_dst,
                                         WORD32 src_strd,
                                         WORD32 dst_strd,
                                         WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = pu1_src + BLK8x8SIZE - 1;

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    memset(pu1_dst, *pu1_left, 8);
    memset(pu1_dst + dst_strd, *(pu1_left - 1), 8);
    memset(pu1_dst + 2 * dst_strd, *(pu1_left - 2), 8);
    memset(pu1_dst + 3 * dst_strd, *(pu1_left - 3), 8);
    memset(pu1_dst + 4 * dst_strd, *(pu1_left - 4), 8);
    memset(pu1_dst + 5 * dst_strd, *(pu1_left - 5), 8);
    memset(pu1_dst + 6 * dst_strd, *(pu1_left - 6), 8);
    memset(pu1_dst + 7 * dst_strd, *(pu1_left - 7), 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:DC
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:DC, described in sec 8.3.2.2.4
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_dc(UWORD8 *pu1_src,
                                       UWORD8 *pu1_dst,
                                       WORD32 src_strd,
                                       WORD32 dst_strd,
                                       WORD32 ngbr_avail)
{
    UWORD8 u1_useleft; /* availability of left predictors (only for DC) */
    UWORD8 u1_usetop; /* availability of top predictors (only for DC) */
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    WORD32 row;
    WORD32 val = 0;

    UNUSED(src_strd);
    u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK);
    u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK);
    pu1_top = pu1_src + BLK8x8SIZE + 1;
    pu1_left = pu1_src + BLK8x8SIZE - 1;

    if(u1_useleft)
    {
        for(row = 0; row < BLK8x8SIZE; row++)
            val += *(pu1_left - row);
        val += 4;
    }
    if(u1_usetop)
    {
        for(row = 0; row < BLK8x8SIZE; row++)
            val += *(pu1_top + row);
        val += 4;
    }

    /* Since 4 is added if either left/top pred is there,
     val still being zero implies both preds are not there */
    val = (val) ? (val >> (2 + u1_useleft + u1_usetop)) : 128;

    memset(pu1_dst, val, 8);
    memset(pu1_dst + dst_strd, val, 8);
    memset(pu1_dst + 2 * dst_strd, val, 8);
    memset(pu1_dst + 3 * dst_strd, val, 8);
    memset(pu1_dst + 4 * dst_strd, val, 8);
    memset(pu1_dst + 5 * dst_strd, val, 8);
    memset(pu1_dst + 6 * dst_strd, val, 8);
    memset(pu1_dst + 7 * dst_strd, val, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Left
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Left, described in
*  sec 8.3.2.2.5
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_diag_dl(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
                                            WORD32 dst_strd,
                                            WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h;
    UWORD32 ui4_i, ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p;
    UWORD8 predicted_pixels[15];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK8x8SIZE + 1;

    ui4_a = *pu1_top++;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_e = *pu1_top++;
    ui4_f = *pu1_top++;
    ui4_g = *pu1_top++;
    ui4_h = *pu1_top++;
    ui4_i = *pu1_top++;
    ui4_j = *pu1_top++;
    ui4_k = *pu1_top++;
    ui4_l = *pu1_top++;
    ui4_m = *pu1_top++;
    ui4_n = *pu1_top++;
    ui4_o = *pu1_top++;
    ui4_p = *pu1_top;

    predicted_pixels[0] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[1] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[2] = FILT121(ui4_c, ui4_d, ui4_e);
    predicted_pixels[3] = FILT121(ui4_d, ui4_e, ui4_f);
    predicted_pixels[4] = FILT121(ui4_e, ui4_f, ui4_g);
    predicted_pixels[5] = FILT121(ui4_f, ui4_g, ui4_h);
    predicted_pixels[6] = FILT121(ui4_g, ui4_h, ui4_i);
    predicted_pixels[7] = FILT121(ui4_h, ui4_i, ui4_j);
    predicted_pixels[8] = FILT121(ui4_i, ui4_j, ui4_k);
    predicted_pixels[9] = FILT121(ui4_j, ui4_k, ui4_l);
    predicted_pixels[10] = FILT121(ui4_k, ui4_l, ui4_m);
    predicted_pixels[11] = FILT121(ui4_l, ui4_m, ui4_n);
    predicted_pixels[12] = FILT121(ui4_m, ui4_n, ui4_o);
    predicted_pixels[13] = FILT121(ui4_n, ui4_o, ui4_p);
    predicted_pixels[14] = FILT121(ui4_o, ui4_p, ui4_p);

    memcpy(pu1_dst, predicted_pixels, 8);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 1, 8);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 8);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 3, 8);
    memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 4, 8);
    memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 5, 8);
    memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 6, 8);
    memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 7, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Right
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:Diagonal_Down_Right, described
*  in sec 8.3.2.2.6
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_diag_dr(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
                                            WORD32 dst_strd,
                                            WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */
    UWORD32 ui4_a;
    UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i;
    UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p, ui4_q;
    UWORD8 predicted_pixels[15];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK8x8SIZE + 1;
    pu1_left = pu1_src + BLK8x8SIZE - 1;
    pu1_topleft = pu1_src + BLK8x8SIZE;

    ui4_a = *pu1_topleft;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_e = *pu1_top++;
    ui4_f = *pu1_top++;
    ui4_g = *pu1_top++;
    ui4_h = *pu1_top++;
    ui4_i = *pu1_top;
    ui4_j = *pu1_left--;
    ui4_k = *pu1_left--;
    ui4_l = *pu1_left--;
    ui4_m = *pu1_left--;
    ui4_n = *pu1_left--;
    ui4_o = *pu1_left--;
    ui4_p = *pu1_left--;
    ui4_q = *pu1_left;

    predicted_pixels[6] = FILT121(ui4_a, ui4_j, ui4_k);
    predicted_pixels[5] = FILT121(ui4_j, ui4_k, ui4_l);
    predicted_pixels[4] = FILT121(ui4_k, ui4_l, ui4_m);
    predicted_pixels[3] = FILT121(ui4_l, ui4_m, ui4_n);
    predicted_pixels[2] = FILT121(ui4_m, ui4_n, ui4_o);
    predicted_pixels[1] = FILT121(ui4_n, ui4_o, ui4_p);
    predicted_pixels[0] = FILT121(ui4_o, ui4_p, ui4_q);
    predicted_pixels[7] = FILT121(ui4_b, ui4_a, ui4_j);
    predicted_pixels[8] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[9] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[10] = FILT121(ui4_c, ui4_d, ui4_e);
    predicted_pixels[11] = FILT121(ui4_d, ui4_e, ui4_f);
    predicted_pixels[12] = FILT121(ui4_e, ui4_f, ui4_g);
    predicted_pixels[13] = FILT121(ui4_f, ui4_g, ui4_h);
    predicted_pixels[14] = FILT121(ui4_g, ui4_h, ui4_i);

    memcpy(pu1_dst, predicted_pixels + 7, 8);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 6, 8);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 5, 8);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 4, 8);
    memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 3, 8);
    memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 2, 8);
    memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 1, 8);
    memcpy(pu1_dst + 7 * dst_strd, predicted_pixels, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for  luma_8x8 mode:Vertical_Right
*
* @par Description:
*  Perform Intra prediction for  luma_8x8 mode:Vertical_Right, described in
*  sec 8.3.2.2.7
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_vert_r(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */
    UWORD32 ui4_a;
    UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i;
    UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p;
    UWORD8 predicted_pixels[22];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK8x8SIZE + 1;
    pu1_left = pu1_src + BLK8x8SIZE - 1;
    pu1_topleft = pu1_src + BLK8x8SIZE;

    ui4_a = *pu1_topleft;

    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_e = *pu1_top++;
    ui4_f = *pu1_top++;
    ui4_g = *pu1_top++;
    ui4_h = *pu1_top++;
    ui4_i = *pu1_top;
    ui4_j = *pu1_left--;
    ui4_k = *pu1_left--;
    ui4_l = *pu1_left--;
    ui4_m = *pu1_left--;
    ui4_n = *pu1_left--;
    ui4_o = *pu1_left--;
    ui4_p = *pu1_left--;

    predicted_pixels[0] = FILT121(ui4_o, ui4_n, ui4_m);
    predicted_pixels[1] = FILT121(ui4_m, ui4_l, ui4_k);
    predicted_pixels[2] = FILT121(ui4_k, ui4_j, ui4_a);
    predicted_pixels[3] = FILT11(ui4_a, ui4_b);
    predicted_pixels[4] = FILT11(ui4_b, ui4_c);
    predicted_pixels[5] = FILT11(ui4_c, ui4_d);
    predicted_pixels[6] = FILT11(ui4_d, ui4_e);
    predicted_pixels[7] = FILT11(ui4_e, ui4_f);
    predicted_pixels[8] = FILT11(ui4_f, ui4_g);
    predicted_pixels[9] = FILT11(ui4_g, ui4_h);
    predicted_pixels[10] = FILT11(ui4_h, ui4_i);
    predicted_pixels[11] = FILT121(ui4_p, ui4_o, ui4_n);
    predicted_pixels[12] = FILT121(ui4_n, ui4_m, ui4_l);
    predicted_pixels[13] = FILT121(ui4_l, ui4_k, ui4_j);
    predicted_pixels[14] = FILT121(ui4_b, ui4_a, ui4_j);
    predicted_pixels[15] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[16] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[17] = FILT121(ui4_c, ui4_d, ui4_e);
    predicted_pixels[18] = FILT121(ui4_d, ui4_e, ui4_f);
    predicted_pixels[19] = FILT121(ui4_e, ui4_f, ui4_g);
    predicted_pixels[20] = FILT121(ui4_f, ui4_g, ui4_h);
    predicted_pixels[21] = FILT121(ui4_g, ui4_h, ui4_i);

    memcpy(pu1_dst, predicted_pixels + 3, 8);
    memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 14, 8);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 2, 8);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 13, 8);
    memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 1, 8);
    memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 12, 8);
    memcpy(pu1_dst + 6 * dst_strd, predicted_pixels, 8);
    memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 11, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:Horizontal_Down
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:Horizontal_Down, described in
*  sec 8.3.2.2.8
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_horz_d(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD8 *pu1_topleft = NULL; /* Pointer to start of top left predictors */
    UWORD32 ui4_a;
    UWORD32 ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h, ui4_i;
    UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p;
    UWORD8 predicted_pixels[22];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK8x8SIZE + 1;
    pu1_left = pu1_src + BLK8x8SIZE - 1;
    pu1_topleft = pu1_src + BLK8x8SIZE;

    ui4_a = *pu1_topleft;
    ui4_j = *pu1_top++;
    ui4_k = *pu1_top++;
    ui4_l = *pu1_top++;
    ui4_m = *pu1_top++;
    ui4_n = *pu1_top++;
    ui4_o = *pu1_top++;
    ui4_p = *pu1_top++;
    ui4_b = *pu1_left--;
    ui4_c = *pu1_left--;
    ui4_d = *pu1_left--;
    ui4_e = *pu1_left--;
    ui4_f = *pu1_left--;
    ui4_g = *pu1_left--;
    ui4_h = *pu1_left--;
    ui4_i = *pu1_left;

    predicted_pixels[0] = FILT11(ui4_h, ui4_i);
    predicted_pixels[1] = FILT121(ui4_g, ui4_h, ui4_i);
    predicted_pixels[2] = FILT11(ui4_g, ui4_h);
    predicted_pixels[3] = FILT121(ui4_f, ui4_g, ui4_h);
    predicted_pixels[4] = FILT11(ui4_f, ui4_g);
    predicted_pixels[5] = FILT121(ui4_e, ui4_f, ui4_g);
    predicted_pixels[6] = FILT11(ui4_e, ui4_f);
    predicted_pixels[7] = FILT121(ui4_d, ui4_e, ui4_f);
    predicted_pixels[8] = FILT11(ui4_d, ui4_e);
    predicted_pixels[9] = FILT121(ui4_c, ui4_d, ui4_e);
    predicted_pixels[10] = FILT11(ui4_c, ui4_d);
    predicted_pixels[11] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[12] = FILT11(ui4_b, ui4_c);
    predicted_pixels[13] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[14] = FILT11(ui4_a, ui4_b);
    predicted_pixels[15] = FILT121(ui4_j, ui4_a, ui4_b);
    predicted_pixels[16] = FILT121(ui4_k, ui4_j, ui4_a);
    predicted_pixels[17] = FILT121(ui4_l, ui4_k, ui4_j);
    predicted_pixels[18] = FILT121(ui4_m, ui4_l, ui4_k);
    predicted_pixels[19] = FILT121(ui4_n, ui4_m, ui4_l);
    predicted_pixels[20] = FILT121(ui4_o, ui4_n, ui4_m);
    predicted_pixels[21] = FILT121(ui4_p, ui4_o, ui4_n);

    memcpy(pu1_dst, predicted_pixels + 14, 8);
    memcpy(pu1_dst + dst_strd, predicted_pixels + 12, 8);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 10, 8);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 8, 8);
    memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 6, 8);
    memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 4, 8);
    memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 2, 8);
    memcpy(pu1_dst + 7 * dst_strd, predicted_pixels, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:Vertical_Left
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:Vertical_Left, described in
*  sec 8.3.2.2.9
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/

void ih264_intra_pred_luma_8x8_mode_vert_l(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD32 ui4_a, ui4_b, ui4_c, ui4_d, ui4_e, ui4_f, ui4_g, ui4_h;
    UWORD32 ui4_i, ui4_j, ui4_k, ui4_l, ui4_m;
    UWORD8 predicted_pixels[22];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + BLK8x8SIZE + 1;

    ui4_a = *pu1_top++;
    ui4_b = *pu1_top++;
    ui4_c = *pu1_top++;
    ui4_d = *pu1_top++;
    ui4_e = *pu1_top++;
    ui4_f = *pu1_top++;
    ui4_g = *pu1_top++;
    ui4_h = *pu1_top++;
    ui4_i = *pu1_top++;
    ui4_j = *pu1_top++;
    ui4_k = *pu1_top++;
    ui4_l = *pu1_top++;
    ui4_m = *pu1_top++;

    predicted_pixels[0] = FILT11(ui4_a, ui4_b);
    predicted_pixels[1] = FILT11(ui4_b, ui4_c);
    predicted_pixels[2] = FILT11(ui4_c, ui4_d);
    predicted_pixels[3] = FILT11(ui4_d, ui4_e);
    predicted_pixels[4] = FILT11(ui4_e, ui4_f);
    predicted_pixels[5] = FILT11(ui4_f, ui4_g);
    predicted_pixels[6] = FILT11(ui4_g, ui4_h);
    predicted_pixels[7] = FILT11(ui4_h, ui4_i);
    predicted_pixels[8] = FILT11(ui4_i, ui4_j);
    predicted_pixels[9] = FILT11(ui4_j, ui4_k);
    predicted_pixels[10] = FILT11(ui4_k, ui4_l);
    predicted_pixels[11] = FILT121(ui4_a, ui4_b, ui4_c);
    predicted_pixels[12] = FILT121(ui4_b, ui4_c, ui4_d);
    predicted_pixels[13] = FILT121(ui4_c, ui4_d, ui4_e);
    predicted_pixels[14] = FILT121(ui4_d, ui4_e, ui4_f);
    predicted_pixels[15] = FILT121(ui4_e, ui4_f, ui4_g);
    predicted_pixels[16] = FILT121(ui4_f, ui4_g, ui4_h);
    predicted_pixels[17] = FILT121(ui4_g, ui4_h, ui4_i);
    predicted_pixels[18] = FILT121(ui4_h, ui4_i, ui4_j);
    predicted_pixels[19] = FILT121(ui4_i, ui4_j, ui4_k);
    predicted_pixels[20] = FILT121(ui4_j, ui4_k, ui4_l);
    predicted_pixels[21] = FILT121(ui4_k, ui4_l, ui4_m);

    memcpy(pu1_dst, predicted_pixels, 8);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 1, 8);
    memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 2, 8);
    memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 3, 8);
    memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 11, 8);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 12, 8);
    memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 13, 8);
    memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 14, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_8x8 mode:Horizontal_Up
*
* @par Description:
*  Perform Intra prediction for luma_8x8 mode:Horizontal_Up, described in
*  sec 8.3.2.2.10
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_8x8_mode_horz_u(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD32 ui4_j, ui4_k, ui4_l, ui4_m, ui4_n, ui4_o, ui4_p, ui4_q;
    UWORD8 predicted_pixels[22];

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_left = pu1_src + BLK8x8SIZE - 1;

    ui4_j = *pu1_left--;
    ui4_k = *pu1_left--;
    ui4_l = *pu1_left--;
    ui4_m = *pu1_left--;
    ui4_n = *pu1_left--;
    ui4_o = *pu1_left--;
    ui4_p = *pu1_left--;
    ui4_q = *pu1_left;

    pu1_left = pu1_src + BLK8x8SIZE - 1;

    predicted_pixels[0] = FILT11(ui4_j, ui4_k);
    predicted_pixels[1] = FILT121(ui4_j, ui4_k, ui4_l);
    predicted_pixels[2] = FILT11(ui4_k, ui4_l);
    predicted_pixels[3] = FILT121(ui4_k, ui4_l, ui4_m);
    predicted_pixels[4] = FILT11(ui4_l, ui4_m);
    predicted_pixels[5] = FILT121(ui4_l, ui4_m, ui4_n);
    predicted_pixels[6] = FILT11(ui4_m, ui4_n);
    predicted_pixels[7] = FILT121(ui4_m, ui4_n, ui4_o);
    predicted_pixels[8] = FILT11(ui4_n, ui4_o);
    predicted_pixels[9] = FILT121(ui4_n, ui4_o, ui4_p);
    predicted_pixels[10] = FILT11(ui4_o, ui4_p);
    predicted_pixels[11] = FILT121(ui4_o, ui4_p, ui4_q);
    predicted_pixels[12] = FILT11(ui4_p, ui4_q);
    predicted_pixels[13] = FILT121(ui4_p, ui4_q, ui4_q);
    memset(predicted_pixels+14,ui4_q,8);

    memcpy(pu1_dst, predicted_pixels, 8);
    memcpy(pu1_dst + 1 * dst_strd, predicted_pixels + 2, 8);
    memcpy(pu1_dst + 2 * dst_strd, predicted_pixels + 4, 8);
    memcpy(pu1_dst + 3 * dst_strd, predicted_pixels + 6, 8);
    memcpy(pu1_dst + 4 * dst_strd, predicted_pixels + 8, 8);
    memcpy(pu1_dst + 5 * dst_strd, predicted_pixels + 10, 8);
    memcpy(pu1_dst + 6 * dst_strd, predicted_pixels + 12, 8);
    memcpy(pu1_dst + 7 * dst_strd, predicted_pixels + 14, 8);
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_16x16 mode:Vertical
*
* @par Description:
*  Perform Intra prediction for luma_16x16 mode:Vertical, described in
*  sec 8.3.3.1
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_16x16_mode_vert(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    WORD32 rows; /* loop variables*/

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + MB_SIZE + 1;
    for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd)
    {
        memcpy(pu1_dst, pu1_top, 16);
        pu1_dst += dst_strd;
        memcpy(pu1_dst, pu1_top, 16);
        pu1_dst += dst_strd;
        memcpy(pu1_dst, pu1_top, 16);
        pu1_dst += dst_strd;
        memcpy(pu1_dst, pu1_top, 16);
    }
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_16x16 mode:Horizontal
*
* @par Description:
*  Perform Intra prediction for luma_16x16 mode:Horizontal, described in
*  sec 8.3.3.2
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_16x16_mode_horz(UWORD8 *pu1_src,
                                           UWORD8 *pu1_dst,
                                           WORD32 src_strd,
                                           WORD32 dst_strd,
                                           WORD32 ngbr_avail)
{
    UWORD8 *pu1_left = NULL; /* Pointer to start of top predictors */
    WORD32 rows;

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_left = pu1_src + MB_SIZE - 1;
    for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd, pu1_left --)
    {
        memset(pu1_dst, *pu1_left, 16); /* copy the left value to the entire row*/
        pu1_left --;
        pu1_dst += dst_strd;
        memset(pu1_dst, *pu1_left, 16);
        pu1_left --;
        pu1_dst += dst_strd;
        memset(pu1_dst, *pu1_left, 16);
        pu1_left --;
        pu1_dst += dst_strd;
        memset(pu1_dst, *pu1_left, 16);
    }
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_16x16 mode:DC
*
* @par Description:
*  Perform Intra prediction for luma_16x16 mode:DC, described in sec 8.3.3.3
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_16x16_mode_dc(UWORD8 *pu1_src,
                                         UWORD8 *pu1_dst,
                                         WORD32 src_strd,
                                         WORD32 dst_strd,
                                         WORD32 ngbr_avail)
{
    WORD8 u1_useleft; /* availability of left predictors (only for DC) */
    UWORD8 u1_usetop; /* availability of top predictors (only for DC) */
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    WORD32 rows; /* loop variables*/
    WORD32 val = 0;

    UNUSED(src_strd);
    u1_useleft = BOOLEAN(ngbr_avail & LEFT_MB_AVAILABLE_MASK);
    u1_usetop = BOOLEAN(ngbr_avail & TOP_MB_AVAILABLE_MASK);
    pu1_top = pu1_src + MB_SIZE + 1;
    pu1_left = pu1_src + MB_SIZE - 1;
    if(u1_useleft)
    {
        for(rows = 0; rows < 16; rows++)
            val += *(pu1_left - rows);
        val += 8;
    }
    if(u1_usetop)
    {
        for(rows = 0; rows < 16; rows++)
            val += *(pu1_top + rows);
        val += 8;
    }
    /* Since 8 is added if either left/top pred is there,
     val still being zero implies both preds are not there */
    val = (val) ? (val >> (3 + u1_useleft + u1_usetop)) : 128;

    for(rows = 0; rows < 16; rows += 4, pu1_dst += dst_strd)
    {
        memset(pu1_dst, val, 16);
        pu1_dst += dst_strd;
        memset(pu1_dst, val, 16);
        pu1_dst += dst_strd;
        memset(pu1_dst, val, 16);
        pu1_dst += dst_strd;
        memset(pu1_dst, val, 16);
    }
}

/**
*******************************************************************************
*
* @brief
*  Perform Intra prediction for luma_16x16 mode:PLANE
*
* @par Description:
*  Perform Intra prediction for luma_16x16 mode:PLANE, described in sec 8.3.3.4
*
* @param[in] pu1_src
*  pointer to the source
*
* @param[out] pu1_dst
*  pointer to the destination
*
* @param[in] src_strd
*  source stride
*
* @param[in] dst_strd
*  destination stride
*
* @param[in] ngbr_avail
*  availability of neighbouring pixels
*
* @returns
*
* @remarks
*  none
*
*******************************************************************************
*/
void ih264_intra_pred_luma_16x16_mode_plane(UWORD8 *pu1_src,
                                            UWORD8 *pu1_dst,
                                            WORD32 src_strd,
                                            WORD32 dst_strd,
                                            WORD32 ngbr_avail)
{
    /*! Written with no multiplications */
    UWORD8 *pu1_left = NULL; /* Pointer to start of left predictors */
    UWORD8 *pu1_top = NULL; /* Pointer to start of top predictors */
    UWORD8 *pu1_topleft = NULL;
    WORD32 a, b, c, tmp;
    UWORD8 *pu1_tmp1, *pu1_tmp2;
    WORD32 shift;

    UNUSED(src_strd);
    UNUSED(ngbr_avail);
    pu1_top = pu1_src + MB_SIZE + 1;
    pu1_left = pu1_src + MB_SIZE - 1;
    pu1_topleft = pu1_src + MB_SIZE;

    {
        a = (*(pu1_top + 15) + *(pu1_left - 15)) << 4;

        /*! Implement Sum(x*(P((x+7),-1) - P((x-7),-1))) x=1...8 */
        pu1_tmp1 = pu1_top + 8;
        pu1_tmp2 = pu1_tmp1 - 2;

        /* Pixel diffs are only 9 bits;
         so sign extension allows shifts to be used even for signed */
        b = ((*pu1_tmp1++) - (*pu1_tmp2--)); /* x=1 */
        b += ((*pu1_tmp1++) - (*pu1_tmp2--)) << 1; /* x=2 */
        tmp = ((*pu1_tmp1++) - (*pu1_tmp2--));
        b += (tmp << 1) + tmp; /* x=3 */
        b += ((*pu1_tmp1++) - (*pu1_tmp2--)) << 2; /* x=4 */

        tmp = ((*pu1_tmp1++) - (*pu1_tmp2--));
        b += (tmp << 2) + tmp; /* x=5 */
        tmp = ((*pu1_tmp1++) - (*pu1_tmp2--));
        b += (tmp << 2) + (tmp << 1); /* x=6 */
        tmp = ((*pu1_tmp1++) - (*pu1_tmp2--));
        b += (tmp << 3) - tmp; /* x=7 */
        b += ((*pu1_tmp1) - (*pu1_topleft)) << 3; /* x=8 */

        b = ((b << 2) + b + 32) >> 6; /*! (5*H + 32)>>6 */

        /*! Implement Sum(y*(P(-1,(y+7)) - P(-1,(y-7)))) y=1...8 */
        pu1_tmp1 = pu1_left - 8;
        pu1_tmp2 = pu1_tmp1 + 2;

        c = ((*pu1_tmp1) - (*pu1_tmp2)); /* y=1 */
        pu1_tmp1--;
        pu1_tmp2++;
        c += ((*pu1_tmp1) - (*pu1_tmp2)) << 1; /* y=2 */
        pu1_tmp1--;
        pu1_tmp2++;
        tmp = ((*pu1_tmp1) - (*pu1_tmp2));
        c += (tmp << 1) + tmp; /* y=3 */
        pu1_tmp1--;
        pu1_tmp2++;
        c += ((*pu1_tmp1) - (*pu1_tmp2)) << 2; /* y=4 */
        pu1_tmp1--;
        pu1_tmp2++;

        tmp = ((*pu1_tmp1) - (*pu1_tmp2));
        c += (tmp << 2) + tmp; /* y=5 */
        pu1_tmp1--;
        pu1_tmp2++;
        tmp = ((*pu1_tmp1) - (*pu1_tmp2));
        c += (tmp << 2) + (tmp << 1); /* y=6 */
        pu1_tmp1--;
        pu1_tmp2++;
        tmp = ((*pu1_tmp1) - (*pu1_tmp2));
        c += (tmp << 3) - tmp; /* y=7 */
        pu1_tmp1--; //pu1_tmp2 ++;
        /* Modified to get (-1,-1) location as *(pu1_top - 1) instead of (pu1_left - ui4_stride) */
        //c += ((*pu1_tmp1) - (*(pu1_top - 1)))<<3;      /* y=8 */
        c += ((*pu1_tmp1) - (*pu1_topleft)) << 3; /* y=8 */

        c = ((c << 2) + c + 32) >> 6; /*! (5*V + 32)>>32 */
        shift = 3;
    }

    /*! Now from the plane parameters a, b, and c,
     compute the fitted plane values over the block */
    {
        WORD32 tmp1, tmpx, tmpx_init, j, i;

        tmpx_init = -(b << shift); /* -8b */
        tmp = a - (c << shift) + 16; /* a-((4or8)*c)+16 */
        for(i = 0; i < 16; i++)
        {
            tmp += c; /*increment every time by c to get c*(y-7or3)*/
            tmpx = tmpx_init; /* Init to -8b */
            for(j = 0; j < 16; j++)
            {
                tmpx += b; /* increment every time by b to get b*(x-7or3) */
                tmp1 = (tmp + tmpx) >> 5;
                *pu1_dst++ = CLIP_U8(tmp1);
            }
            pu1_dst += (dst_strd - 16);
        }
    }
}

Coverage Report

Created: 2024-05-11 06:32