/******************************************************************************
|
*
|
* 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_defs.h"
|
#include "ih264_typedefs.h"
|
#include "ih264_macros.h"
|
#include "ih264_platform_macros.h"
|
#include "ih264_intra_pred_filters.h"
|
|
/* 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
|
};
|
|
/******************* LUMA INTRAPREDICTION *******************/
|
|
/******************* 4x4 Modes *******************/
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_vert
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_horz
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_dc
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer 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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_diag_dl
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_diag_dr
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_vert_r
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/*
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_horz_d
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_vert_l
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_4x4_mode_horz_u
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/******************* 8x8 Modes *******************/
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_ref_filtering
|
*
|
* @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_src
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride[Not Used]
|
*
|
* @param[in] dst_strd
|
* integer destination stride[Not Used]
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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 left_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[left_strd]);
|
}
|
else
|
{
|
pu1_dst[7] = ((3 * pu1_left[0]) + pu1_left[left_strd] + 2) >> 2;
|
}
|
|
for(idx = 1; idx <= 6; idx++)
|
{
|
pu1_dst[7 - idx] = FILT121(pu1_left[(idx - 1) * left_strd],
|
pu1_left[idx * left_strd],
|
pu1_left[(idx + 1) * left_strd]);
|
|
}
|
pu1_dst[0] = (pu1_left[6 * left_strd] + 3 * pu1_left[7 * left_strd] + 2)
|
>> 2;
|
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_vert
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_horz
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_dc
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer 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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_diag_dl
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_diag_dr
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_vert_r
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
|
}
|
|
/*
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_horz_d
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_vert_l
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_8x8_mode_horz_u
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
|
|
/******************* 16x16 Modes *******************/
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_16x16_mode_vert
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels (Not used in this function)
|
*
|
* @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);
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_16x16_mode_horz
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_16x16_mode_dc
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer 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);
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
*ih264_intra_pred_luma_16x16_mode_plane
|
*
|
* @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
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] src_strd
|
* integer source stride
|
*
|
* @param[in] dst_strd
|
* integer destination stride
|
*
|
* @param[in] ngbr_avail
|
* availability of neighbouring pixels(Not used in this function)
|
*
|
* @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);
|
}
|
}
|
}
|
