/******************************************************************************
|
*
|
* 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_inter_pred_filters.c
|
*
|
* @brief
|
* Contains function definitions for inter prediction interpolation filters
|
*
|
* @author
|
* Ittiam
|
*
|
* @par List of Functions:
|
* - ih264_inter_pred_luma_copy
|
* - ih264_interleave_copy
|
* - ih264_inter_pred_luma_horz
|
* - ih264_inter_pred_luma_vert
|
* - ih264_inter_pred_luma_horz_hpel_vert_hpel
|
* - ih264_inter_pred_luma_horz_qpel
|
* - ih264_inter_pred_luma_vert_qpel
|
* - ih264_inter_pred_luma_horz_qpel_vert_qpel
|
* - ih264_inter_pred_luma_horz_hpel_vert_qpel
|
* - ih264_inter_pred_luma_horz_qpel_vert_hpel
|
* - ih264_inter_pred_luma_bilinear
|
* - ih264_inter_pred_chroma
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
/*****************************************************************************/
|
/* File Includes */
|
/*****************************************************************************/
|
|
/* User include files */
|
#include "ih264_typedefs.h"
|
#include "ih264_macros.h"
|
#include "ih264_platform_macros.h"
|
#include "ih264_inter_pred_filters.h"
|
|
|
/*****************************************************************************/
|
/* Constant Data variables */
|
/*****************************************************************************/
|
|
/* coefficients for 6 tap filtering*/
|
const WORD32 ih264_g_six_tap[3] ={1,-5,20};
|
|
|
/*****************************************************************************/
|
/* Function definitions . */
|
/*****************************************************************************/
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Interprediction luma function for copy
|
*
|
* @par Description:
|
* Copies the array of width 'wd' and height 'ht' from the location pointed
|
* by 'src' to the location pointed by '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] ht
|
* integer height of the array
|
*
|
* @param[in] wd
|
* integer width of the array
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
|
void ih264_inter_pred_luma_copy(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
UNUSED(pu1_tmp);
|
UNUSED(dydx);
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
pu1_dst[col] = pu1_src[col];
|
}
|
|
pu1_src += src_strd;
|
pu1_dst += dst_strd;
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Fucntion for copying to an interleaved destination
|
*
|
* @par Description:
|
* Copies the array of width 'wd' and height 'ht' from the location pointed
|
* by 'src' to the location pointed by '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] ht
|
* integer height of the array
|
*
|
* @param[in] wd
|
* integer width of the array
|
*
|
* @returns
|
*
|
* @remarks
|
* The alternate elements of src will be copied to alternate locations in dsr
|
* Other locations are not touched
|
*
|
*******************************************************************************
|
*/
|
void ih264_interleave_copy(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd)
|
{
|
WORD32 row, col;
|
wd *= 2;
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col+=2)
|
{
|
pu1_dst[col] = pu1_src[col];
|
}
|
|
pu1_src += src_strd;
|
pu1_dst += dst_strd;
|
}
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Interprediction luma filter for horizontal input
|
*
|
* @par Description:
|
* Applies a 6 tap horizontal filter .The output is clipped to 8 bits
|
* sec 8.4.2.2.1 titled "Luma sample interpolation process"
|
*
|
* @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] ht
|
* integer height of the array
|
*
|
* @param[in] wd
|
* integer width of the array
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
void ih264_inter_pred_luma_horz(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
WORD16 i2_tmp;
|
UNUSED(pu1_tmp);
|
UNUSED(dydx);
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
i2_tmp = 0;/*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
i2_tmp = ih264_g_six_tap[0] *
|
(pu1_src[col - 2] + pu1_src[col + 3])
|
+ ih264_g_six_tap[1] *
|
(pu1_src[col - 1] + pu1_src[col + 2])
|
+ ih264_g_six_tap[2] *
|
(pu1_src[col] + pu1_src[col + 1]);
|
i2_tmp = (i2_tmp + 16) >> 5;
|
pu1_dst[col] = CLIP_U8(i2_tmp);
|
}
|
|
pu1_src += src_strd;
|
pu1_dst += dst_strd;
|
}
|
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Interprediction luma filter for vertical input
|
*
|
* @par Description:
|
* Applies a 6 tap vertical filter.The output is clipped to 8 bits
|
* sec 8.4.2.2.1 titled "Luma sample interpolation process"
|
*
|
* @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] ht
|
* integer height of the array
|
*
|
* @param[in] wd
|
* integer width of the array
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
void ih264_inter_pred_luma_vert(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
WORD16 i2_tmp;
|
UNUSED(pu1_tmp);
|
UNUSED(dydx);
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
i2_tmp = 0; /*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
i2_tmp = ih264_g_six_tap[0] *
|
(pu1_src[col - 2 * src_strd] + pu1_src[col + 3 * src_strd])
|
+ ih264_g_six_tap[1] *
|
(pu1_src[col - 1 * src_strd] + pu1_src[col + 2 * src_strd])
|
+ ih264_g_six_tap[2] *
|
(pu1_src[col] + pu1_src[col + 1 * src_strd]);
|
i2_tmp = (i2_tmp + 16) >> 5;
|
pu1_dst[col] = CLIP_U8(i2_tmp);
|
}
|
pu1_src += src_strd;
|
pu1_dst += dst_strd;
|
}
|
}
|
|
/*!
|
**************************************************************************
|
* \if Function name : ih264_inter_pred_luma_horz_hpel_vert_hpel \endif
|
*
|
* \brief
|
* This function implements a two stage cascaded six tap filter. It
|
* applies the six tap filter in the horizontal direction on the
|
* predictor values, followed by applying the same filter in the
|
* vertical direction on the output of the first stage. The six tap
|
* filtering operation is described in sec 8.4.2.2.1 titled "Luma sample
|
* interpolation process"
|
*
|
* \param pu1_src: Pointer to the buffer containing the predictor values.
|
* pu1_src could point to the frame buffer or the predictor buffer.
|
* \param pu1_dst: Pointer to the destination buffer where the output of
|
* the six tap filter is stored.
|
* \param ht: Height of the rectangular pixel grid to be interpolated
|
* \param wd: Width of the rectangular pixel grid to be interpolated
|
* \param src_strd: Width of the buffer pointed to by pu1_src.
|
* \param dst_strd: Width of the destination buffer
|
* \param pu1_tmp: temporary buffer.
|
* \param dydx: x and y reference offset for qpel calculations: UNUSED in this function.
|
*
|
* \return
|
* None.
|
*
|
* \note
|
* This function takes the 8 bit predictor values, applies the six tap
|
* filter in the horizontal direction and outputs the result clipped to
|
* 8 bit precision. The input is stored in the buffer pointed to by
|
* pu1_src while the output is stored in the buffer pointed by pu1_dst.
|
* Both pu1_src and pu1_dst could point to the same buffer i.e. the
|
* six tap filter could be done in place.
|
*
|
**************************************************************************
|
*/
|
void ih264_inter_pred_luma_horz_hpel_vert_hpel(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
WORD32 tmp;
|
WORD16* pi2_pred1_temp;
|
WORD16* pi2_pred1;
|
UNUSED(dydx);
|
pi2_pred1_temp = (WORD16*)pu1_tmp;
|
pi2_pred1_temp += 2;
|
pi2_pred1 = pi2_pred1_temp;
|
for(row = 0; row < ht; row++)
|
{
|
for(col = -2; col < wd + 3; col++)
|
{
|
tmp = 0;/*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
tmp = ih264_g_six_tap[0] *
|
(pu1_src[col - 2 * src_strd] + pu1_src[col + 3 * src_strd])
|
+ ih264_g_six_tap[1] *
|
(pu1_src[col - 1 * src_strd] + pu1_src[col + 2 * src_strd])
|
+ ih264_g_six_tap[2] *
|
(pu1_src[col] + pu1_src[col + 1 * src_strd]);
|
pi2_pred1_temp[col] = tmp;
|
}
|
pu1_src += src_strd;
|
pi2_pred1_temp = pi2_pred1_temp + wd + 5;
|
}
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
tmp = 0;/*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
tmp = ih264_g_six_tap[0] *
|
(pi2_pred1[col - 2] + pi2_pred1[col + 3])
|
+ ih264_g_six_tap[1] *
|
(pi2_pred1[col - 1] + pi2_pred1[col + 2])
|
+ ih264_g_six_tap[2] * (pi2_pred1[col] + pi2_pred1[col + 1]);
|
tmp = (tmp + 512) >> 10;
|
pu1_dst[col] = CLIP_U8(tmp);
|
}
|
pi2_pred1 += (wd + 5);
|
pu1_dst += dst_strd;
|
}
|
}
|
|
/*!
|
**************************************************************************
|
* \if Function name : ih264_inter_pred_luma_horz_qpel \endif
|
*
|
* \brief
|
* This routine applies the six tap filter to the predictors in the
|
* horizontal direction. The six tap filtering operation is described in
|
* sec 8.4.2.2.1 titled "Luma sample interpolation process"
|
*
|
* \param pu1_src: Pointer to the buffer containing the predictor values.
|
* pu1_src could point to the frame buffer or the predictor buffer.
|
* \param pu1_dst: Pointer to the destination buffer where the output of
|
* the six tap filter is stored.
|
* \param ht: Height of the rectangular pixel grid to be interpolated
|
* \param wd: Width of the rectangular pixel grid to be interpolated
|
* \param src_strd: Width of the buffer pointed to by pu1_src.
|
* \param dst_strd: Width of the destination buffer
|
* \param pu1_tmp: temporary buffer: UNUSED in this function
|
* \param dydx: x and y reference offset for qpel calculations.
|
*
|
* \return
|
* None.
|
*
|
* \note
|
* This function takes the 8 bit predictor values, applies the six tap
|
* filter in the horizontal direction and outputs the result clipped to
|
* 8 bit precision. The input is stored in the buffer pointed to by
|
* pu1_src while the output is stored in the buffer pointed by pu1_dst.
|
* Both pu1_src and pu1_dst could point to the same buffer i.e. the
|
* six tap filter could be done in place.
|
*
|
**************************************************************************
|
*/
|
void ih264_inter_pred_luma_horz_qpel(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
UWORD8 *pu1_pred1;
|
WORD32 x_offset = dydx & 0x3;
|
UNUSED(pu1_tmp);
|
pu1_pred1 = pu1_src + (x_offset >> 1);
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++, pu1_src++, pu1_dst++)
|
{
|
WORD16 i2_temp;
|
/* The logic below implements the following equation
|
i2_temp = puc_pred[-2] - 5 * (puc_pred[-1] + puc_pred[2]) +
|
20 * (puc_pred[0] + puc_pred[1]) + puc_pred[3]; */
|
i2_temp = pu1_src[-2] + pu1_src[3]
|
- (pu1_src[-1] + pu1_src[2])
|
+ ((pu1_src[0] + pu1_src[1] - pu1_src[-1] - pu1_src[2]) << 2)
|
+ ((pu1_src[0] + pu1_src[1]) << 4);
|
i2_temp = (i2_temp + 16) >> 5;
|
i2_temp = CLIP_U8(i2_temp);
|
*pu1_dst = (i2_temp + *pu1_pred1 + 1) >> 1;
|
|
pu1_pred1++;
|
}
|
pu1_dst += dst_strd - wd;
|
pu1_src += src_strd - wd;
|
pu1_pred1 += src_strd - wd;
|
}
|
}
|
|
/*!
|
**************************************************************************
|
* \if Function name : ih264_inter_pred_luma_vert_qpel \endif
|
*
|
* \brief
|
* This routine applies the six tap filter to the predictors in the
|
* vertical direction and interpolates them to obtain pixels at quarter vertical
|
* positions (0, 1/4) and (0, 3/4). The six tap filtering operation is
|
* described in sec 8.4.2.2.1 titled "Luma sample interpolation process"
|
*
|
* \param pu1_src: Pointer to the buffer containing the predictor values.
|
* pu1_src could point to the frame buffer or the predictor buffer.
|
* \param pu1_dst: Pointer to the destination buffer where the output of
|
* the six tap filter is stored.
|
* \param ht: Height of the rectangular pixel grid to be interpolated
|
* \param wd: Width of the rectangular pixel grid to be interpolated
|
* \param src_strd: Width of the buffer pointed to by puc_pred.
|
* \param dst_strd: Width of the destination buffer
|
* \param pu1_tmp: temporary buffer: UNUSED in this function
|
* \param dydx: x and y reference offset for qpel calculations.
|
*
|
* \return
|
* void
|
*
|
* \note
|
* This function takes the 8 bit predictor values, applies the six tap
|
* filter in the vertical direction and outputs the result clipped to
|
* 8 bit precision. The input is stored in the buffer pointed to by
|
* puc_pred while the output is stored in the buffer pointed by puc_dest.
|
* Both puc_pred and puc_dest could point to the same buffer i.e. the
|
* six tap filter could be done in place.
|
*
|
* \para <title>
|
* <paragraph>
|
* ...
|
**************************************************************************
|
*/
|
void ih264_inter_pred_luma_vert_qpel(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
WORD32 y_offset = dydx >> 2;
|
WORD32 off1, off2, off3;
|
UWORD8 *pu1_pred1;
|
UNUSED(pu1_tmp);
|
y_offset = y_offset & 0x3;
|
|
off1 = src_strd;
|
off2 = src_strd << 1;
|
off3 = off1 + off2;
|
|
pu1_pred1 = pu1_src + (y_offset >> 1) * src_strd;
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++, pu1_dst++, pu1_src++, pu1_pred1++)
|
{
|
WORD16 i2_temp;
|
/* The logic below implements the following equation
|
i16_temp = puc_pred[-2*src_strd] + puc_pred[3*src_strd] -
|
5 * (puc_pred[-1*src_strd] + puc_pred[2*src_strd]) +
|
20 * (puc_pred[0] + puc_pred[src_strd]); */
|
i2_temp = pu1_src[-off2] + pu1_src[off3]
|
- (pu1_src[-off1] + pu1_src[off2])
|
+ ((pu1_src[0] + pu1_src[off1] - pu1_src[-off1] - pu1_src[off2]) << 2)
|
+ ((pu1_src[0] + pu1_src[off1]) << 4);
|
i2_temp = (i2_temp + 16) >> 5;
|
i2_temp = CLIP_U8(i2_temp);
|
|
*pu1_dst = (i2_temp + *pu1_pred1 + 1) >> 1;
|
}
|
pu1_src += src_strd - wd;
|
pu1_pred1 += src_strd - wd;
|
pu1_dst += dst_strd - wd;
|
}
|
}
|
|
/*!
|
**************************************************************************
|
* \if Function name : ih264_inter_pred_luma_horz_qpel_vert_qpel \endif
|
*
|
* \brief
|
* This routine applies the six tap filter to the predictors in the
|
* vertical and horizontal direction and averages them to get pixels at locations
|
* (1/4,1/4), (1/4, 3/4), (3/4, 1/4) & (3/4, 3/4). The six tap filtering operation
|
* is described in sec 8.4.2.2.1 titled "Luma sample interpolation process"
|
*
|
* \param pu1_src: Pointer to the buffer containing the predictor values.
|
* pu1_src could point to the frame buffer or the predictor buffer.
|
* \param pu1_dst: Pointer to the destination buffer where the output of
|
* the six tap filter is stored.
|
* \param wd: Width of the rectangular pixel grid to be interpolated
|
* \param ht: Height of the rectangular pixel grid to be interpolated
|
* \param src_strd: Width of the buffer pointed to by puc_pred.
|
* \param dst_strd: Width of the destination buffer
|
* \param pu1_tmp: temporary buffer, UNUSED in this function
|
* \param dydx: x and y reference offset for qpel calculations.
|
*
|
* \return
|
* void
|
*
|
* \note
|
* This function takes the 8 bit predictor values, applies the six tap
|
* filter in the vertical direction and outputs the result clipped to
|
* 8 bit precision. The input is stored in the buffer pointed to by
|
* puc_pred while the output is stored in the buffer pointed by puc_dest.
|
* Both puc_pred and puc_dest could point to the same buffer i.e. the
|
* six tap filter could be done in place.
|
*
|
* \para <title>
|
* <paragraph>
|
* ...
|
**************************************************************************
|
*/
|
void ih264_inter_pred_luma_horz_qpel_vert_qpel(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
WORD32 x_offset = dydx & 0x3;
|
WORD32 y_offset = dydx >> 2;
|
|
WORD32 off1, off2, off3;
|
UWORD8* pu1_pred_vert, *pu1_pred_horz;
|
UNUSED(pu1_tmp);
|
y_offset = y_offset & 0x3;
|
|
off1 = src_strd;
|
off2 = src_strd << 1;
|
off3 = off1 + off2;
|
|
pu1_pred_horz = pu1_src + (y_offset >> 1) * src_strd;
|
pu1_pred_vert = pu1_src + (x_offset >> 1);
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd;
|
col++, pu1_dst++, pu1_pred_vert++, pu1_pred_horz++)
|
{
|
WORD16 i2_temp_vert, i2_temp_horz;
|
/* The logic below implements the following equation
|
i2_temp = puc_pred[-2*src_strd] + puc_pred[3*src_strd] -
|
5 * (puc_pred[-1*src_strd] + puc_pred[2*src_strd]) +
|
20 * (puc_pred[0] + puc_pred[src_strd]); */
|
i2_temp_vert = pu1_pred_vert[-off2] + pu1_pred_vert[off3]
|
- (pu1_pred_vert[-off1] + pu1_pred_vert[off2])
|
+ ((pu1_pred_vert[0] + pu1_pred_vert[off1]
|
- pu1_pred_vert[-off1]
|
- pu1_pred_vert[off2]) << 2)
|
+ ((pu1_pred_vert[0] + pu1_pred_vert[off1]) << 4);
|
i2_temp_vert = (i2_temp_vert + 16) >> 5;
|
i2_temp_vert = CLIP_U8(i2_temp_vert);
|
|
/* The logic below implements the following equation
|
i16_temp = puc_pred[-2] - 5 * (puc_pred[-1] + puc_pred[2]) +
|
20 * (puc_pred[0] + puc_pred[1]) + puc_pred[3]; */
|
i2_temp_horz = pu1_pred_horz[-2] + pu1_pred_horz[3]
|
- (pu1_pred_horz[-1] + pu1_pred_horz[2])
|
+ ((pu1_pred_horz[0] + pu1_pred_horz[1]
|
- pu1_pred_horz[-1]
|
- pu1_pred_horz[2]) << 2)
|
+ ((pu1_pred_horz[0] + pu1_pred_horz[1]) << 4);
|
i2_temp_horz = (i2_temp_horz + 16) >> 5;
|
i2_temp_horz = CLIP_U8(i2_temp_horz);
|
*pu1_dst = (i2_temp_vert + i2_temp_horz + 1) >> 1;
|
}
|
pu1_pred_vert += (src_strd - wd);
|
pu1_pred_horz += (src_strd - wd);
|
pu1_dst += (dst_strd - wd);
|
}
|
}
|
|
/*!
|
**************************************************************************
|
* \if Function name : ih264_inter_pred_luma_horz_qpel_vert_hpel \endif
|
*
|
* \brief
|
* This routine applies the six tap filter to the predictors in the vertical
|
* and horizontal direction to obtain the pixel at (1/2,1/2). It then interpolates
|
* pixel at (0,1/2) and (1/2,1/2) to obtain pixel at (1/4,1/2). Similarly for (3/4,1/2).
|
* The six tap filtering operation is described in sec 8.4.2.2.1 titled
|
* "Luma sample interpolation process"
|
*
|
* \param pu1_src: Pointer to the buffer containing the predictor values.
|
* pu1_src could point to the frame buffer or the predictor buffer.
|
* \param pu1_dst: Pointer to the destination buffer where the output of
|
* the six tap filter followed by interpolation is stored.
|
* \param wd: Width of the rectangular pixel grid to be interpolated
|
* \param ht: Height of the rectangular pixel grid to be interpolated
|
* \param src_strd: Width of the buffer pointed to by puc_pred.
|
* \param dst_strd: Width of the destination buffer
|
* \param pu1_tmp: buffer to store temporary output after 1st 6-tap filter.
|
* \param dydx: x and y reference offset for qpel calculations.
|
*
|
* \return
|
* void
|
*
|
* \note
|
* This function takes the 8 bit predictor values, applies the six tap
|
* filter in the vertical direction and outputs the result clipped to
|
* 8 bit precision. The input is stored in the buffer pointed to by
|
* puc_pred while the output is stored in the buffer pointed by puc_dest.
|
* Both puc_pred and puc_dest could point to the same buffer i.e. the
|
* six tap filter could be done in place.
|
*
|
* \para <title>
|
* <paragraph>
|
* ...
|
**************************************************************************
|
*/
|
void ih264_inter_pred_luma_horz_qpel_vert_hpel(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
WORD32 row, col;
|
WORD32 tmp;
|
WORD16* pi2_pred1_temp, *pi2_pred1;
|
UWORD8* pu1_dst_tmp;
|
WORD32 x_offset = dydx & 0x3;
|
WORD16 i2_macro;
|
|
pi2_pred1_temp = (WORD16*)pu1_tmp;
|
pi2_pred1_temp += 2;
|
pi2_pred1 = pi2_pred1_temp;
|
pu1_dst_tmp = pu1_dst;
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = -2; col < wd + 3; col++)
|
{
|
tmp = 0;/*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
tmp = ih264_g_six_tap[0] *
|
(pu1_src[col - 2 * src_strd] + pu1_src[col + 3 * src_strd])
|
+ ih264_g_six_tap[1] *
|
(pu1_src[col - 1 * src_strd] + pu1_src[col + 2 * src_strd])
|
+ ih264_g_six_tap[2] *
|
(pu1_src[col] + pu1_src[col + 1 * src_strd]);
|
pi2_pred1_temp[col] = tmp;
|
}
|
|
pu1_src += src_strd;
|
pi2_pred1_temp = pi2_pred1_temp + wd + 5;
|
}
|
|
pi2_pred1_temp = pi2_pred1;
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
tmp = 0;/*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
tmp = ih264_g_six_tap[0] *
|
(pi2_pred1[col - 2] + pi2_pred1[col + 3])
|
+ ih264_g_six_tap[1] *
|
(pi2_pred1[col - 1] + pi2_pred1[col + 2])
|
+ ih264_g_six_tap[2] *
|
(pi2_pred1[col] + pi2_pred1[col + 1]);
|
tmp = (tmp + 512) >> 10;
|
pu1_dst[col] = CLIP_U8(tmp);
|
}
|
pi2_pred1 += (wd + 5);
|
pu1_dst += dst_strd;
|
}
|
|
pu1_dst = pu1_dst_tmp;
|
pi2_pred1_temp += (x_offset >> 1);
|
for(row = ht; row != 0; row--)
|
{
|
for(col = wd; col != 0; col--, pu1_dst++, pi2_pred1_temp++)
|
{
|
UWORD8 uc_temp;
|
/* Clipping the output of the six tap filter obtained from the
|
first stage of the 2d filter stage */
|
*pi2_pred1_temp = (*pi2_pred1_temp + 16) >> 5;
|
i2_macro = (*pi2_pred1_temp);
|
uc_temp = CLIP_U8(i2_macro);
|
*pu1_dst = (*pu1_dst + uc_temp + 1) >> 1;
|
}
|
pi2_pred1_temp += 5;
|
pu1_dst += dst_strd - wd;
|
}
|
}
|
|
/*!
|
**************************************************************************
|
* \if Function name : ih264_inter_pred_luma_horz_hpel_vert_qpel \endif
|
*
|
* \brief
|
* This routine applies the six tap filter to the predictors in the horizontal
|
* and vertical direction to obtain the pixel at (1/2,1/2). It then interpolates
|
* pixel at (1/2,0) and (1/2,1/2) to obtain pixel at (1/2,1/4). Similarly for (1/2,3/4).
|
* The six tap filtering operation is described in sec 8.4.2.2.1 titled
|
* "Luma sample interpolation process"
|
*
|
* \param pu1_src: Pointer to the buffer containing the predictor values.
|
* pu1_src could point to the frame buffer or the predictor buffer.
|
* \param pu1_dst: Pointer to the destination buffer where the output of
|
* the six tap filter followed by interpolation is stored.
|
* \param wd: Width of the rectangular pixel grid to be interpolated
|
* \param ht: Height of the rectangular pixel grid to be interpolated
|
* \param src_strd: Width of the buffer pointed to by puc_pred.
|
* \param dst_strd: Width of the destination buffer
|
* \param pu1_tmp: buffer to store temporary output after 1st 6-tap filter.
|
* \param dydx: x and y reference offset for qpel calculations.
|
*
|
* \return
|
* void
|
*
|
* \note
|
* This function takes the 8 bit predictor values, applies the six tap
|
* filter in the vertical direction and outputs the result clipped to
|
* 8 bit precision. The input is stored in the buffer pointed to by
|
* puc_pred while the output is stored in the buffer pointed by puc_dest.
|
* Both puc_pred and puc_dest could point to the same buffer i.e. the
|
* six tap filter could be done in place.
|
*
|
* \para <title>
|
* <paragraph>
|
* ...
|
**************************************************************************
|
*/
|
void ih264_inter_pred_luma_horz_hpel_vert_qpel(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd,
|
UWORD8* pu1_tmp,
|
WORD32 dydx)
|
{
|
|
WORD32 row, col;
|
WORD32 tmp;
|
WORD32 y_offset = dydx >> 2;
|
WORD16* pi2_pred1_temp, *pi2_pred1;
|
UWORD8* pu1_dst_tmp;
|
//WORD32 x_offset = dydx & 0x3;
|
WORD16 i2_macro;
|
|
y_offset = y_offset & 0x3;
|
|
pi2_pred1_temp = (WORD16*)pu1_tmp;
|
pi2_pred1_temp += 2 * wd;
|
pi2_pred1 = pi2_pred1_temp;
|
pu1_dst_tmp = pu1_dst;
|
pu1_src -= 2 * src_strd;
|
for(row = -2; row < ht + 3; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
tmp = 0;/*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
tmp = ih264_g_six_tap[0] * (pu1_src[col - 2] + pu1_src[col + 3])
|
+ ih264_g_six_tap[1] * (pu1_src[col - 1] + pu1_src[col + 2])
|
+ ih264_g_six_tap[2] * (pu1_src[col] + pu1_src[col + 1]);
|
pi2_pred1_temp[col - 2 * wd] = tmp;
|
}
|
|
pu1_src += src_strd;
|
pi2_pred1_temp += wd;
|
}
|
pi2_pred1_temp = pi2_pred1;
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
tmp = 0;/*ih264_g_six_tap[] is the array containing the filter coeffs*/
|
tmp = ih264_g_six_tap[0] * (pi2_pred1[col - 2 * wd] + pi2_pred1[col + 3 * wd])
|
+ ih264_g_six_tap[1] * (pi2_pred1[col - 1 * wd] + pi2_pred1[col + 2 * wd])
|
+ ih264_g_six_tap[2] * (pi2_pred1[col] + pi2_pred1[col + 1 * wd]);
|
tmp = (tmp + 512) >> 10;
|
pu1_dst[col] = CLIP_U8(tmp);
|
}
|
pi2_pred1 += wd;
|
pu1_dst += dst_strd;
|
}
|
pu1_dst = pu1_dst_tmp;
|
pi2_pred1_temp += (y_offset >> 1) * wd;
|
for(row = ht; row != 0; row--)
|
|
{
|
for(col = wd; col != 0; col--, pu1_dst++, pi2_pred1_temp++)
|
{
|
UWORD8 u1_temp;
|
/* Clipping the output of the six tap filter obtained from the
|
first stage of the 2d filter stage */
|
*pi2_pred1_temp = (*pi2_pred1_temp + 16) >> 5;
|
i2_macro = (*pi2_pred1_temp);
|
u1_temp = CLIP_U8(i2_macro);
|
*pu1_dst = (*pu1_dst + u1_temp + 1) >> 1;
|
}
|
//pi16_pred1_temp += wd;
|
pu1_dst += dst_strd - wd;
|
}
|
}
|
|
/**
|
*******************************************************************************
|
* function:ih264_inter_pred_luma_bilinear
|
*
|
* @brief
|
* This routine applies the bilinear filter to the predictors .
|
* The filtering operation is described in
|
* sec 8.4.2.2.1 titled "Luma sample interpolation process"
|
*
|
* @par Description:
|
\note
|
* This function is called to obtain pixels lying at the following
|
* locations (1/4,1), (3/4,1),(1,1/4), (1,3/4) ,(1/4,1/2), (3/4,1/2),(1/2,1/4), (1/2,3/4),(3/4,1/4),(1/4,3/4),(3/4,3/4)&& (1/4,1/4) .
|
* The function averages the two adjacent values from the two input arrays in horizontal direction.
|
*
|
*
|
* @param[in] pu1_src1:
|
* UWORD8 Pointer to the buffer containing the first input array.
|
*
|
* @param[in] pu1_src2:
|
* UWORD8 Pointer to the buffer containing the second input array.
|
*
|
* @param[out] pu1_dst
|
* UWORD8 pointer to the destination where the output of bilinear filter is stored.
|
*
|
* @param[in] src_strd1
|
* Stride of the first input buffer
|
*
|
* @param[in] src_strd2
|
* Stride of the second input buffer
|
*
|
* @param[in] dst_strd
|
* integer destination stride of pu1_dst
|
*
|
* @param[in] ht
|
* integer height of the array
|
*
|
* @param[in] wd
|
* integer width of the array
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
void ih264_inter_pred_luma_bilinear(UWORD8 *pu1_src1,
|
UWORD8 *pu1_src2,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd1,
|
WORD32 src_strd2,
|
WORD32 dst_strd,
|
WORD32 ht,
|
WORD32 wd)
|
{
|
WORD32 row, col;
|
WORD16 i2_tmp;
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < wd; col++)
|
{
|
i2_tmp = pu1_src1[col] + pu1_src2[col];
|
i2_tmp = (i2_tmp + 1) >> 1;
|
pu1_dst[col] = CLIP_U8(i2_tmp);
|
}
|
pu1_src1 += src_strd1;
|
pu1_src2 += src_strd2;
|
pu1_dst += dst_strd;
|
}
|
|
}
|
|
/**
|
*******************************************************************************
|
*
|
* @brief
|
* Interprediction chroma filter
|
*
|
* @par Description:
|
* Applies filtering to chroma samples as mentioned in
|
* sec 8.4.2.2.2 titled "chroma sample interpolation process"
|
*
|
* @param[in] pu1_src
|
* UWORD8 pointer to the source containing alternate U and V samples
|
*
|
* @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] u1_dx
|
* dx value where the sample is to be produced(refer sec 8.4.2.2.2 )
|
*
|
* @param[in] u1_dy
|
* dy value where the sample is to be produced(refer sec 8.4.2.2.2 )
|
*
|
* @param[in] ht
|
* integer height of the array
|
*
|
* @param[in] wd
|
* integer width of the array
|
*
|
* @returns
|
*
|
* @remarks
|
* None
|
*
|
*******************************************************************************
|
*/
|
void ih264_inter_pred_chroma(UWORD8 *pu1_src,
|
UWORD8 *pu1_dst,
|
WORD32 src_strd,
|
WORD32 dst_strd,
|
WORD32 dx,
|
WORD32 dy,
|
WORD32 ht,
|
WORD32 wd)
|
{
|
WORD32 row, col;
|
WORD16 i2_tmp;
|
|
for(row = 0; row < ht; row++)
|
{
|
for(col = 0; col < 2 * wd; col++)
|
{
|
i2_tmp = 0; /* applies equation (8-266) in section 8.4.2.2.2 */
|
i2_tmp = (8 - dx) * (8 - dy) * pu1_src[col]
|
+ (dx) * (8 - dy) * pu1_src[col + 2]
|
+ (8 - dx) * (dy) * (pu1_src + src_strd)[col]
|
+ (dx) * (dy) * (pu1_src + src_strd)[col + 2];
|
i2_tmp = (i2_tmp + 32) >> 6;
|
pu1_dst[col] = CLIP_U8(i2_tmp);
|
}
|
pu1_src += src_strd;
|
pu1_dst += dst_strd;
|
}
|
}
|
