common/ih264_inter_pred_filters.c

/******************************************************************************
 *
 * 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;
    }
}