/******************************************************************************
|
*
|
* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
|
*
|
* 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.
|
*
|
******************************************************************************/
|
/**
|
*******************************************************************************
|
* @file
|
* ihevc_intra_pred_filters.c
|
*
|
* @brief
|
* Contains function Definition for intra prediction interpolation filters
|
*
|
*
|
* @author
|
* Srinivas T
|
*
|
* @par List of Functions:
|
* - ihevc_intra_pred_luma_planar()
|
* - ihevc_intra_pred_luma_dc()
|
* - ihevc_intra_pred_luma_horz()
|
* - ihevc_intra_pred_luma_ver()
|
* - ihevc_intra_pred_luma_mode2()
|
* - ihevc_intra_pred_luma_mode_18_34()
|
* - ihevc_intra_pred_luma_mode_3_to_9()
|
* - ihevc_intra_pred_luma_mode_11_to_17()
|
* - ihevc_intra_pred_luma_mode_19_to_25()
|
* - ihevc_intra_pred_luma_mode_27_to_33()
|
* - ihevc_intra_pred_luma_ref_substitution()
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
/*****************************************************************************/
|
/* File Includes */
|
/*****************************************************************************/
|
|
#include <assert.h>
|
#include "ihevc_typedefs.h"
|
#include "ihevc_intra_pred.h"
|
#include "ihevc_macros.h"
|
#include "ihevc_func_selector.h"
|
#include "ihevc_platform_macros.h"
|
#include "ihevc_common_tables.h"
|
#include "ihevc_defs.h"
|
#include "ihevc_mem_fns.h"
|
#include "ihevc_debug.h"
|
|
/****************************************************************************/
|
/* Constant Macros */
|
/****************************************************************************/
|
#define MAX_CU_SIZE 64
|
#define BIT_DEPTH 8
|
#define T32_4NT 128
|
#define T16_4NT 64
|
|
|
/****************************************************************************/
|
/* Function Macros */
|
/****************************************************************************/
|
#define GET_BITS(y,x) ((y) & (1 << x)) && (1 << x)
|
|
/*****************************************************************************/
|
/* global tables Definition */
|
/*****************************************************************************/
|
|
|
/*****************************************************************************/
|
/* Function Definition */
|
/*****************************************************************************/
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for pu1_ref substitution
|
*
|
*
|
* @par Description:
|
* Reference substitution process for samples unavailable for prediction
|
* Refer to section 8.4.4.2.2
|
*
|
* @param[in] pu1_top_left
|
* UWORD8 pointer to the top-left
|
*
|
* @param[in] pu1_top
|
* UWORD8 pointer to the top
|
*
|
* @param[in] pu1_left
|
* UWORD8 pointer to the left
|
*
|
* @param[in] src_strd
|
* WORD32 Source stride
|
*
|
* @param[in] nbr_flags
|
* WORD32 neighbor availability flags
|
*
|
* @param[in] nt
|
* WORD32 transform Block size
|
*
|
* @param[in] dst_strd
|
* WORD32 Destination stride
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
void ihevc_intra_pred_luma_ref_subst_all_avlble(UWORD8 *pu1_top_left,
|
UWORD8 *pu1_top,
|
UWORD8 *pu1_left,
|
WORD32 src_strd,
|
WORD32 nt,
|
WORD32 nbr_flags,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd)
|
{
|
|
WORD32 i;
|
WORD32 two_nt = 2 * nt;
|
UNUSED(nbr_flags);
|
UNUSED(dst_strd);
|
|
/* Neighbor Flag Structure*/
|
/* MSB ---> LSB */
|
/* Top-Left | Top-Right | Top | Left | Bottom-Left
|
1 4 4 4 4
|
*/
|
ASSERT((nbr_flags == 0x11188) || (nbr_flags == 0x133CC) || (nbr_flags == 0x1FFFF));
|
{
|
|
if(nt == 4)
|
{
|
/* 1 bit extraction for all the neighboring blocks */
|
|
|
/* Else fill the corresponding samples */
|
pu1_dst[two_nt] = *pu1_top_left;
|
//if(left)
|
{
|
for(i = 0; i < nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
// if(bot_left)
|
{
|
for(i = nt; i < two_nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
// if(top)
|
{
|
ihevc_memcpy(&pu1_dst[two_nt + 1], pu1_top, nt);
|
}
|
// if(tp_right)
|
{
|
ihevc_memcpy(&pu1_dst[two_nt + 1 + nt], pu1_top + nt, nt);
|
}
|
|
|
}
|
else
|
|
{
|
|
/* Else fill the corresponding samples */
|
ASSERT((nt == 8) || (nt == 16) || (nt == 32));
|
pu1_dst[two_nt] = *pu1_top_left;
|
|
for(i = 0; i < nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
|
for(i = nt; i < two_nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
|
ihevc_memcpy_mul_8(&pu1_dst[two_nt + 1], pu1_top, nt);
|
|
ihevc_memcpy_mul_8(&pu1_dst[two_nt + 1 + nt], pu1_top + nt, nt);
|
}
|
|
}
|
}
|
|
|
void ihevc_intra_pred_luma_ref_substitution(UWORD8 *pu1_top_left,
|
UWORD8 *pu1_top,
|
UWORD8 *pu1_left,
|
WORD32 src_strd,
|
WORD32 nt,
|
WORD32 nbr_flags,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd)
|
{
|
UWORD8 pu1_ref;
|
WORD32 dc_val, i;
|
WORD32 total_samples = (4 * nt) + 1;
|
WORD32 two_nt = 2 * nt;
|
|
WORD32 three_nt = 3 * nt;
|
WORD32 get_bits;
|
WORD32 next;
|
WORD32 bot_left, left, top, tp_right, tp_left;
|
|
WORD32 idx, nbr_id_from_bl, frwd_nbr_flag;
|
UNUSED(dst_strd);
|
/*dc_val = 1 << (BIT_DEPTH - 1);*/
|
dc_val = 1 << (8 - 1);
|
|
|
/* Neighbor Flag Structure*/
|
/* MSB ---> LSB */
|
/* Top-Left | Top-Right | Top | Left | Bottom-Left
|
1 4 4 4 4
|
*/
|
/* If no neighbor flags are present, fill the neighbor samples with DC value */
|
if(nbr_flags == 0)
|
{
|
for(i = 0; i < total_samples; i++)
|
{
|
pu1_dst[i] = dc_val;
|
}
|
}
|
else
|
{
|
if(nt <= 8)
|
{
|
/* 1 bit extraction for all the neighboring blocks */
|
tp_left = (nbr_flags & 0x10000) >> 16;
|
bot_left = (nbr_flags & 0x8) >> 3;
|
left = (nbr_flags & 0x80) >> 7;
|
top = (nbr_flags & 0x100) >> 8;
|
tp_right = (nbr_flags & 0x1000) >> 12;
|
|
/* Else fill the corresponding samples */
|
if(tp_left)
|
pu1_dst[two_nt] = *pu1_top_left;
|
else
|
pu1_dst[two_nt] = 0;
|
|
|
if(left)
|
{
|
for(i = 0; i < nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset(&pu1_dst[two_nt - 1 - (nt - 1)], 0, nt);
|
}
|
|
|
if(bot_left)
|
{
|
for(i = nt; i < two_nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset(&pu1_dst[two_nt - 1 - (two_nt - 1)], 0, nt);
|
}
|
|
|
if(top)
|
{
|
ihevc_memcpy(&pu1_dst[two_nt + 1], pu1_top, nt);
|
}
|
else
|
{
|
ihevc_memset(&pu1_dst[two_nt + 1], 0, nt);
|
}
|
|
if(tp_right)
|
{
|
ihevc_memcpy(&pu1_dst[two_nt + 1 + nt], pu1_top + nt, nt);
|
}
|
else
|
{
|
ihevc_memset(&pu1_dst[two_nt + 1 + nt], 0, nt);
|
}
|
next = 1;
|
|
/* If bottom -left is not available, reverse substitution process*/
|
if(bot_left == 0)
|
{
|
WORD32 a_nbr_flag[5];
|
a_nbr_flag[0] = bot_left;
|
a_nbr_flag[1] = left;
|
a_nbr_flag[2] = tp_left;
|
a_nbr_flag[3] = top;
|
a_nbr_flag[4] = tp_right;
|
|
/* Check for the 1st available sample from bottom-left*/
|
while(!a_nbr_flag[next])
|
next++;
|
|
/* If Left, top-left are available*/
|
if(next <= 2)
|
{
|
idx = nt * next;
|
pu1_ref = pu1_dst[idx];
|
for(i = 0; i < idx; i++)
|
pu1_dst[i] = pu1_ref;
|
}
|
else /* If top, top-right are available */
|
{
|
/* Idx is changed to copy 1 pixel value for top-left ,if top-left is not available*/
|
idx = (nt * (next - 1)) + 1;
|
pu1_ref = pu1_dst[idx];
|
for(i = 0; i < idx; i++)
|
pu1_dst[i] = pu1_ref;
|
}
|
}
|
|
/* Forward Substitution Process */
|
/* If left is Unavailable, copy the last bottom-left value */
|
if(left == 0)
|
{
|
ihevc_memset(&pu1_dst[nt], pu1_dst[nt - 1], nt);
|
|
}
|
/* If top-left is Unavailable, copy the last left value */
|
if(tp_left == 0)
|
pu1_dst[two_nt] = pu1_dst[two_nt - 1];
|
/* If top is Unavailable, copy the last top-left value */
|
if(top == 0)
|
{
|
ihevc_memset(&pu1_dst[two_nt + 1], pu1_dst[two_nt], nt);
|
}
|
/* If to right is Unavailable, copy the last top value */
|
if(tp_right == 0)
|
{
|
ihevc_memset(&pu1_dst[three_nt + 1], pu1_dst[three_nt], nt);
|
|
}
|
}
|
|
if(nt == 16)
|
{
|
WORD32 nbr_flags_temp = 0;
|
nbr_flags_temp = ((nbr_flags & 0xC) >> 2) + ((nbr_flags & 0xC0) >> 4)
|
+ ((nbr_flags & 0x300) >> 4)
|
+ ((nbr_flags & 0x3000) >> 6)
|
+ ((nbr_flags & 0x10000) >> 8);
|
|
/* Else fill the corresponding samples */
|
if(nbr_flags & 0x10000)
|
pu1_dst[two_nt] = *pu1_top_left;
|
else
|
pu1_dst[two_nt] = 0;
|
|
if(nbr_flags & 0xC0)
|
{
|
for(i = 0; i < nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[two_nt - 1 - (nt - 1)], 0, nt);
|
}
|
|
/* Bottom - left availability is checked for every 8x8 TU position and set accordingly */
|
{
|
if(nbr_flags & 0x8)
|
{
|
for(i = nt; i < (nt + 8); i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[nt - 8], 0, 8);
|
}
|
|
if(nbr_flags & 0x4)
|
{
|
for(i = (nt + 8); i < two_nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[0], 0, 8);
|
}
|
}
|
|
if(nbr_flags & 0x300)
|
{
|
ihevc_memcpy_mul_8(&pu1_dst[two_nt + 1], pu1_top, nt);
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[two_nt + 1], 0, nt);
|
}
|
|
if(nbr_flags & 0x3000)
|
{
|
ihevc_memcpy_mul_8(&pu1_dst[two_nt + 1 + nt], pu1_top + nt, nt);
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[two_nt + 1 + nt], 0, nt);
|
}
|
/* compute trailing zeors based on nbr_flag for substitution process of below left see section .*/
|
/* as each bit in nbr flags corresponds to 8 pels for bot_left, left, top and topright but 1 pel for topleft */
|
{
|
nbr_id_from_bl = look_up_trailing_zeros(nbr_flags_temp & 0XF) * 8; /* for below left and left */
|
|
if(nbr_id_from_bl == 64)
|
nbr_id_from_bl = 32;
|
|
if(nbr_id_from_bl == 32)
|
{
|
/* for top left : 1 pel per nbr bit */
|
if(!((nbr_flags_temp >> 8) & 0x1))
|
{
|
nbr_id_from_bl++;
|
nbr_id_from_bl += look_up_trailing_zeros((nbr_flags_temp >> 4) & 0xF) * 8; /* top and top right; 8 pels per nbr bit */
|
//nbr_id_from_bl += idx * 8;
|
}
|
}
|
/* Reverse Substitution Process*/
|
if(nbr_id_from_bl)
|
{
|
/* Replicate the bottom-left and subsequent unavailable pixels with the 1st available pixel above */
|
pu1_ref = pu1_dst[nbr_id_from_bl];
|
for(i = (nbr_id_from_bl - 1); i >= 0; i--)
|
{
|
pu1_dst[i] = pu1_ref;
|
}
|
}
|
}
|
|
/* for the loop of 4*Nt+1 pixels (excluding pixels computed from reverse substitution) */
|
while(nbr_id_from_bl < ((T16_4NT)+1))
|
{
|
/* To Obtain the next unavailable idx flag after reverse neighbor substitution */
|
/* Devide by 8 to obtain the original index */
|
frwd_nbr_flag = (nbr_id_from_bl >> 3); /*+ (nbr_id_from_bl & 0x1);*/
|
|
/* The Top-left flag is at the last bit location of nbr_flags*/
|
if(nbr_id_from_bl == (T16_4NT / 2))
|
{
|
get_bits = GET_BITS(nbr_flags_temp, 8);
|
|
/* only pel substitution for TL */
|
if(!get_bits)
|
pu1_dst[nbr_id_from_bl] = pu1_dst[nbr_id_from_bl - 1];
|
}
|
else
|
{
|
get_bits = GET_BITS(nbr_flags_temp, frwd_nbr_flag);
|
if(!get_bits)
|
{
|
/* 8 pel substitution (other than TL) */
|
pu1_ref = pu1_dst[nbr_id_from_bl - 1];
|
ihevc_memset_mul_8(pu1_dst + nbr_id_from_bl, pu1_ref, 8);
|
|
|
}
|
|
}
|
nbr_id_from_bl += (nbr_id_from_bl == (T16_4NT / 2)) ? 1 : 8;
|
}
|
|
|
}
|
|
if(nt == 32)
|
{
|
/* Else fill the corresponding samples */
|
if(nbr_flags & 0x10000)
|
pu1_dst[two_nt] = *pu1_top_left;
|
else
|
pu1_dst[two_nt] = 0;
|
|
if(nbr_flags & 0xF0)
|
{
|
for(i = 0; i < nt; i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[two_nt - 1 - (nt - 1)], 0, nt);
|
}
|
|
/* Bottom - left availability is checked for every 8x8 TU position and set accordingly */
|
{
|
if(nbr_flags & 0x8)
|
{
|
for(i = nt; i < (nt + 8); i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[24], 0, 8);
|
}
|
|
if(nbr_flags & 0x4)
|
{
|
for(i = (nt + 8); i < (nt + 16); i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[16], 0, 8);
|
}
|
|
if(nbr_flags & 0x2)
|
{
|
for(i = (nt + 16); i < (nt + 24); i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[8], 0, 8);
|
}
|
|
if(nbr_flags & 0x1)
|
{
|
for(i = (nt + 24); i < (two_nt); i++)
|
pu1_dst[two_nt - 1 - i] = pu1_left[i * src_strd];
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[0], 0, 8);
|
}
|
}
|
|
|
if(nbr_flags & 0xF00)
|
{
|
ihevc_memcpy_mul_8(&pu1_dst[two_nt + 1], pu1_top, nt);
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[two_nt + 1], 0, nt);
|
}
|
|
if(nbr_flags & 0xF000)
|
{
|
ihevc_memcpy_mul_8(&pu1_dst[two_nt + 1 + nt], pu1_top + nt, nt);
|
}
|
else
|
{
|
ihevc_memset_mul_8(&pu1_dst[two_nt + 1 + nt], 0, nt);
|
}
|
/* compute trailing ones based on mbr_flag for substitution process of below left see section .*/
|
/* as each bit in nbr flags corresponds to 8 pels for bot_left, left, top and topright but 1 pel for topleft */
|
{
|
nbr_id_from_bl = look_up_trailing_zeros((nbr_flags & 0XFF)) * 8; /* for below left and left */
|
|
if(nbr_id_from_bl == 64)
|
{
|
/* for top left : 1 pel per nbr bit */
|
if(!((nbr_flags >> 16) & 0x1))
|
{
|
/* top left not available */
|
nbr_id_from_bl++;
|
/* top and top right; 8 pels per nbr bit */
|
nbr_id_from_bl += look_up_trailing_zeros((nbr_flags >> 8) & 0xFF) * 8;
|
}
|
}
|
/* Reverse Substitution Process*/
|
if(nbr_id_from_bl)
|
{
|
/* Replicate the bottom-left and subsequent unavailable pixels with the 1st available pixel above */
|
pu1_ref = pu1_dst[nbr_id_from_bl];
|
for(i = (nbr_id_from_bl - 1); i >= 0; i--)
|
pu1_dst[i] = pu1_ref;
|
}
|
}
|
|
/* for the loop of 4*Nt+1 pixels (excluding pixels computed from reverse substitution) */
|
while(nbr_id_from_bl < ((T32_4NT)+1))
|
{
|
/* To Obtain the next unavailable idx flag after reverse neighbor substitution */
|
/* Devide by 8 to obtain the original index */
|
frwd_nbr_flag = (nbr_id_from_bl >> 3); /*+ (nbr_id_from_bl & 0x1);*/
|
|
/* The Top-left flag is at the last bit location of nbr_flags*/
|
if(nbr_id_from_bl == (T32_4NT / 2))
|
{
|
get_bits = GET_BITS(nbr_flags, 16);
|
/* only pel substitution for TL */
|
if(!get_bits)
|
pu1_dst[nbr_id_from_bl] = pu1_dst[nbr_id_from_bl - 1];
|
}
|
else
|
{
|
get_bits = GET_BITS(nbr_flags, frwd_nbr_flag);
|
if(!get_bits)
|
{
|
/* 8 pel substitution (other than TL) */
|
pu1_ref = pu1_dst[nbr_id_from_bl - 1];
|
ihevc_memset_mul_8(&pu1_dst[nbr_id_from_bl], pu1_ref, 8);
|
|
}
|
|
}
|
nbr_id_from_bl += (nbr_id_from_bl == (T32_4NT / 2)) ? 1 : 8;
|
}
|
}
|
|
}
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for ref_filtering
|
*
|
*
|
* @par Description:
|
* Reference DC filtering for neighboring samples dependent on TU size and
|
* mode Refer to section 8.4.4.2.3 in the standard
|
*
|
* @param[in] pu1_src
|
* UWORD8 pointer to the source
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination
|
*
|
* @param[in] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_ref_filtering(UWORD8 *pu1_src,
|
WORD32 nt,
|
UWORD8 *pu1_dst,
|
WORD32 mode,
|
WORD32 strong_intra_smoothing_enable_flag)
|
{
|
WORD32 filter_flag;
|
WORD32 i; /* Generic indexing variable */
|
WORD32 four_nt = 4 * nt;
|
UWORD8 au1_flt[(4 * MAX_CU_SIZE) + 1];
|
WORD32 bi_linear_int_flag = 0;
|
WORD32 abs_cond_left_flag = 0;
|
WORD32 abs_cond_top_flag = 0;
|
/*WORD32 dc_val = 1 << (BIT_DEPTH - 5);*/
|
WORD32 dc_val = 1 << (8 - 5);
|
//WORD32 strong_intra_smoothing_enable_flag = 1;
|
|
filter_flag = gau1_intra_pred_ref_filter[mode] & (1 << (CTZ(nt) - 2));
|
if(0 == filter_flag)
|
{
|
if(pu1_src == pu1_dst)
|
{
|
return;
|
}
|
else
|
{
|
for(i = 0; i < (four_nt + 1); i++)
|
pu1_dst[i] = pu1_src[i];
|
}
|
}
|
|
else
|
{
|
/* If strong intra smoothin is enabled and transform size is 32 */
|
if((1 == strong_intra_smoothing_enable_flag) && (32 == nt))
|
{
|
/* Strong Intra Filtering */
|
abs_cond_top_flag = (ABS(pu1_src[2 * nt] + pu1_src[4 * nt]
|
- (2 * pu1_src[3 * nt]))) < dc_val;
|
abs_cond_left_flag = (ABS(pu1_src[2 * nt] + pu1_src[0]
|
- (2 * pu1_src[nt]))) < dc_val;
|
|
bi_linear_int_flag = ((1 == abs_cond_left_flag)
|
&& (1 == abs_cond_top_flag));
|
}
|
/* Extremities Untouched*/
|
au1_flt[0] = pu1_src[0];
|
au1_flt[4 * nt] = pu1_src[4 * nt];
|
|
/* Strong filtering of reference samples */
|
if(1 == bi_linear_int_flag)
|
{
|
au1_flt[2 * nt] = pu1_src[2 * nt];
|
|
for(i = 1; i < (2 * nt); i++)
|
au1_flt[i] = (((2 * nt) - i) * pu1_src[0] + i * pu1_src[2 * nt] + 32) >> 6;
|
|
for(i = 1; i < (2 * nt); i++)
|
au1_flt[i + (2 * nt)] = (((2 * nt) - i) * pu1_src[2 * nt] + i * pu1_src[4 * nt] + 32) >> 6;
|
|
}
|
else
|
{
|
/* Perform bilinear filtering of Reference Samples */
|
for(i = 0; i < (four_nt - 1); i++)
|
{
|
au1_flt[i + 1] = (pu1_src[i] + 2 * pu1_src[i + 1]
|
+ pu1_src[i + 2] + 2) >> 2;
|
}
|
}
|
|
|
for(i = 0; i < (four_nt + 1); i++)
|
pu1_dst[i] = au1_flt[i];
|
}
|
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma planar
|
*
|
* @par Description:
|
* Planar Intraprediction with reference neighboring samples location
|
* pointed by 'pu1_ref' to the TU block location pointed by 'pu1_dst' Refer
|
* to section 8.4.4.2.4 in the standard
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_planar(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
|
|
WORD32 row, col;
|
WORD32 log2nt = 5;
|
WORD32 two_nt, three_nt;
|
UNUSED(src_strd);
|
UNUSED(mode);
|
switch(nt)
|
{
|
case 32:
|
log2nt = 5;
|
break;
|
case 16:
|
log2nt = 4;
|
break;
|
case 8:
|
log2nt = 3;
|
break;
|
case 4:
|
log2nt = 2;
|
break;
|
default:
|
break;
|
}
|
two_nt = 2 * nt;
|
three_nt = 3 * nt;
|
/* Planar filtering */
|
for(row = 0; row < nt; row++)
|
{
|
for(col = 0; col < nt; col++)
|
{
|
pu1_dst[row * dst_strd + col] = ((nt - 1 - col)
|
* pu1_ref[two_nt - 1 - row]
|
+ (col + 1) * pu1_ref[three_nt + 1]
|
+ (nt - 1 - row) * pu1_ref[two_nt + 1 + col]
|
+ (row + 1) * pu1_ref[nt - 1] + nt) >> (log2nt + 1);
|
}
|
}
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma dc
|
*
|
* @par Description:
|
* Intraprediction for DC mode with reference neighboring samples location
|
* pointed by 'pu1_ref' to the TU block location pointed by 'pu1_dst' Refer
|
* to section 8.4.4.2.5 in the standard
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_dc(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
|
WORD32 acc_dc;
|
WORD32 dc_val, two_dc_val, three_dc_val;
|
WORD32 i;
|
WORD32 row, col;
|
WORD32 log2nt = 5;
|
WORD32 two_nt, three_nt;
|
UNUSED(mode);
|
UNUSED(src_strd);
|
switch(nt)
|
{
|
case 32:
|
log2nt = 5;
|
break;
|
case 16:
|
log2nt = 4;
|
break;
|
case 8:
|
log2nt = 3;
|
break;
|
case 4:
|
log2nt = 2;
|
break;
|
default:
|
break;
|
}
|
two_nt = 2 * nt;
|
three_nt = 3 * nt;
|
|
acc_dc = 0;
|
/* Calculate DC value for the transform block */
|
for(i = nt; i < two_nt; i++)
|
acc_dc += pu1_ref[i];
|
|
for(i = (two_nt + 1); i <= three_nt; i++)
|
acc_dc += pu1_ref[i];
|
|
dc_val = (acc_dc + nt) >> (log2nt + 1);
|
|
two_dc_val = 2 * dc_val;
|
three_dc_val = 3 * dc_val;
|
|
|
if(nt == 32)
|
{
|
for(row = 0; row < nt; row++)
|
for(col = 0; col < nt; col++)
|
pu1_dst[(row * dst_strd) + col] = dc_val;
|
}
|
else
|
{
|
/* DC filtering for the first top row and first left column */
|
pu1_dst[0] = ((pu1_ref[two_nt - 1] + two_dc_val + pu1_ref[two_nt + 1] + 2)
|
>> 2);
|
|
for(col = 1; col < nt; col++)
|
pu1_dst[col] = (pu1_ref[two_nt + 1 + col] + three_dc_val + 2) >> 2;
|
|
for(row = 1; row < nt; row++)
|
pu1_dst[row * dst_strd] = (pu1_ref[two_nt - 1 - row] + three_dc_val + 2)
|
>> 2;
|
|
/* Fill the remaining rows with DC value*/
|
for(row = 1; row < nt; row++)
|
for(col = 1; col < nt; col++)
|
pu1_dst[(row * dst_strd) + col] = dc_val;
|
}
|
}
|
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for horizontal luma variable.
|
*
|
* @par Description:
|
* Horizontal intraprediction(mode 10) with reference samples location
|
* pointed by 'pu1_ref' to the TU block location pointed by 'pu1_dst' Refer
|
* to section 8.4.4.2.6 in the standard (Special case)
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_horz(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
|
WORD32 row, col;
|
WORD32 two_nt;
|
WORD16 s2_predpixel;
|
UNUSED(mode);
|
UNUSED(src_strd);
|
two_nt = 2 * nt;
|
|
if(nt == 32)
|
{
|
for(row = 0; row < nt; row++)
|
for(col = 0; col < nt; col++)
|
pu1_dst[(row * dst_strd) + col] = pu1_ref[two_nt - 1 - row];
|
}
|
else
|
{
|
/*Filtering done for the 1st row */
|
for(col = 0; col < nt; col++)
|
{
|
s2_predpixel = pu1_ref[two_nt - 1]
|
+ ((pu1_ref[two_nt + 1 + col] - pu1_ref[two_nt]) >> 1);
|
pu1_dst[col] = CLIP_U8(s2_predpixel);
|
}
|
|
/* Replication to next rows*/
|
for(row = 1; row < nt; row++)
|
for(col = 0; col < nt; col++)
|
pu1_dst[(row * dst_strd) + col] = pu1_ref[two_nt - 1 - row];
|
}
|
}
|
|
|
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for vertical luma variable.
|
*
|
* @par Description:
|
* Horizontal intraprediction with reference neighboring samples location
|
* pointed by 'pu1_ref' to the TU block location pointed by 'pu1_dst' Refer
|
* to section 8.4.4.2.6 in the standard (Special case)
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_ver(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
WORD32 row, col;
|
WORD16 s2_predpixel;
|
WORD32 two_nt = 2 * nt;
|
UNUSED(mode);
|
UNUSED(src_strd);
|
|
if(nt == 32)
|
{
|
/* Replication to next columns*/
|
for(row = 0; row < nt; row++)
|
for(col = 0; col < nt; col++)
|
pu1_dst[(row * dst_strd) + col] = pu1_ref[two_nt + 1 + col];
|
}
|
else
|
{
|
/*Filtering done for the 1st column */
|
for(row = 0; row < nt; row++)
|
{
|
s2_predpixel = pu1_ref[two_nt + 1]
|
+ ((pu1_ref[two_nt - 1 - row] - pu1_ref[two_nt]) >> 1);
|
pu1_dst[row * dst_strd] = CLIP_U8(s2_predpixel);
|
}
|
|
/* Replication to next columns*/
|
for(row = 0; row < nt; row++)
|
for(col = 1; col < nt; col++)
|
pu1_dst[(row * dst_strd) + col] = pu1_ref[two_nt + 1 + col];
|
}
|
}
|
|
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma mode2.
|
*
|
* @par Description:
|
* Intraprediction for mode 2 (sw angle) with reference neighboring samples
|
* location pointed by 'pu1_ref' to the TU block location pointed by
|
* 'pu1_dst' Refer to section 8.4.4.2.6 in the standard
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_mode2(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
WORD32 row, col;
|
WORD32 two_nt = 2 * nt;
|
WORD32 intra_pred_ang = 32;
|
WORD32 idx = 0;
|
UNUSED(mode);
|
UNUSED(src_strd);
|
/* For the angle 45, replication is done from the corresponding angle */
|
/* intra_pred_ang = tan(angle) in q5 format */
|
for(col = 0; col < nt; col++)
|
{
|
idx = ((col + 1) * intra_pred_ang) >> 5; /* Use idx++ */
|
|
for(row = 0; row < nt; row++)
|
pu1_dst[col + (row * dst_strd)] = pu1_ref[two_nt - row - idx - 1];
|
}
|
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma mode 18 & mode 34.
|
*
|
* @par Description:
|
* Intraprediction for mode 34 (ne angle) and mode 18 (nw angle) with
|
* reference neighboring samples location pointed by 'pu1_ref' to the TU
|
* block location pointed by 'pu1_dst'
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_mode_18_34(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
WORD32 row, col;
|
WORD32 intra_pred_ang;
|
WORD32 idx = 0;
|
WORD32 two_nt = 2 * nt;
|
UNUSED(src_strd);
|
intra_pred_ang = 32; /*Default value*/
|
|
/* For mode 18, angle is -45degree */
|
if(mode == 18)
|
intra_pred_ang = -32;
|
/* For mode 34, angle is 45degree */
|
else if(mode == 34)
|
intra_pred_ang = 32;
|
/* For the angle 45 and -45, replication is done from the corresponding angle */
|
/* No interpolation is done for 45 degree*/
|
for(row = 0; row < nt; row++)
|
{
|
idx = ((row + 1) * intra_pred_ang) >> 5;
|
#if OPT
|
if(mode == 18)
|
idx--;
|
if(mode == 34)
|
idx++;
|
#endif
|
for(col = 0; col < nt; col++)
|
pu1_dst[col + (row * dst_strd)] = pu1_ref[two_nt + col + idx + 1];
|
|
}
|
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma mode 3 to mode 9
|
*
|
* @par Description:
|
* Intraprediction for mode 3 to 9 (positive angle, horizontal mode ) with
|
* reference neighboring samples location pointed by 'pu1_ref' to the TU
|
* block location pointed by 'pu1_dst'
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_mode_3_to_9(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
WORD32 row, col;
|
WORD32 two_nt = 2 * nt;
|
WORD32 intra_pred_ang;
|
WORD32 idx, ref_main_idx;
|
WORD32 pos, fract;
|
UNUSED(src_strd);
|
/* Intra Pred Angle according to the mode */
|
intra_pred_ang = gai4_ihevc_ang_table[mode];
|
|
/* For the angles other then 45 degree, interpolation btw 2 neighboring */
|
/* samples dependent on distance to obtain destination sample */
|
|
for(col = 0; col < nt; col++)
|
{
|
pos = ((col + 1) * intra_pred_ang);
|
idx = pos >> 5;
|
fract = pos & (31);
|
|
// Do linear filtering
|
for(row = 0; row < nt; row++)
|
{
|
ref_main_idx = two_nt - row - idx - 1;
|
pu1_dst[col + (row * dst_strd)] = (((32 - fract)
|
* pu1_ref[ref_main_idx]
|
+ fract * pu1_ref[ref_main_idx - 1] + 16) >> 5);
|
}
|
|
}
|
|
}
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma mode 11 to mode 17
|
*
|
* @par Description:
|
* Intraprediction for mode 11 to 17 (negative angle, horizontal mode )
|
* with reference neighboring samples location pointed by 'pu1_ref' to the
|
* TU block location pointed by 'pu1_dst'
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_mode_11_to_17(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
/* This function and ihevc_intra_pred_luma_mode_19_to_25 are same except*/
|
/* for ref main & side samples assignment,can be combined for */
|
/* optimzation*/
|
|
WORD32 row, col, k;
|
WORD32 two_nt;
|
WORD32 intra_pred_ang, inv_ang, inv_ang_sum;
|
WORD32 idx, ref_main_idx, ref_idx;
|
WORD32 pos, fract;
|
|
UWORD8 ref_temp[2 * MAX_CU_SIZE + 1];
|
UWORD8 *ref_main;
|
UNUSED(src_strd);
|
inv_ang_sum = 128;
|
two_nt = 2 * nt;
|
|
intra_pred_ang = gai4_ihevc_ang_table[mode];
|
|
inv_ang = gai4_ihevc_inv_ang_table[mode - 11];
|
/* Intermediate reference samples for negative angle modes */
|
/* This have to be removed during optimization*/
|
/* For horizontal modes, (ref main = ref left) (ref side = ref above) */
|
|
ref_main = ref_temp + nt - 1;
|
for(k = 0; k < nt + 1; k++)
|
ref_temp[k + nt - 1] = pu1_ref[two_nt - k];
|
|
ref_main = ref_temp + nt - 1;
|
ref_idx = (nt * intra_pred_ang) >> 5;
|
|
/* SIMD Optimization can be done using look-up table for the loop */
|
/* For negative angled derive the main reference samples from side */
|
/* reference samples refer to section 8.4.4.2.6 */
|
for(k = -1; k > ref_idx; k--)
|
{
|
inv_ang_sum += inv_ang;
|
ref_main[k] = pu1_ref[two_nt + (inv_ang_sum >> 8)];
|
}
|
|
/* For the angles other then 45 degree, interpolation btw 2 neighboring */
|
/* samples dependent on distance to obtain destination sample */
|
for(col = 0; col < nt; col++)
|
{
|
pos = ((col + 1) * intra_pred_ang);
|
idx = pos >> 5;
|
fract = pos & (31);
|
|
// Do linear filtering
|
for(row = 0; row < nt; row++)
|
{
|
ref_main_idx = row + idx + 1;
|
pu1_dst[col + (dst_strd * row)] = (UWORD8)(((32 - fract)
|
* ref_main[ref_main_idx]
|
+ fract * ref_main[ref_main_idx + 1] + 16) >> 5);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma mode 19 to mode 25
|
*
|
* @par Description:
|
* Intraprediction for mode 19 to 25 (negative angle, vertical mode ) with
|
* reference neighboring samples location pointed by 'pu1_ref' to the TU
|
* block location pointed by 'pu1_dst'
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_mode_19_to_25(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
|
WORD32 row, col, k;
|
WORD32 two_nt, intra_pred_ang, idx;
|
WORD32 inv_ang, inv_ang_sum, pos, fract;
|
WORD32 ref_main_idx, ref_idx;
|
UWORD8 ref_temp[(2 * MAX_CU_SIZE) + 1];
|
UWORD8 *ref_main;
|
UNUSED(src_strd);
|
two_nt = 2 * nt;
|
intra_pred_ang = gai4_ihevc_ang_table[mode];
|
inv_ang = gai4_ihevc_inv_ang_table[mode - 12];
|
|
/* Intermediate reference samples for negative angle modes */
|
/* This have to be removed during optimization*/
|
/* For horizontal modes, (ref main = ref above) (ref side = ref left) */
|
ref_main = ref_temp + nt - 1;
|
for(k = 0; k < (nt + 1); k++)
|
ref_temp[k + nt - 1] = pu1_ref[two_nt + k];
|
|
ref_idx = (nt * intra_pred_ang) >> 5;
|
inv_ang_sum = 128;
|
|
/* SIMD Optimization can be done using look-up table for the loop */
|
/* For negative angled derive the main reference samples from side */
|
/* reference samples refer to section 8.4.4.2.6 */
|
for(k = -1; k > ref_idx; k--)
|
{
|
inv_ang_sum += inv_ang;
|
ref_main[k] = pu1_ref[two_nt - (inv_ang_sum >> 8)];
|
}
|
|
for(row = 0; row < nt; row++)
|
{
|
pos = ((row + 1) * intra_pred_ang);
|
idx = pos >> 5;
|
fract = pos & (31);
|
|
// Do linear filtering
|
for(col = 0; col < nt; col++)
|
{
|
ref_main_idx = col + idx + 1;
|
pu1_dst[(row * dst_strd) + col] = (UWORD8)(((32 - fract)
|
* ref_main[ref_main_idx]
|
+ fract * ref_main[ref_main_idx + 1] + 16) >> 5);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Intra prediction interpolation filter for luma mode 27 to mode 33
|
*
|
* @par Description:
|
* Intraprediction for mode 27 to 33 (positive angle, vertical mode ) with
|
* reference neighboring samples location pointed by 'pu1_ref' to the TU
|
* block location pointed by 'pu1_dst'
|
*
|
* @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] nt
|
* integer Transform Block size
|
*
|
* @param[in] mode
|
* integer intraprediction mode
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
|
void ihevc_intra_pred_luma_mode_27_to_33(UWORD8 *pu1_ref,
|
WORD32 src_strd,
|
UWORD8 *pu1_dst,
|
WORD32 dst_strd,
|
WORD32 nt,
|
WORD32 mode)
|
{
|
WORD32 row, col;
|
WORD32 two_nt, pos, fract;
|
WORD32 intra_pred_ang;
|
WORD32 idx, ref_main_idx;
|
UNUSED(src_strd);
|
two_nt = 2 * nt;
|
intra_pred_ang = gai4_ihevc_ang_table[mode];
|
|
for(row = 0; row < nt; row++)
|
{
|
pos = ((row + 1) * intra_pred_ang);
|
idx = pos >> 5;
|
fract = pos & (31);
|
|
// Do linear filtering
|
for(col = 0; col < nt; col++)
|
{
|
ref_main_idx = two_nt + col + idx + 1;
|
pu1_dst[col + (row * dst_strd)] = (((32 - fract)
|
* pu1_ref[ref_main_idx]
|
+ fract * pu1_ref[ref_main_idx + 1] + 16) >> 5);
|
}
|
|
}
|
|
}
|
