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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
mc.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：23k
源码类别：

Audio

开发平台：

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. #ifdef SYS_LINUX
  31. #include <altivec.h>
  32. #endif
  34. #include "x264.h"
  35. #include "common/common.h"
  36. #include "common/mc.h"
  37. #include "mc.h"
  38. #include "ppccommon.h"
  40. typedef void (*pf_mc_t)( uint8_t *src, int i_src,
  41.                          uint8_t *dst, int i_dst, int i_height );
  43. static inline int x264_tapfilter( uint8_t *pix, int i_pix_next )
  44. {
  45.     return pix[-2*i_pix_next] - 5*pix[-1*i_pix_next] + 20*(pix[0] +
  46.            pix[1*i_pix_next]) - 5*pix[ 2*i_pix_next] +
  47.            pix[ 3*i_pix_next];
  48. }
  49. static inline int x264_tapfilter1( uint8_t *pix )
  50. {
  51.     return pix[-2] - 5*pix[-1] + 20*(pix[0] + pix[1]) - 5*pix[ 2] +
  52.            pix[ 3];
  53. }
  55. /* pixel_avg */
  56. static inline void pixel_avg_w4( uint8_t *dst,  int i_dst,
  57.                                  uint8_t *src1, int i_src1,
  58.                                  uint8_t *src2, int i_src2,
  59.                                  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_src2;
  71.     }
  72. }
  73. static inline void pixel_avg_w8( uint8_t *dst,  int i_dst,
  74.                                  uint8_t *src1, int i_src1,
  75.                                  uint8_t *src2, int i_src2,
  76.                                  int i_height )
  77. {
  78.     int y;
  79.     vec_u8_t src1v, src2v;
  80.     LOAD_ZERO;
  81.     PREP_LOAD;
  82.     PREP_STORE8;
  83.     for( y = 0; y < i_height; y++ )
  84.     {
  85.         VEC_LOAD( src1, src1v, 8, vec_u8_t );
  86.         VEC_LOAD( src2, src2v, 8, vec_u8_t );
  87.         src1v = vec_avg( src1v, src2v );
  88.         VEC_STORE8( src1v, dst );
  90.         dst  += i_dst;
  91.         src1 += i_src1;
  92.         src2 += i_src2;
  93.     }
  94. }
  95. static inline void pixel_avg_w16( uint8_t *dst,  int i_dst,
  96.                                   uint8_t *src1, int i_src1,
  97.                                   uint8_t *src2, int i_src2,
  98.                                   int i_height )
  99. {
  100.     int y;
  101.     vec_u8_t src1v, src2v;
  102.     PREP_LOAD;
  103.     PREP_STORE16;
  104.     for( y = 0; y < i_height; y++ )
  105.     {
  106.         VEC_LOAD( src1, src1v, 16, vec_u8_t );
  107.         VEC_LOAD( src2, src2v, 16, vec_u8_t );
  108.         src1v = vec_avg( src1v, src2v );
  109.         VEC_STORE16( src1v, dst );
  111.         dst  += i_dst;
  112.         src1 += i_src1;
  113.         src2 += i_src2;
  114.     }
  115. }
  117. /* mc_copy: plain c */
  118. #define MC_COPY( name, a )                                
  119. static void name( uint8_t *src, int i_src,                
  120.                   uint8_t *dst, int i_dst, int i_height ) 
  121. {                                                         
  122.     int y;                                                
  123.     for( y = 0; y < i_height; y++ )                       
  124.     {                                                     
  125.         memcpy( dst, src, a );                            
  126.         src += i_src;                                     
  127.         dst += i_dst;                                     
  128.     }                                                     
  129. }
  130. MC_COPY( mc_copy_w4,  4  )
  131. MC_COPY( mc_copy_w8,  8  )
  132. MC_COPY( mc_copy_w16, 16 )
  134. void mc_luma_altivec( uint8_t *dst,    int i_dst_stride,
  135.                       uint8_t *src[4], int i_src_stride,
  136.                       int mvx, int mvy,
  137.                       int i_width, int i_height )
  138. {
  139.     uint8_t *src1, *src2;
  140.     
  141.     /* todo : fixme... */
  142.     int correction = (((mvx&3) == 3 && (mvy&3) == 1) || ((mvx&3) == 1 && (mvy&3) == 3)) ? 1:0;
  143.     
  144.     int hpel1x = mvx>>1;
  145.     int hpel1y = (mvy+1-correction)>>1;
  146.     int filter1 = (hpel1x & 1) + ( (hpel1y & 1) << 1 );
  147.     
  148.     
  149.     src1 = src[filter1] + (hpel1y >> 1) * i_src_stride + (hpel1x >> 1);
  150.     
  151.     if ( (mvx|mvy) & 1 ) /* qpel interpolation needed */
  152.     {
  153.         int hpel2x = (mvx+1)>>1;
  154.         int hpel2y = (mvy+correction)>>1;
  155.         int filter2 = (hpel2x & 1) + ( (hpel2y & 1) <<1 );
  156.         
  157.         src2 = src[filter2] + (hpel2y >> 1) * i_src_stride + (hpel2x >> 1);
  158.         
  159.         switch(i_width) {
  160.         case 4:
  161.             pixel_avg_w4( dst, i_dst_stride, src1, i_src_stride,
  162.                           src2, i_src_stride, i_height );
  163.             break;
  164.         case 8:
  165.             pixel_avg_w8( dst, i_dst_stride, src1, i_src_stride,
  166.                           src2, i_src_stride, i_height );
  167.             break;
  168.         case 16:
  169.         default:
  170.             pixel_avg_w16( dst, i_dst_stride, src1, i_src_stride,
  171.                            src2, i_src_stride, i_height );
  172.         }
  173.         
  174.     }
  175.     else
  176.     {
  177.         switch(i_width) {
  178.         case 4:
  179.             mc_copy_w4( src1, i_src_stride, dst, i_dst_stride, i_height );
  180.             break;
  181.         case 8:
  182.             mc_copy_w8( src1, i_src_stride, dst, i_dst_stride, i_height );
  183.             break;
  184.         case 16:
  185.             mc_copy_w16( src1, i_src_stride, dst, i_dst_stride, i_height );
  186.             break;
  187.         }
  188.         
  189.     }
  190. }
  192. uint8_t *get_ref_altivec( uint8_t *dst,    int * i_dst_stride,
  193.                           uint8_t *src[4], int i_src_stride,
  194.                           int mvx, int mvy,
  195.                           int i_width, int i_height )
  196. {
  197.     uint8_t *src1, *src2;
  198.     
  199.     /* todo : fixme... */
  200.     int correction = (((mvx&3) == 3 && (mvy&3) == 1) || ((mvx&3) == 1 && (mvy&3) == 3)) ? 1:0;
  201.     
  202.     int hpel1x = mvx>>1;
  203.     int hpel1y = (mvy+1-correction)>>1;
  204.     int filter1 = (hpel1x & 1) + ( (hpel1y & 1) << 1 );
  205.     
  206.     
  207.     src1 = src[filter1] + (hpel1y >> 1) * i_src_stride + (hpel1x >> 1);
  208.     
  209.     if ( (mvx|mvy) & 1 ) /* qpel interpolation needed */
  210.     {
  211.         int hpel2x = (mvx+1)>>1;
  212.         int hpel2y = (mvy+correction)>>1;
  213.         int filter2 = (hpel2x & 1) + ( (hpel2y & 1) <<1 );
  214.         
  215.         src2 = src[filter2] + (hpel2y >> 1) * i_src_stride + (hpel2x >> 1);
  216.         
  217.         switch(i_width) {
  218.         case 4:
  219.             pixel_avg_w4( dst, *i_dst_stride, src1, i_src_stride,
  220.                           src2, i_src_stride, i_height );
  221.             break;
  222.         case 8:
  223.             pixel_avg_w8( dst, *i_dst_stride, src1, i_src_stride,
  224.                           src2, i_src_stride, i_height );
  225.             break;
  226.         case 12:
  227.         case 16:
  228.         default:
  229.             pixel_avg_w16( dst, *i_dst_stride, src1, i_src_stride,
  230.                           src2, i_src_stride, i_height );
  231.             break;
  232.         case 20:
  233.             //FIXME suboptimal
  234.             pixel_avg_w16( dst, *i_dst_stride, src1, i_src_stride,
  235.                           src2, i_src_stride, i_height );
  236.             pixel_avg_w4( dst+16, *i_dst_stride, src1+16, i_src_stride,
  237.                           src2+16, i_src_stride, i_height );
  238.             break;
  239.         }
  240.         return dst;
  242.     }
  243.     else
  244.     {
  245.         *i_dst_stride = i_src_stride;
  246.         return src1;
  247.     }
  248. }
  250. #define DO_PROCESS(a) 
  251.         src##a##v_16 = vec_u8_to_u16( src##a##v_8 ); 
  252.         src##a##v_16 = vec_mladd( coeff##a##v, src##a##v_16, zero_u16v ); 
  253.         dstv_16      = vec_add( dstv_16, src##a##v_16 )
  255. static void mc_chroma_altivec_4xh( uint8_t *dst, int i_dst_stride,
  256.                                    uint8_t *src, int i_src_stride,
  257.                                    int mvx, int mvy,
  258.                                    int i_height )
  259. {
  260.     uint8_t *srcp;
  261.     int y;
  262.     int d8x = mvx & 0x07;
  263.     int d8y = mvy & 0x07;
  265.     DECLARE_ALIGNED_16( uint16_t coeff[4] );
  266.     coeff[0] = (8-d8x)*(8-d8y);
  267.     coeff[1] = d8x    *(8-d8y);
  268.     coeff[2] = (8-d8x)*d8y;
  269.     coeff[3] = d8x    *d8y;
  271.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  272.     srcp  = &src[i_src_stride];
  273.     
  274.     LOAD_ZERO;
  275.     PREP_LOAD;
  276.     PREP_STORE4;
  277.     vec_u16_t   coeff0v, coeff1v, coeff2v, coeff3v;
  278.     vec_u8_t    src0v_8, src1v_8, src2v_8, src3v_8;
  279.     vec_u16_t   src0v_16, src1v_16, src2v_16, src3v_16;
  280.     vec_u8_t    dstv_8;
  281.     vec_u16_t   dstv_16;
  282.     vec_u8_t    permv;
  283.     vec_u16_t   shiftv;
  284.     vec_u16_t   k32v;
  285.     
  286.     coeff0v = vec_ld( 0, coeff );
  287.     coeff3v = vec_splat( coeff0v, 3 );
  288.     coeff2v = vec_splat( coeff0v, 2 );
  289.     coeff1v = vec_splat( coeff0v, 1 );
  290.     coeff0v = vec_splat( coeff0v, 0 );
  291.     k32v    = vec_sl( vec_splat_u16( 1 ), vec_splat_u16( 5 ) );
  292.     permv   = vec_lvsl( 0, (uint8_t *) 1 );
  293.     shiftv  = vec_splat_u16( 6 );
  295.     VEC_LOAD( src, src2v_8, 5, vec_u8_t );
  296.     src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  298.     for( y = 0; y < i_height; y++ )
  299.     {
  300.         src0v_8 = src2v_8;
  301.         src1v_8 = src3v_8;
  302.         VEC_LOAD( srcp, src2v_8, 5, vec_u8_t );
  303.         src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  305.         dstv_16 = k32v;
  307.         DO_PROCESS( 0 );
  308.         DO_PROCESS( 1 );
  309.         DO_PROCESS( 2 );
  310.         DO_PROCESS( 3 );
  312.         dstv_16 = vec_sr( dstv_16, shiftv );
  313.         dstv_8  = vec_u16_to_u8( dstv_16 );
  314.         VEC_STORE4( dstv_8, dst );
  316.         dst  += i_dst_stride;
  317.         srcp += i_src_stride;
  318.     }
  319. }
  321. static void mc_chroma_altivec_8xh( uint8_t *dst, int i_dst_stride,
  322.                                    uint8_t *src, int i_src_stride,
  323.                                    int mvx, int mvy,
  324.                                    int i_height )
  325. {
  326.     uint8_t *srcp;
  327.     int y;
  328.     int d8x = mvx & 0x07;
  329.     int d8y = mvy & 0x07;
  331.     DECLARE_ALIGNED_16( uint16_t coeff[4] );
  332.     coeff[0] = (8-d8x)*(8-d8y);
  333.     coeff[1] = d8x    *(8-d8y);
  334.     coeff[2] = (8-d8x)*d8y;
  335.     coeff[3] = d8x    *d8y;
  337.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  338.     srcp  = &src[i_src_stride];
  339.     
  340.     LOAD_ZERO;
  341.     PREP_LOAD;
  342.     PREP_STORE8;
  343.     vec_u16_t   coeff0v, coeff1v, coeff2v, coeff3v;
  344.     vec_u8_t    src0v_8, src1v_8, src2v_8, src3v_8;
  345.     vec_u16_t   src0v_16, src1v_16, src2v_16, src3v_16;
  346.     vec_u8_t    dstv_8;
  347.     vec_u16_t   dstv_16;
  348.     vec_u8_t    permv;
  349.     vec_u16_t   shiftv;
  350.     vec_u16_t   k32v;
  351.     
  352.     coeff0v = vec_ld( 0, coeff );
  353.     coeff3v = vec_splat( coeff0v, 3 );
  354.     coeff2v = vec_splat( coeff0v, 2 );
  355.     coeff1v = vec_splat( coeff0v, 1 );
  356.     coeff0v = vec_splat( coeff0v, 0 );
  357.     k32v    = vec_sl( vec_splat_u16( 1 ), vec_splat_u16( 5 ) );
  358.     permv   = vec_lvsl( 0, (uint8_t *) 1 );
  359.     shiftv  = vec_splat_u16( 6 );
  361.     VEC_LOAD( src, src2v_8, 9, vec_u8_t );
  362.     src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  364.     for( y = 0; y < i_height; y++ )
  365.     {
  366.         src0v_8 = src2v_8;
  367.         src1v_8 = src3v_8;
  368.         VEC_LOAD( srcp, src2v_8, 9, vec_u8_t );
  369.         src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  371.         dstv_16 = k32v;
  373.         DO_PROCESS( 0 );
  374.         DO_PROCESS( 1 );
  375.         DO_PROCESS( 2 );
  376.         DO_PROCESS( 3 );
  378.         dstv_16 = vec_sr( dstv_16, shiftv );
  379.         dstv_8  = vec_u16_to_u8( dstv_16 );
  380.         VEC_STORE8( dstv_8, dst );
  382.         dst  += i_dst_stride;
  383.         srcp += i_src_stride;
  384.     }
  385. }
  387. static void mc_chroma_altivec( uint8_t *dst, int i_dst_stride,
  388.                                uint8_t *src, int i_src_stride,
  389.                                int mvx, int mvy,
  390.                                int i_width, int i_height )
  391. {
  392.     if( i_width == 8 )
  393.     {
  394.         mc_chroma_altivec_8xh( dst, i_dst_stride, src, i_src_stride,
  395.                                mvx, mvy, i_height );
  396.     }
  397.     else
  398.     {
  399.         mc_chroma_altivec_4xh( dst, i_dst_stride, src, i_src_stride,
  400.                                mvx, mvy, i_height );
  401.     }
  402. }
  404. #define HPEL_FILTER_1( t1v, t2v, t3v, t4v, t5v, t6v ) 
  405. {                                                     
  406.     t1v = vec_add( t1v, t6v );                        
  407.     t2v = vec_add( t2v, t5v );                        
  408.     t3v = vec_add( t3v, t4v );                        
  409.                                                       
  410.     t1v = vec_sub( t1v, t2v );   /* (a-b) */          
  411.     t2v = vec_sub( t2v, t3v );   /* (b-c) */          
  412.     t2v = vec_sl(  t2v, twov );  /* (b-c)*4 */        
  413.     t1v = vec_sub( t1v, t2v );   /* a-5*b+4*c */      
  414.     t3v = vec_sl(  t3v, fourv ); /* 16*c */           
  415.     t1v = vec_add( t1v, t3v );   /* a-5*b+20*c */     
  416. }
  418. #define HPEL_FILTER_2( t1v, t2v, t3v, t4v, t5v, t6v ) 
  419. {                                                     
  420.     t1v = vec_add( t1v, t6v );                        
  421.     t2v = vec_add( t2v, t5v );                        
  422.     t3v = vec_add( t3v, t4v );                        
  423.                                                       
  424.     t1v = vec_sub( t1v, t2v );  /* (a-b) */           
  425.     t1v = vec_sra( t1v, twov ); /* (a-b)/4 */         
  426.     t1v = vec_sub( t1v, t2v );  /* (a-b)/4-b */       
  427.     t1v = vec_add( t1v, t3v );  /* (a-b)/4-b+c */     
  428.     t1v = vec_sra( t1v, twov ); /* ((a-b)/4-b+c)/4 */ 
  429.     t1v = vec_add( t1v, t3v );  /* ((a-b)/4-b+c)/4+c = (a-5*b+20*c)/16 */ 
  430. }
  432. #define HPEL_FILTER_HORIZONTAL()                            
  433. {                                                           
  434.     VEC_LOAD( &src[x- 2+i_stride*y], src1v, 16, vec_u8_t ); 
  435.     VEC_LOAD( &src[x+14+i_stride*y], src6v, 16, vec_u8_t ); 
  436.                                                             
  437.     src2v = vec_sld( src1v, src6v,  1 );                    
  438.     src3v = vec_sld( src1v, src6v,  2 );                    
  439.     src4v = vec_sld( src1v, src6v,  3 );                    
  440.     src5v = vec_sld( src1v, src6v,  4 );                    
  441.     src6v = vec_sld( src1v, src6v,  5 );                    
  442.                                                             
  443.     temp1v = vec_u8_to_s16_h( src1v );                      
  444.     temp2v = vec_u8_to_s16_h( src2v );                      
  445.     temp3v = vec_u8_to_s16_h( src3v );                      
  446.     temp4v = vec_u8_to_s16_h( src4v );                      
  447.     temp5v = vec_u8_to_s16_h( src5v );                      
  448.     temp6v = vec_u8_to_s16_h( src6v );                      
  449.                                                             
  450.     HPEL_FILTER_1( temp1v, temp2v, temp3v,                  
  451.                    temp4v, temp5v, temp6v );                
  452.                                                             
  453.     dest1v = vec_add( temp1v, sixteenv );                   
  454.     dest1v = vec_sra( dest1v, fivev );                      
  455.                                                             
  456.     temp1v = vec_u8_to_s16_l( src1v );                      
  457.     temp2v = vec_u8_to_s16_l( src2v );                      
  458.     temp3v = vec_u8_to_s16_l( src3v );                      
  459.     temp4v = vec_u8_to_s16_l( src4v );                      
  460.     temp5v = vec_u8_to_s16_l( src5v );                      
  461.     temp6v = vec_u8_to_s16_l( src6v );                      
  462.                                                             
  463.     HPEL_FILTER_1( temp1v, temp2v, temp3v,                  
  464.                    temp4v, temp5v, temp6v );                
  465.                                                             
  466.     dest2v = vec_add( temp1v, sixteenv );                   
  467.     dest2v = vec_sra( dest2v, fivev );                      
  468.                                                             
  469.     destv = vec_packsu( dest1v, dest2v );                   
  470.                                                             
  471.     VEC_STORE16( destv, &dsth[x+i_stride*y] );              
  472. }
  474. #define HPEL_FILTER_VERTICAL()                               
  475. {                                                            
  476.     VEC_LOAD( &src[x+i_stride*(y-2)], src1v, 16, vec_u8_t ); 
  477.     VEC_LOAD( &src[x+i_stride*(y-1)], src2v, 16, vec_u8_t ); 
  478.     VEC_LOAD( &src[x+i_stride*(y-0)], src3v, 16, vec_u8_t ); 
  479.     VEC_LOAD( &src[x+i_stride*(y+1)], src4v, 16, vec_u8_t ); 
  480.     VEC_LOAD( &src[x+i_stride*(y+2)], src5v, 16, vec_u8_t ); 
  481.     VEC_LOAD( &src[x+i_stride*(y+3)], src6v, 16, vec_u8_t ); 
  482.                                                              
  483.     temp1v = vec_u8_to_s16_h( src1v );                       
  484.     temp2v = vec_u8_to_s16_h( src2v );                       
  485.     temp3v = vec_u8_to_s16_h( src3v );                       
  486.     temp4v = vec_u8_to_s16_h( src4v );                       
  487.     temp5v = vec_u8_to_s16_h( src5v );                       
  488.     temp6v = vec_u8_to_s16_h( src6v );                       
  489.                                                              
  490.     HPEL_FILTER_1( temp1v, temp2v, temp3v,                   
  491.                    temp4v, temp5v, temp6v );                 
  492.                                                              
  493.     dest1v = vec_add( temp1v, sixteenv );                    
  494.     dest1v = vec_sra( dest1v, fivev );                       
  495.                                                              
  496.     temp4v = vec_u8_to_s16_l( src1v );                       
  497.     temp5v = vec_u8_to_s16_l( src2v );                       
  498.     temp6v = vec_u8_to_s16_l( src3v );                       
  499.     temp7v = vec_u8_to_s16_l( src4v );                       
  500.     temp8v = vec_u8_to_s16_l( src5v );                       
  501.     temp9v = vec_u8_to_s16_l( src6v );                       
  502.                                                              
  503.     HPEL_FILTER_1( temp4v, temp5v, temp6v,                   
  504.                    temp7v, temp8v, temp9v );                 
  505.                                                              
  506.     dest2v = vec_add( temp4v, sixteenv );                    
  507.     dest2v = vec_sra( dest2v, fivev );                       
  508.                                                              
  509.     destv = vec_packsu( dest1v, dest2v );                    
  510.                                                              
  511.     VEC_STORE16( destv, &dstv[x+i_stride*y] );               
  512. }
  514. #define HPEL_FILTER_CENTRAL()                     
  515. {                                                 
  516.     temp1v = vec_sld( tempav, tempbv, 12 );       
  517.     temp2v = vec_sld( tempav, tempbv, 14 );       
  518.     temp3v = tempbv;                              
  519.     temp4v = vec_sld( tempbv, tempcv,  2 );       
  520.     temp5v = vec_sld( tempbv, tempcv,  4 );       
  521.     temp6v = vec_sld( tempbv, tempcv,  6 );       
  522.                                                   
  523.     HPEL_FILTER_2( temp1v, temp2v, temp3v,        
  524.                    temp4v, temp5v, temp6v );      
  525.                                                   
  526.     dest1v = vec_add( temp1v, thirtytwov );       
  527.     dest1v = vec_sra( dest1v, sixv );             
  528.                                                   
  529.     temp1v = vec_sld( tempbv, tempcv, 12 );       
  530.     temp2v = vec_sld( tempbv, tempcv, 14 );       
  531.     temp3v = tempcv;                              
  532.     temp4v = vec_sld( tempcv, tempdv,  2 );       
  533.     temp5v = vec_sld( tempcv, tempdv,  4 );       
  534.     temp6v = vec_sld( tempcv, tempdv,  6 );       
  535.                                                   
  536.     HPEL_FILTER_2( temp1v, temp2v, temp3v,        
  537.                    temp4v, temp5v, temp6v );      
  538.                                                   
  539.     dest2v = vec_add( temp1v, thirtytwov );       
  540.     dest2v = vec_sra( dest2v, sixv );             
  541.                                                   
  542.     destv = vec_packsu( dest1v, dest2v );         
  543.                                                   
  544.     VEC_STORE16( destv, &dstc[x-16+i_stride*y] ); 
  545. }
  547. void x264_hpel_filter_altivec( uint8_t *dsth, uint8_t *dstv, uint8_t *dstc, uint8_t *src,
  548.                                int i_stride, int i_width, int i_height )
  549. {
  550.     int x, y;
  552.     vec_u8_t destv;
  553.     vec_u8_t src1v, src2v, src3v, src4v, src5v, src6v;
  554.     vec_s16_t dest1v, dest2v;
  555.     vec_s16_t temp1v, temp2v, temp3v, temp4v, temp5v, temp6v, temp7v, temp8v, temp9v;
  556.     vec_s16_t tempav, tempbv, tempcv, tempdv, tempev;
  558.     PREP_LOAD;
  559.     PREP_STORE16;
  560.     LOAD_ZERO;
  562.     vec_u16_t twov, fourv, fivev, sixv;
  563.     vec_s16_t sixteenv, thirtytwov;
  564.     vect_ushort_u temp_u;
  566.     temp_u.s[0]=2;
  567.     twov = vec_splat( temp_u.v, 0 );
  568.     temp_u.s[0]=4;
  569.     fourv = vec_splat( temp_u.v, 0 );
  570.     temp_u.s[0]=5;
  571.     fivev = vec_splat( temp_u.v, 0 );
  572.     temp_u.s[0]=6;
  573.     sixv = vec_splat( temp_u.v, 0 );
  574.     temp_u.s[0]=16;
  575.     sixteenv = (vec_s16_t)vec_splat( temp_u.v, 0 );
  576.     temp_u.s[0]=32;
  577.     thirtytwov = (vec_s16_t)vec_splat( temp_u.v, 0 );
  579.     for( y = 0; y < i_height; y++ )
  580.     {
  581.         x = 0;
  583.         /* horizontal_filter */
  584.         HPEL_FILTER_HORIZONTAL();
  586.         /* vertical_filter */
  587.         HPEL_FILTER_VERTICAL();
  589.         /* central_filter */
  590.         tempav = tempcv;
  591.         tempbv = tempdv;
  592.         tempcv = vec_splat( temp1v, 0 ); /* first only */
  593.         tempdv = temp1v;
  594.         tempev = temp4v;
  596.         for( x = 16; x < i_width; x+=16 )
  597.         {
  598.             /* horizontal_filter */
  599.             HPEL_FILTER_HORIZONTAL();
  601.             /* vertical_filter */
  602.             HPEL_FILTER_VERTICAL();
  604.             /* central_filter */
  605.             tempav = tempcv;
  606.             tempbv = tempdv;
  607.             tempcv = tempev;
  608.             tempdv = temp1v;
  609.             tempev = temp4v;
  611.             HPEL_FILTER_CENTRAL();
  612.         }
  614.         /* Partial vertical filter */
  615.         VEC_LOAD( &src[x+i_stride*(y-2)], src1v, 16, vec_u8_t );
  616.         VEC_LOAD( &src[x+i_stride*(y-1)], src2v, 16, vec_u8_t );
  617.         VEC_LOAD( &src[x+i_stride*(y-0)], src3v, 16, vec_u8_t );
  618.         VEC_LOAD( &src[x+i_stride*(y+1)], src4v, 16, vec_u8_t );
  619.         VEC_LOAD( &src[x+i_stride*(y+2)], src5v, 16, vec_u8_t );
  620.         VEC_LOAD( &src[x+i_stride*(y+3)], src6v, 16, vec_u8_t );
  622.         temp1v = vec_u8_to_s16_h( src1v );
  623.         temp2v = vec_u8_to_s16_h( src2v );
  624.         temp3v = vec_u8_to_s16_h( src3v );
  625.         temp4v = vec_u8_to_s16_h( src4v );
  626.         temp5v = vec_u8_to_s16_h( src5v );
  627.         temp6v = vec_u8_to_s16_h( src6v );
  629.         HPEL_FILTER_1( temp1v, temp2v, temp3v,
  630.                       temp4v, temp5v, temp6v );
  632.         /* central_filter */
  633.         tempav = tempcv;
  634.         tempbv = tempdv;
  635.         tempcv = tempev;
  636.         tempdv = temp1v;
  637.         /* tempev is not used */
  639.         HPEL_FILTER_CENTRAL();
  640.     }
  641. }
  643. void x264_mc_altivec_init( x264_mc_functions_t *pf )
  644. {
  645.     pf->mc_luma   = mc_luma_altivec;
  646.     pf->get_ref   = get_ref_altivec;
  647.     pf->mc_chroma = mc_chroma_altivec;
  649.     pf->hpel_filter = x264_hpel_filter_altivec;
  650. }