开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mc.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：29k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mc.c：源码内容
  1. /*****************************************************************************
  2.  * mc.c: h264 encoder library (Motion Compensation)
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2008 x264 project
  5.  *
  6.  * Authors: Eric Petit <eric.petit@lapsus.org>
  7.  *          Guillaume Poirier <gpoirier@mplayerhq.hu>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <stdint.h>
  28. #include <stdarg.h>
  30. #include "x264.h"
  31. #include "common/common.h"
  32. #include "common/mc.h"
  33. #include "mc.h"
  34. #include "ppccommon.h"
  36. typedef void (*pf_mc_t)( uint8_t *src, int i_src,
  37.                          uint8_t *dst, int i_dst, int i_height );
  40. static const int hpel_ref0[16] = {0,1,1,1,0,1,1,1,2,3,3,3,0,1,1,1};
  41. static const int hpel_ref1[16] = {0,0,0,0,2,2,3,2,2,2,3,2,2,2,3,2};
  44. static inline int x264_tapfilter( uint8_t *pix, int i_pix_next )
  45. {
  46.     return pix[-2*i_pix_next] - 5*pix[-1*i_pix_next] + 20*(pix[0] +
  47.            pix[1*i_pix_next]) - 5*pix[ 2*i_pix_next] +
  48.            pix[ 3*i_pix_next];
  49. }
  50. static inline int x264_tapfilter1( uint8_t *pix )
  51. {
  52.     return pix[-2] - 5*pix[-1] + 20*(pix[0] + pix[1]) - 5*pix[ 2] +
  53.            pix[ 3];
  54. }
  57. static inline void x264_pixel_avg2_w4_altivec( uint8_t *dst,  int i_dst,
  58.                                                uint8_t *src1, int i_src1,
  59.                                                uint8_t *src2, int i_height )
  60. {
  61.     int x, y;
  62.     for( y = 0; y < i_height; y++ )
  63.     {
  64.         for( x = 0; x < 4; x++ )
  65.         {
  66.             dst[x] = ( src1[x] + src2[x] + 1 ) >> 1;
  67.         }
  68.         dst  += i_dst;
  69.         src1 += i_src1;
  70.         src2 += i_src1;
  71.     }
  72. }
  74. static inline void x264_pixel_avg2_w8_altivec( uint8_t *dst,  int i_dst,
  75.                                                uint8_t *src1, int i_src1,
  76.                                                uint8_t *src2, int i_height )
  77. {
  78.     int y;
  79.     vec_u8_t src1v, src2v;
  80.     PREP_LOAD;
  81.     PREP_STORE8;
  82.     PREP_LOAD_SRC( src1 );
  83.     PREP_LOAD_SRC( src2 );
  85.     for( y = 0; y < i_height; y++ )
  86.     {
  87.         VEC_LOAD( src1, src1v, 8, vec_u8_t, src1 );
  88.         VEC_LOAD( src2, src2v, 8, vec_u8_t, src2 );
  89.         src1v = vec_avg( src1v, src2v );
  90.         VEC_STORE8( src1v, dst );
  92.         dst  += i_dst;
  93.         src1 += i_src1;
  94.         src2 += i_src1;
  95.     }
  96. }
  98. static inline void x264_pixel_avg2_w16_altivec( uint8_t *dst,  int i_dst,
  99.                                                 uint8_t *src1, int i_src1,
  100.                                                 uint8_t *src2, int i_height )
  101. {
  102.     int y;
  103.     vec_u8_t src1v, src2v;
  104.     PREP_LOAD;
  105.     PREP_LOAD_SRC( src1 );
  106.     PREP_LOAD_SRC( src2 );
  108.     for( y = 0; y < i_height; y++ )
  109.     {
  110.         VEC_LOAD( src1, src1v, 16, vec_u8_t, src1 );
  111.         VEC_LOAD( src2, src2v, 16, vec_u8_t, src2 );
  112.         src1v = vec_avg( src1v, src2v );
  113.         vec_st(src1v, 0, dst);
  115.         dst  += i_dst;
  116.         src1 += i_src1;
  117.         src2 += i_src1;
  118.     }
  119. }
  121. static inline void x264_pixel_avg2_w20_altivec( uint8_t *dst,  int i_dst,
  122.                                                 uint8_t *src1, int i_src1,
  123.                                                 uint8_t *src2, int i_height )
  124. {
  125.     x264_pixel_avg2_w16_altivec(dst, i_dst, src1, i_src1, src2, i_height);
  126.     x264_pixel_avg2_w4_altivec(dst+16, i_dst, src1+16, i_src1, src2+16, i_height);
  127. }
  129. /* mc_copy: plain c */
  131. #define MC_COPY( name, a )                                
  132. static void name( uint8_t *dst, int i_dst,                
  133.                   uint8_t *src, int i_src, int i_height ) 
  134. {                                                         
  135.     int y;                                                
  136.     for( y = 0; y < i_height; y++ )                       
  137.     {                                                     
  138.         memcpy( dst, src, a );                            
  139.         src += i_src;                                     
  140.         dst += i_dst;                                     
  141.     }                                                     
  142. }
  143. MC_COPY( x264_mc_copy_w4_altivec,  4  )
  144. MC_COPY( x264_mc_copy_w8_altivec,  8  )
  146. static void x264_mc_copy_w16_altivec( uint8_t *dst, int i_dst,
  147.                                       uint8_t *src, int i_src, int i_height )
  148. {
  149.     int y;
  150.     vec_u8_t cpyV;
  151.     PREP_LOAD;
  152.     PREP_LOAD_SRC( src );
  154.     for( y = 0; y < i_height; y++)
  155.     {
  156.         VEC_LOAD( src, cpyV, 16, vec_u8_t, src );
  157.         vec_st(cpyV, 0, dst);
  159.         src += i_src;
  160.         dst += i_dst;
  161.     }
  162. }
  165. static void x264_mc_copy_w16_aligned_altivec( uint8_t *dst, int i_dst,
  166.                                               uint8_t *src, int i_src, int i_height )
  167. {
  168.     int y;
  170.     for( y = 0; y < i_height; ++y)
  171.     {
  172.         vec_u8_t cpyV = vec_ld( 0, src);
  173.         vec_st(cpyV, 0, dst);
  175.         src += i_src;
  176.         dst += i_dst;
  177.     }
  178. }
  181. static void mc_luma_altivec( uint8_t *dst,    int i_dst_stride,
  182.                              uint8_t *src[4], int i_src_stride,
  183.                              int mvx, int mvy,
  184.                              int i_width, int i_height )
  185. {
  186.     int qpel_idx = ((mvy&3)<<2) + (mvx&3);
  187.     int offset = (mvy>>2)*i_src_stride + (mvx>>2);
  188.     uint8_t *src1 = src[hpel_ref0[qpel_idx]] + offset + ((mvy&3) == 3) * i_src_stride;
  189.     if( qpel_idx & 5 ) /* qpel interpolation needed */
  190.     {
  191.         uint8_t *src2 = src[hpel_ref1[qpel_idx]] + offset + ((mvx&3) == 3);
  193.         switch(i_width) {
  194.         case 4:
  195.             x264_pixel_avg2_w4_altivec( dst, i_dst_stride, src1, i_src_stride, src2, i_height );
  196.             break;
  197.         case 8:
  198.             x264_pixel_avg2_w8_altivec( dst, i_dst_stride, src1, i_src_stride, src2, i_height );
  199.             break;
  200.         case 16:
  201.         default:
  202.             x264_pixel_avg2_w16_altivec( dst, i_dst_stride, src1, i_src_stride, src2, i_height );
  203.         }
  205.     }
  206.     else
  207.     {
  208.         switch(i_width) {
  209.         case 4:
  210.             x264_mc_copy_w4_altivec( dst, i_dst_stride, src1, i_src_stride, i_height );
  211.             break;
  212.         case 8:
  213.             x264_mc_copy_w8_altivec( dst, i_dst_stride, src1, i_src_stride, i_height );
  214.             break;
  215.         case 16:
  216.             x264_mc_copy_w16_altivec( dst, i_dst_stride, src1, i_src_stride, i_height );
  217.             break;
  218.         }
  219.     }
  220. }
  224. static uint8_t *get_ref_altivec( uint8_t *dst,   int *i_dst_stride,
  225.                                  uint8_t *src[4], int i_src_stride,
  226.                                  int mvx, int mvy,
  227.                                  int i_width, int i_height )
  228. {
  229.     int qpel_idx = ((mvy&3)<<2) + (mvx&3);
  230.     int offset = (mvy>>2)*i_src_stride + (mvx>>2);
  231.     uint8_t *src1 = src[hpel_ref0[qpel_idx]] + offset + ((mvy&3) == 3) * i_src_stride;
  232.     if( qpel_idx & 5 ) /* qpel interpolation needed */
  233.     {
  234.         uint8_t *src2 = src[hpel_ref1[qpel_idx]] + offset + ((mvx&3) == 3);
  235.         switch(i_width) {
  236.         case 4:
  237.             x264_pixel_avg2_w4_altivec( dst, *i_dst_stride, src1, i_src_stride, src2, i_height );
  238.             break;
  239.         case 8:
  240.             x264_pixel_avg2_w8_altivec( dst, *i_dst_stride, src1, i_src_stride, src2, i_height );
  241.             break;
  242.         case 12:
  243.         case 16:
  244.         default:
  245.             x264_pixel_avg2_w16_altivec( dst, *i_dst_stride, src1, i_src_stride, src2, i_height );
  246.             break;
  247.         case 20:
  248.             x264_pixel_avg2_w20_altivec( dst, *i_dst_stride, src1, i_src_stride, src2, i_height );
  249.             break;
  250.         }
  251.         return dst;
  252.     }
  253.     else
  254.     {
  255.         *i_dst_stride = i_src_stride;
  256.         return src1;
  257.     }
  258. }
  260. static void mc_chroma_2xh( uint8_t *dst, int i_dst_stride,
  261.                            uint8_t *src, int i_src_stride,
  262.                            int mvx, int mvy,
  263.                            int i_height )
  264. {
  265.     uint8_t *srcp;
  266.     int y;
  267.     int d8x = mvx&0x07;
  268.     int d8y = mvy&0x07;
  270.     const int cA = (8-d8x)*(8-d8y);
  271.     const int cB = d8x    *(8-d8y);
  272.     const int cC = (8-d8x)*d8y;
  273.     const int cD = d8x    *d8y;
  275.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  276.     srcp  = &src[i_src_stride];
  278.     for( y = 0; y < i_height; y++ )
  279.     {
  280.         dst[0] = ( cA*src[0] +  cB*src[0+1] +
  281.                   cC*srcp[0] + cD*srcp[0+1] + 32 ) >> 6;
  282.         dst[1] = ( cA*src[1] +  cB*src[1+1] +
  283.                   cC*srcp[1] + cD*srcp[1+1] + 32 ) >> 6;
  285.         src  += i_src_stride;
  286.         srcp += i_src_stride;
  287.         dst  += i_dst_stride;
  288.     }
  289.  }
  292. #define DO_PROCESS_W4( a )  
  293.     dstv_16A = vec_mladd( src##a##v_16A, coeff##a##v, dstv_16A );   
  294.     dstv_16B = vec_mladd( src##a##v_16B, coeff##a##v, dstv_16B )
  296. static void mc_chroma_altivec_4xh( uint8_t *dst, int i_dst_stride,
  297.                                    uint8_t *src, int i_src_stride,
  298.                                    int mvx, int mvy,
  299.                                    int i_height )
  300. {
  301.     uint8_t *srcp;
  302.     int y;
  303.     int d8x = mvx & 0x07;
  304.     int d8y = mvy & 0x07;
  306.     ALIGNED_16( uint16_t coeff[4] );
  307.     coeff[0] = (8-d8x)*(8-d8y);
  308.     coeff[1] = d8x    *(8-d8y);
  309.     coeff[2] = (8-d8x)*d8y;
  310.     coeff[3] = d8x    *d8y;
  312.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  313.     srcp  = &src[i_src_stride];
  315.     LOAD_ZERO;
  316.     PREP_LOAD;
  317.     PREP_LOAD_SRC( src );
  318.     vec_u16_t   coeff0v, coeff1v, coeff2v, coeff3v;
  319.     vec_u8_t    src2v_8A, dstv_8A;
  320.     vec_u8_t    src2v_8B, dstv_8B;
  321.     vec_u16_t   src0v_16A, src1v_16A, src2v_16A, src3v_16A, dstv_16A;
  322.     vec_u16_t   src0v_16B, src1v_16B, src2v_16B, src3v_16B, dstv_16B;
  323.     vec_u16_t   shiftv, k32v;
  325.     coeff0v = vec_ld( 0, coeff );
  326.     coeff3v = vec_splat( coeff0v, 3 );
  327.     coeff2v = vec_splat( coeff0v, 2 );
  328.     coeff1v = vec_splat( coeff0v, 1 );
  329.     coeff0v = vec_splat( coeff0v, 0 );
  330.     k32v    = vec_sl( vec_splat_u16( 1 ), vec_splat_u16( 5 ) );
  331.     shiftv  = vec_splat_u16( 6 );
  333.     VEC_LOAD( src, src2v_8B, 5, vec_u8_t, src );
  334.     src2v_16B = vec_u8_to_u16( src2v_8B );
  335.     src3v_16B = vec_sld( src2v_16B, src2v_16B, 2 );
  337.     for( y = 0; y < i_height; y+=2 )
  338.     {
  339.         src0v_16A = src2v_16B;
  340.         src1v_16A = src3v_16B;
  342.         VEC_LOAD_G( srcp, src2v_8A, 5, vec_u8_t );
  343.         srcp += i_src_stride;
  344.         VEC_LOAD_G( srcp, src2v_8B, 5, vec_u8_t );
  345.         srcp += i_src_stride;
  346.         src2v_16A = vec_u8_to_u16( src2v_8A );
  347.         src2v_16B = vec_u8_to_u16( src2v_8B );
  348.         src3v_16A = vec_sld( src2v_16A, src2v_16A, 2 );
  349.         src3v_16B = vec_sld( src2v_16B, src2v_16B, 2 );
  351.         src0v_16B = src2v_16A;
  352.         src1v_16B = src3v_16A;
  354.         dstv_16A = dstv_16B = k32v;
  355.         DO_PROCESS_W4( 0 );
  356.         DO_PROCESS_W4( 1 );
  357.         DO_PROCESS_W4( 2 );
  358.         DO_PROCESS_W4( 3 );
  360.         dstv_16A = vec_sr( dstv_16A, shiftv );
  361.         dstv_16B = vec_sr( dstv_16B, shiftv );
  362.         dstv_8A  = vec_u16_to_u8( dstv_16A );
  363.         dstv_8B  = vec_u16_to_u8( dstv_16B );
  364.         vec_ste( vec_splat( (vec_u32_t) dstv_8A, 0 ), 0, (uint32_t*) dst );
  365.         dst += i_dst_stride;
  366.         vec_ste( vec_splat( (vec_u32_t) dstv_8B, 0 ), 0, (uint32_t*) dst );
  367.         dst += i_dst_stride;
  368.     }
  369. }
  371. #define DO_PROCESS_W8( a )  
  372.     src##a##v_16A = vec_u8_to_u16( src##a##v_8A );  
  373.     src##a##v_16B = vec_u8_to_u16( src##a##v_8B );  
  374.     dstv_16A = vec_mladd( src##a##v_16A, coeff##a##v, dstv_16A );   
  375.     dstv_16B = vec_mladd( src##a##v_16B, coeff##a##v, dstv_16B )
  377. static void mc_chroma_altivec_8xh( uint8_t *dst, int i_dst_stride,
  378.                                    uint8_t *src, int i_src_stride,
  379.                                    int mvx, int mvy,
  380.                                    int i_height )
  381. {
  382.     uint8_t *srcp;
  383.     int y;
  384.     int d8x = mvx & 0x07;
  385.     int d8y = mvy & 0x07;
  387.     ALIGNED_16( uint16_t coeff[4] );
  388.     coeff[0] = (8-d8x)*(8-d8y);
  389.     coeff[1] = d8x    *(8-d8y);
  390.     coeff[2] = (8-d8x)*d8y;
  391.     coeff[3] = d8x    *d8y;
  393.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  394.     srcp  = &src[i_src_stride];
  396.     LOAD_ZERO;
  397.     PREP_LOAD;
  398.     PREP_LOAD_SRC( src );
  399.     PREP_STORE8;
  400.     vec_u16_t   coeff0v, coeff1v, coeff2v, coeff3v;
  401.     vec_u8_t    src0v_8A, src1v_8A, src2v_8A, src3v_8A, dstv_8A;
  402.     vec_u8_t    src0v_8B, src1v_8B, src2v_8B, src3v_8B, dstv_8B;
  403.     vec_u16_t   src0v_16A, src1v_16A, src2v_16A, src3v_16A, dstv_16A;
  404.     vec_u16_t   src0v_16B, src1v_16B, src2v_16B, src3v_16B, dstv_16B;
  405.     vec_u16_t   shiftv, k32v;
  407.     coeff0v = vec_ld( 0, coeff );
  408.     coeff3v = vec_splat( coeff0v, 3 );
  409.     coeff2v = vec_splat( coeff0v, 2 );
  410.     coeff1v = vec_splat( coeff0v, 1 );
  411.     coeff0v = vec_splat( coeff0v, 0 );
  412.     k32v    = vec_sl( vec_splat_u16( 1 ), vec_splat_u16( 5 ) );
  413.     shiftv  = vec_splat_u16( 6 );
  415.     VEC_LOAD( src, src2v_8B, 9, vec_u8_t, src );
  416.     src3v_8B = vec_sld( src2v_8B, src2v_8B, 1 );
  418.     for( y = 0; y < i_height; y+=2 )
  419.     {
  420.         src0v_8A = src2v_8B;
  421.         src1v_8A = src3v_8B;
  423.         VEC_LOAD_G( srcp, src2v_8A, 9, vec_u8_t );
  424.         srcp += i_src_stride;
  425.         VEC_LOAD_G( srcp, src2v_8B, 9, vec_u8_t );
  426.         srcp += i_src_stride;
  427.         src3v_8A = vec_sld( src2v_8A, src2v_8A, 1 );
  428.         src3v_8B = vec_sld( src2v_8B, src2v_8B, 1 );
  430.         src0v_8B = src2v_8A;
  431.         src1v_8B = src3v_8A;
  432.         dstv_16A = dstv_16B = k32v;
  433.         DO_PROCESS_W8( 0 );
  434.         DO_PROCESS_W8( 1 );
  435.         DO_PROCESS_W8( 2 );
  436.         DO_PROCESS_W8( 3 );
  438.         dstv_16A = vec_sr( dstv_16A, shiftv );
  439.         dstv_16B = vec_sr( dstv_16B, shiftv );
  440.         dstv_8A  = vec_u16_to_u8( dstv_16A );
  441.         dstv_8B  = vec_u16_to_u8( dstv_16B );
  442.         VEC_STORE8( dstv_8A, dst );
  443.         dst += i_dst_stride;
  444.         VEC_STORE8( dstv_8B, dst );
  445.         dst += i_dst_stride;
  446.     }
  447. }
  449. static void mc_chroma_altivec( uint8_t *dst, int i_dst_stride,
  450.                                uint8_t *src, int i_src_stride,
  451.                                int mvx, int mvy,
  452.                                int i_width, int i_height )
  453. {
  454.     if( i_width == 8 )
  455.     {
  456.         mc_chroma_altivec_8xh( dst, i_dst_stride, src, i_src_stride,
  457.                                mvx, mvy, i_height );
  458.     }
  459.     else if( i_width == 4 )
  460.     {
  461.         mc_chroma_altivec_4xh( dst, i_dst_stride, src, i_src_stride,
  462.                                mvx, mvy, i_height );
  463.     }
  464.     else
  465.     {
  466.         mc_chroma_2xh( dst, i_dst_stride, src, i_src_stride,
  467.                        mvx, mvy, i_height );
  468.     }
  469. }
  471. #define HPEL_FILTER_1( t1v, t2v, t3v, t4v, t5v, t6v ) 
  472. {                                                     
  473.     t1v = vec_add( t1v, t6v );                        
  474.     t2v = vec_add( t2v, t5v );                        
  475.     t3v = vec_add( t3v, t4v );                        
  476.                                                       
  477.     t1v = vec_sub( t1v, t2v );   /* (a-b) */          
  478.     t2v = vec_sub( t2v, t3v );   /* (b-c) */          
  479.     t2v = vec_sl(  t2v, twov );  /* (b-c)*4 */        
  480.     t1v = vec_sub( t1v, t2v );   /* a-5*b+4*c */      
  481.     t3v = vec_sl(  t3v, fourv ); /* 16*c */           
  482.     t1v = vec_add( t1v, t3v );   /* a-5*b+20*c */     
  483. }
  485. #define HPEL_FILTER_2( t1v, t2v, t3v, t4v, t5v, t6v ) 
  486. {                                                     
  487.     t1v = vec_add( t1v, t6v );                        
  488.     t2v = vec_add( t2v, t5v );                        
  489.     t3v = vec_add( t3v, t4v );                        
  490.                                                       
  491.     t1v = vec_sub( t1v, t2v );  /* (a-b) */           
  492.     t1v = vec_sra( t1v, twov ); /* (a-b)/4 */         
  493.     t1v = vec_sub( t1v, t2v );  /* (a-b)/4-b */       
  494.     t1v = vec_add( t1v, t3v );  /* (a-b)/4-b+c */     
  495.     t1v = vec_sra( t1v, twov ); /* ((a-b)/4-b+c)/4 */ 
  496.     t1v = vec_add( t1v, t3v );  /* ((a-b)/4-b+c)/4+c = (a-5*b+20*c)/16 */ 
  497. }
  499. #define HPEL_FILTER_HORIZONTAL()                             
  500. {                                                            
  501.     VEC_LOAD_G( &src[x- 2+i_stride*y], src1v, 16, vec_u8_t); 
  502.     VEC_LOAD_G( &src[x+14+i_stride*y], src6v, 16, vec_u8_t); 
  503.                                                              
  504.     src2v = vec_sld( src1v, src6v,  1 );                     
  505.     src3v = vec_sld( src1v, src6v,  2 );                     
  506.     src4v = vec_sld( src1v, src6v,  3 );                     
  507.     src5v = vec_sld( src1v, src6v,  4 );                     
  508.     src6v = vec_sld( src1v, src6v,  5 );                     
  509.                                                              
  510.     temp1v = vec_u8_to_s16_h( src1v );                       
  511.     temp2v = vec_u8_to_s16_h( src2v );                       
  512.     temp3v = vec_u8_to_s16_h( src3v );                       
  513.     temp4v = vec_u8_to_s16_h( src4v );                       
  514.     temp5v = vec_u8_to_s16_h( src5v );                       
  515.     temp6v = vec_u8_to_s16_h( src6v );                       
  516.                                                              
  517.     HPEL_FILTER_1( temp1v, temp2v, temp3v,                   
  518.                    temp4v, temp5v, temp6v );                 
  519.                                                              
  520.     dest1v = vec_add( temp1v, sixteenv );                    
  521.     dest1v = vec_sra( dest1v, fivev );                       
  522.                                                              
  523.     temp1v = vec_u8_to_s16_l( src1v );                       
  524.     temp2v = vec_u8_to_s16_l( src2v );                       
  525.     temp3v = vec_u8_to_s16_l( src3v );                       
  526.     temp4v = vec_u8_to_s16_l( src4v );                       
  527.     temp5v = vec_u8_to_s16_l( src5v );                       
  528.     temp6v = vec_u8_to_s16_l( src6v );                       
  529.                                                              
  530.     HPEL_FILTER_1( temp1v, temp2v, temp3v,                   
  531.                    temp4v, temp5v, temp6v );                 
  532.                                                              
  533.     dest2v = vec_add( temp1v, sixteenv );                    
  534.     dest2v = vec_sra( dest2v, fivev );                       
  535.                                                              
  536.     destv = vec_packsu( dest1v, dest2v );                    
  537.                                                              
  538.     VEC_STORE16( destv, &dsth[x+i_stride*y], dsth );         
  539. }
  541. #define HPEL_FILTER_VERTICAL()                                    
  542. {                                                                 
  543.     VEC_LOAD( &src[x+i_stride*(y-2)], src1v, 16, vec_u8_t, src ); 
  544.     VEC_LOAD( &src[x+i_stride*(y-1)], src2v, 16, vec_u8_t, src ); 
  545.     VEC_LOAD( &src[x+i_stride*(y-0)], src3v, 16, vec_u8_t, src ); 
  546.     VEC_LOAD( &src[x+i_stride*(y+1)], src4v, 16, vec_u8_t, src ); 
  547.     VEC_LOAD( &src[x+i_stride*(y+2)], src5v, 16, vec_u8_t, src ); 
  548.     VEC_LOAD( &src[x+i_stride*(y+3)], src6v, 16, vec_u8_t, src ); 
  549.                                                                   
  550.     temp1v = vec_u8_to_s16_h( src1v );                            
  551.     temp2v = vec_u8_to_s16_h( src2v );                            
  552.     temp3v = vec_u8_to_s16_h( src3v );                            
  553.     temp4v = vec_u8_to_s16_h( src4v );                            
  554.     temp5v = vec_u8_to_s16_h( src5v );                            
  555.     temp6v = vec_u8_to_s16_h( src6v );                            
  556.                                                                   
  557.     HPEL_FILTER_1( temp1v, temp2v, temp3v,                        
  558.                    temp4v, temp5v, temp6v );                      
  559.                                                                   
  560.     dest1v = vec_add( temp1v, sixteenv );                         
  561.     dest1v = vec_sra( dest1v, fivev );                            
  562.                                                                   
  563.     temp4v = vec_u8_to_s16_l( src1v );                            
  564.     temp5v = vec_u8_to_s16_l( src2v );                            
  565.     temp6v = vec_u8_to_s16_l( src3v );                            
  566.     temp7v = vec_u8_to_s16_l( src4v );                            
  567.     temp8v = vec_u8_to_s16_l( src5v );                            
  568.     temp9v = vec_u8_to_s16_l( src6v );                            
  569.                                                                   
  570.     HPEL_FILTER_1( temp4v, temp5v, temp6v,                        
  571.                    temp7v, temp8v, temp9v );                      
  572.                                                                   
  573.     dest2v = vec_add( temp4v, sixteenv );                         
  574.     dest2v = vec_sra( dest2v, fivev );                            
  575.                                                                   
  576.     destv = vec_packsu( dest1v, dest2v );                         
  577.                                                                   
  578.     VEC_STORE16( destv, &dstv[x+i_stride*y], dsth );              
  579. }
  581. #define HPEL_FILTER_CENTRAL()                           
  582. {                                                       
  583.     temp1v = vec_sld( tempav, tempbv, 12 );             
  584.     temp2v = vec_sld( tempav, tempbv, 14 );             
  585.     temp3v = tempbv;                                    
  586.     temp4v = vec_sld( tempbv, tempcv,  2 );             
  587.     temp5v = vec_sld( tempbv, tempcv,  4 );             
  588.     temp6v = vec_sld( tempbv, tempcv,  6 );             
  589.                                                         
  590.     HPEL_FILTER_2( temp1v, temp2v, temp3v,              
  591.                    temp4v, temp5v, temp6v );            
  592.                                                         
  593.     dest1v = vec_add( temp1v, thirtytwov );             
  594.     dest1v = vec_sra( dest1v, sixv );                   
  595.                                                         
  596.     temp1v = vec_sld( tempbv, tempcv, 12 );             
  597.     temp2v = vec_sld( tempbv, tempcv, 14 );             
  598.     temp3v = tempcv;                                    
  599.     temp4v = vec_sld( tempcv, tempdv,  2 );             
  600.     temp5v = vec_sld( tempcv, tempdv,  4 );             
  601.     temp6v = vec_sld( tempcv, tempdv,  6 );             
  602.                                                         
  603.     HPEL_FILTER_2( temp1v, temp2v, temp3v,              
  604.                    temp4v, temp5v, temp6v );            
  605.                                                         
  606.     dest2v = vec_add( temp1v, thirtytwov );             
  607.     dest2v = vec_sra( dest2v, sixv );                   
  608.                                                         
  609.     destv = vec_packsu( dest1v, dest2v );               
  610.                                                         
  611.     VEC_STORE16( destv, &dstc[x-16+i_stride*y], dsth ); 
  612. }
  614. void x264_hpel_filter_altivec( uint8_t *dsth, uint8_t *dstv, uint8_t *dstc, uint8_t *src,
  615.                                int i_stride, int i_width, int i_height, int16_t *buf )
  616. {
  617.     int x, y;
  619.     vec_u8_t destv;
  620.     vec_u8_t src1v, src2v, src3v, src4v, src5v, src6v;
  621.     vec_s16_t dest1v, dest2v;
  622.     vec_s16_t temp1v, temp2v, temp3v, temp4v, temp5v, temp6v, temp7v, temp8v, temp9v;
  623.     vec_s16_t tempav, tempbv, tempcv, tempdv, tempev;
  625.     PREP_LOAD;
  626.     PREP_LOAD_SRC( src);
  627.     PREP_STORE16;
  628.     PREP_STORE16_DST( dsth );
  629.     LOAD_ZERO;
  631.     vec_u16_t twov, fourv, fivev, sixv;
  632.     vec_s16_t sixteenv, thirtytwov;
  633.     vec_u16_u temp_u;
  635.     temp_u.s[0]=2;
  636.     twov = vec_splat( temp_u.v, 0 );
  637.     temp_u.s[0]=4;
  638.     fourv = vec_splat( temp_u.v, 0 );
  639.     temp_u.s[0]=5;
  640.     fivev = vec_splat( temp_u.v, 0 );
  641.     temp_u.s[0]=6;
  642.     sixv = vec_splat( temp_u.v, 0 );
  643.     temp_u.s[0]=16;
  644.     sixteenv = (vec_s16_t)vec_splat( temp_u.v, 0 );
  645.     temp_u.s[0]=32;
  646.     thirtytwov = (vec_s16_t)vec_splat( temp_u.v, 0 );
  648.     for( y = 0; y < i_height; y++ )
  649.     {
  650.         x = 0;
  652.         /* horizontal_filter */
  653.         HPEL_FILTER_HORIZONTAL();
  655.         /* vertical_filter */
  656.         HPEL_FILTER_VERTICAL();
  658.         /* central_filter */
  659.         tempav = tempcv;
  660.         tempbv = tempdv;
  661.         tempcv = vec_splat( temp1v, 0 ); /* first only */
  662.         tempdv = temp1v;
  663.         tempev = temp4v;
  665.         for( x = 16; x < i_width; x+=16 )
  666.         {
  667.             /* horizontal_filter */
  668.             HPEL_FILTER_HORIZONTAL();
  670.             /* vertical_filter */
  671.             HPEL_FILTER_VERTICAL();
  673.             /* central_filter */
  674.             tempav = tempcv;
  675.             tempbv = tempdv;
  676.             tempcv = tempev;
  677.             tempdv = temp1v;
  678.             tempev = temp4v;
  680.             HPEL_FILTER_CENTRAL();
  681.         }
  683.         /* Partial vertical filter */
  684.         VEC_LOAD_PARTIAL( &src[x+i_stride*(y-2)], src1v, 16, vec_u8_t, src );
  685.         VEC_LOAD_PARTIAL( &src[x+i_stride*(y-1)], src2v, 16, vec_u8_t, src );
  686.         VEC_LOAD_PARTIAL( &src[x+i_stride*(y-0)], src3v, 16, vec_u8_t, src );
  687.         VEC_LOAD_PARTIAL( &src[x+i_stride*(y+1)], src4v, 16, vec_u8_t, src );
  688.         VEC_LOAD_PARTIAL( &src[x+i_stride*(y+2)], src5v, 16, vec_u8_t, src );
  689.         VEC_LOAD_PARTIAL( &src[x+i_stride*(y+3)], src6v, 16, vec_u8_t, src );
  691.         temp1v = vec_u8_to_s16_h( src1v );
  692.         temp2v = vec_u8_to_s16_h( src2v );
  693.         temp3v = vec_u8_to_s16_h( src3v );
  694.         temp4v = vec_u8_to_s16_h( src4v );
  695.         temp5v = vec_u8_to_s16_h( src5v );
  696.         temp6v = vec_u8_to_s16_h( src6v );
  698.         HPEL_FILTER_1( temp1v, temp2v, temp3v,
  699.                        temp4v, temp5v, temp6v );
  701.         /* central_filter */
  702.         tempav = tempcv;
  703.         tempbv = tempdv;
  704.         tempcv = tempev;
  705.         tempdv = temp1v;
  706.         /* tempev is not used */
  708.         HPEL_FILTER_CENTRAL();
  709.     }
  710. }
  712. static void frame_init_lowres_core_altivec( uint8_t *src0, uint8_t *dst0, uint8_t *dsth, uint8_t *dstv, uint8_t *dstc,
  713.                                            int src_stride, int dst_stride, int width, int height )
  714. {
  715.     int w = width/16;
  716.     int end = (width & 15);
  717.     int x, y;
  718.     vec_u8_t src0v, src1v, src2v;
  719.     vec_u8_t lv, hv, src1p1v;
  720.     vec_u8_t avg0v, avg1v, avghv, avghp1v, avgleftv, avgrightv;
  721.     static const vec_u8_t inverse_bridge_shuffle = CV(0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x1E );
  723.     for( y=0; y<height; y++ )
  724.     {
  725.         uint8_t *src1 = src0+src_stride;
  726.         uint8_t *src2 = src1+src_stride;
  728.         src0v = vec_ld(0, src0);
  729.         src1v = vec_ld(0, src1);
  730.         src2v = vec_ld(0, src2);
  732.         avg0v = vec_avg(src0v, src1v);
  733.         avg1v = vec_avg(src1v, src2v);
  735.         for( x=0; x<w; x++ )
  736.         {
  737.             lv = vec_ld(16*(x*2+1), src0);
  738.             src1v = vec_ld(16*(x*2+1), src1);
  739.             avghv = vec_avg(lv, src1v);
  741.             lv = vec_ld(16*(x*2+2), src0);
  742.             src1p1v = vec_ld(16*(x*2+2), src1);
  743.             avghp1v = vec_avg(lv, src1p1v);
  745.             avgleftv = vec_avg(vec_sld(avg0v, avghv, 1), avg0v);
  746.             avgrightv = vec_avg(vec_sld(avghv, avghp1v, 1), avghv);
  748.             vec_st(vec_perm(avgleftv, avgrightv, inverse_bridge_shuffle), 16*x, dst0);
  749.             vec_st((vec_u8_t)vec_pack((vec_u16_t)avgleftv,(vec_u16_t)avgrightv), 16*x, dsth);
  751.             avg0v = avghp1v;
  753.             hv = vec_ld(16*(x*2+1), src2);
  754.             avghv = vec_avg(src1v, hv);
  756.             hv = vec_ld(16*(x*2+2), src2);
  757.             avghp1v = vec_avg(src1p1v, hv);
  759.             avgleftv = vec_avg(vec_sld(avg1v, avghv, 1), avg1v);
  760.             avgrightv = vec_avg(vec_sld(avghv, avghp1v, 1), avghv);
  762.             vec_st(vec_perm(avgleftv, avgrightv, inverse_bridge_shuffle), 16*x, dstv);
  763.             vec_st((vec_u8_t)vec_pack((vec_u16_t)avgleftv,(vec_u16_t)avgrightv), 16*x, dstc);
  765.             avg1v = avghp1v;
  767.         }
  768.         if (end)
  769.         {
  770.             lv = vec_ld(16*(x*2+1), src0);
  771.             src1v = vec_ld(16*(x*2+1), src1);
  772.             avghv = vec_avg(lv, src1v);
  774.             lv = vec_ld(16*(x*2+1), src2);
  775.             avghp1v = vec_avg(src1v, lv);
  777.             avgleftv = vec_avg(vec_sld(avg0v, avghv, 1), avg0v);
  778.             avgrightv = vec_avg(vec_sld(avg1v, avghp1v, 1), avg1v);
  780.             lv = vec_perm(avgleftv, avgrightv, inverse_bridge_shuffle);
  781.             hv = (vec_u8_t)vec_pack((vec_u16_t)avgleftv,(vec_u16_t)avgrightv);
  783.             vec_ste((vec_u32_t)lv,16*x,(uint32_t*)dst0);
  784.             vec_ste((vec_u32_t)lv,16*x+4,(uint32_t*)dst0);
  785.             vec_ste((vec_u32_t)hv,16*x,(uint32_t*)dsth);
  786.             vec_ste((vec_u32_t)hv,16*x+4,(uint32_t*)dsth);
  788.             lv = vec_sld(lv, lv, 8);
  789.             hv = vec_sld(hv, hv, 8);
  791.             vec_ste((vec_u32_t)lv,16*x,(uint32_t*)dstv);
  792.             vec_ste((vec_u32_t)lv,16*x+4,(uint32_t*)dstv);
  793.             vec_ste((vec_u32_t)hv,16*x,(uint32_t*)dstc);
  794.             vec_ste((vec_u32_t)hv,16*x+4,(uint32_t*)dstc);
  795.         }
  797.         src0 += src_stride*2;
  798.         dst0 += dst_stride;
  799.         dsth += dst_stride;
  800.         dstv += dst_stride;
  801.         dstc += dst_stride;
  802.     }
  803. }
  805. void x264_mc_altivec_init( x264_mc_functions_t *pf )
  806. {
  807.     pf->mc_luma   = mc_luma_altivec;
  808.     pf->get_ref   = get_ref_altivec;
  809.     pf->mc_chroma = mc_chroma_altivec;
  811.     pf->copy_16x16_unaligned = x264_mc_copy_w16_altivec;
  812.     pf->copy[PIXEL_16x16] = x264_mc_copy_w16_aligned_altivec;
  814.     pf->hpel_filter = x264_hpel_filter_altivec;
  815.     pf->frame_init_lowres_core = frame_init_lowres_core_altivec;
  816. }