/****************************************************************************** * * 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_inter_pred_filters.h" #include "ih264_platform_macros.h" /*****************************************************************************/ /* Constant Data variables */ /*****************************************************************************/ /** ****************************************************************************** * @brief coefficients for 6 tap filtering ****************************************************************************** */ const WORD32 ih264_g_six_tap[3] = { 1, -5, 20 }; /*****************************************************************************/ /* Function definitions . */ /*****************************************************************************/ /** ******************************************************************************* * * @brief function for luma 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 * pointer to the source * * @param[out] pu1_dst * pointer to the destination * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * height of the array * * @param[in] wd * width of the array * * @param[in] pu1_tmp * temporary buffer * * @param[in] dydx * x and y reference offset for qpel calculations * * @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 interleaved 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 * pointer to the source * * @param[out] pu1_dst * pointer to the destination * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * height of the array * * @param[in] wd * 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 * Luma hpel Horizontal Interprediction * * @par Description: * Applies a 6 tap horizontal filter. The output is clipped to 8 bits. * Refer sec 8.4.2.2.1 titled "Luma sample interpolation process" * * @param[in] pu1_src * pointer to the source * * @param[out] pu1_dst * pointer to the destination * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * height of the array * * @param[in] wd * width of the array * * @param[in] pu1_tmp * temporary buffer * * @param[in] dydx * x and y reference offset for qpel calculations * * @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 = 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 * Luma hpel Vertical Interprediction * * @par Description: * Applies a 6 tap vertical filter.The output is clipped to 8 bits * Refer sec 8.4.2.2.1 titled "Luma sample interpolation process" * * @param[in] pu1_src * pointer to the source * * @param[out] pu1_dst * pointer to the destination * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * height of the array * * @param[in] wd * width of the array * * @param[in] pu1_tmp * temporary buffer * * @param[in] dydx * x and y reference offset for qpel calculations * * @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 = 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; } } /** ******************************************************************************* * * @brief * Luma Horizontal hpel & Vertical hpel Interprediction * * @par Description: * 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[in] pu1_src * pointer to the source * * @param[out] pu1_dst * pointer to the destination * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * height of the array * * @param[in] wd * width of the array * * @param[in] pu1_tmp * temporary buffer * * @param[in] dydx * x and y reference offset for qpel calculations * * @returns * * @remarks * 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 = 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 = 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; } } /** ******************************************************************************* * * @brief * Luma Horizontal qpel Interprediction * * @par Description: * This routine applies the six tap filter to the predictors in the * horizontal direction and interpolates them to obtain pixels at quarter * horizontal positions (1/4, 0) and (3/4, 0). The six tap filtering operation * is described in sec 8.4.2.2.1 titled "Luma sample interpolation process" * * @param[in] pu1_src * Pointer to the buffer containing the predictor values. * * @param[out] pu1_dst * Pointer to the destination buffer where the output of the six tap filter is * stored * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * Height of the rectangular pixel grid to be interpolated * * @param[in] wd * Width of the rectangular pixel grid to be interpolated * * @param[in] pu1_tmp * temporary buffer. UNUSED in this function * * @param[in] dydx * x and y reference offset for qpel calculations * * @returns * * @remarks * 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; } } /** ******************************************************************************* * * @brief * Luma vertical qpel Interprediction * * @par Description: * 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[in] pu1_src * Pointer to the buffer containing the predictor values. * * @param[out] pu1_dst * Pointer to the destination buffer where the output of the six tap filter is * stored * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * Height of the rectangular pixel grid to be interpolated * * @param[in] wd * Width of the rectangular pixel grid to be interpolated * * @param[in] pu1_tmp * temporary buffer. UNUSED in this function * * @param[in] dydx * x and y reference offset for qpel calculations * * @returns * * @remarks * 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_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; } } /** ******************************************************************************* * * @brief * Luma Horizontal qpel and vertical qpel Interprediction * * @par Description: * This routine applies the six tap filter to the predictors in the * vertical and horizontal direction 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[in] pu1_src * Pointer to the buffer containing the predictor values. * * @param[out] pu1_dst * Pointer to the destination buffer where the output of the six tap filter is * stored * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * Height of the rectangular pixel grid to be interpolated * * @param[in] wd * Width of the rectangular pixel grid to be interpolated * * @param[in] pu1_tmp * temporary buffer. UNUSED in this function * * @param[in] dydx * x and y reference offset for qpel calculations * * @returns * * @remarks * 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_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); } } /** ******************************************************************************* * * @brief * Luma Horizontal qpel and vertical hpel Interprediction * * @par Description: * 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[in] pu1_src * Pointer to the buffer containing the predictor values. * * @param[out] pu1_dst * Pointer to the destination buffer where the output of the six tap filter is * stored * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * Height of the rectangular pixel grid to be interpolated * * @param[in] wd * Width of the rectangular pixel grid to be interpolated * * @param[in] pu1_tmp * temporary buffer. UNUSED in this function * * @param[in] dydx * x and y reference offset for qpel calculations * * @returns * * @remarks * 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_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 * <paragraph> * ... ************************************************************************** */ /** ******************************************************************************* * * @brief * Luma Horizontal hpel and vertical qpel Interprediction * * @par Description: * 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 (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[in] pu1_src * Pointer to the buffer containing the predictor values. * * @param[out] pu1_dst * Pointer to the destination buffer where the output of the six tap filter is * stored * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] ht * Height of the rectangular pixel grid to be interpolated * * @param[in] wd * Width of the rectangular pixel grid to be interpolated * * @param[in] pu1_tmp * temporary buffer. UNUSED in this function * * @param[in] dydx * x and y reference offset for qpel calculations * * @returns * * @remarks * 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_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; } } /** ******************************************************************************* * * @brief This routine applies the bilinear filter to the predictors. * * @par Description 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". 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) * and (1/4,1/4). The function averages the two adjacent values from the two * input arrays in horizontal direction. * * @param[in] pu1_src1: * Pointer to the buffer containing the first input array. * * @param[in] pu1_src2: * Pointer to the buffer containing the second input array. * * @param[out] pu1_dst * 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 * destination stride of pu1_dst * * @param[in] ht * height of the array * * @param[in] wd * 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 * pointer to the source containing alternate U and V samples * * @param[out] pu1_dst * pointer to the destination * * @param[in] src_strd * source stride * * @param[in] dst_strd * destination stride * * @param[in] dx * dx value where the sample is to be produced (refer sec 8.4.2.2.2 ) * * @param[in] 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; } }