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

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

Audio

开发平台：

Visual C++

mc.c：源码内容
  1. /*****************************************************************************
  2.  * mc.c: h264 encoder library (Motion Compensation)
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 Laurent Aimar
  5.  * $Id: mc.c,v 1.1 2004/06/03 19:27:07 fenrir Exp $
  6.  *
  7.  * Authors: Eric Petit <titer@m0k.org>
  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., 59 Temple Place - Suite 330, 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/mc.h"
  36. #include "common/clip1.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.     /* TODO - optimize */
  79.     pixel_avg_w4( &dst[0], i_dst, &src1[0], i_src1, &src2[0], i_src2,
  80.                   i_height );
  81.     pixel_avg_w4( &dst[4], i_dst, &src1[4], i_src1, &src2[4], i_src2,
  82.                   i_height );
  83. }
  84. static inline void pixel_avg_w16( uint8_t *dst,  int i_dst,
  85.                                   uint8_t *src1, int i_src1,
  86.                                   uint8_t *src2, int i_src2,
  87.                                   int i_height )
  88. {
  89.     int y;
  90.     vec_u8_t src1v, src2v;
  91.     PREP_LOAD;
  92.     PREP_STORE16;
  93.     for( y = 0; y < i_height; y++ )
  94.     {
  95.         VEC_LOAD( src1, src1v, 16, vec_u8_t );
  96.         VEC_LOAD( src2, src2v, 16, vec_u8_t );
  97.         src1v = vec_avg( src1v, src2v );
  98.         VEC_STORE16( src1v, dst );
  100.         dst  += i_dst;
  101.         src1 += i_src1;
  102.         src2 += i_src2;
  103.     }
  104. }
  106. /* mc_copy: plain c */
  107. #define MC_COPY( name, a )                                
  108. static void name( uint8_t *src, int i_src,                
  109.                   uint8_t *dst, int i_dst, int i_height ) 
  110. {                                                         
  111.     int y;                                                
  112.     for( y = 0; y < i_height; y++ )                       
  113.     {                                                     
  114.         memcpy( dst, src, a );                            
  115.         src += i_src;                                     
  116.         dst += i_dst;                                     
  117.     }                                                     
  118. }
  119. MC_COPY( mc_copy_w4,  4  )
  120. MC_COPY( mc_copy_w8,  8  )
  121. MC_COPY( mc_copy_w16, 16 )
  123. void mc_luma_altivec( uint8_t *src[4], int i_src_stride,
  124.                       uint8_t *dst,    int i_dst_stride,
  125.                       int mvx, int mvy,
  126.                       int i_width, int i_height )
  127. {
  128.     uint8_t *src1, *src2;
  129.     
  130.     /* todo : fixme... */
  131.     int correction = (((mvx&3) == 3 && (mvy&3) == 1) || ((mvx&3) == 1 && (mvy&3) == 3)) ? 1:0;
  132.     
  133.     int hpel1x = mvx>>1;
  134.     int hpel1y = (mvy+1-correction)>>1;
  135.     int filter1 = (hpel1x & 1) + ( (hpel1y & 1) << 1 );
  136.     
  137.     
  138.     src1 = src[filter1] + (hpel1y >> 1) * i_src_stride + (hpel1x >> 1);
  139.     
  140.     if ( (mvx|mvy) & 1 ) /* qpel interpolation needed */
  141.     {
  142.         int hpel2x = (mvx+1)>>1;
  143.         int hpel2y = (mvy+correction)>>1;
  144.         int filter2 = (hpel2x & 1) + ( (hpel2y & 1) <<1 );
  145.         
  146.         src2 = src[filter2] + (hpel2y >> 1) * i_src_stride + (hpel2x >> 1);
  147.         
  148.         switch(i_width) {
  149.         case 4:
  150.             pixel_avg_w4( dst, i_dst_stride, src1, i_src_stride,
  151.                           src2, i_src_stride, i_height );
  152.             break;
  153.         case 8:
  154.             pixel_avg_w8( dst, i_dst_stride, src1, i_src_stride,
  155.                           src2, i_src_stride, i_height );
  156.             break;
  157.         case 16:
  158.         default:
  159.             pixel_avg_w16( dst, i_dst_stride, src1, i_src_stride,
  160.                            src2, i_src_stride, i_height );
  161.         }
  162.         
  163.     }
  164.     else
  165.     {
  166.         switch(i_width) {
  167.         case 4:
  168.             mc_copy_w4( src1, i_src_stride, dst, i_dst_stride, i_height );
  169.             break;
  170.         case 8:
  171.             mc_copy_w8( src1, i_src_stride, dst, i_dst_stride, i_height );
  172.             break;
  173.         case 16:
  174.             mc_copy_w16( src1, i_src_stride, dst, i_dst_stride, i_height );
  175.             break;
  176.         }
  177.         
  178.     }
  179. }
  181. uint8_t *get_ref_altivec( uint8_t *src[4], int i_src_stride,
  182.                           uint8_t *dst,    int * i_dst_stride,
  183.                           int mvx, int mvy,
  184.                           int i_width, int i_height )
  185. {
  186.     uint8_t *src1, *src2;
  187.     
  188.     /* todo : fixme... */
  189.     int correction = (((mvx&3) == 3 && (mvy&3) == 1) || ((mvx&3) == 1 && (mvy&3) == 3)) ? 1:0;
  190.     
  191.     int hpel1x = mvx>>1;
  192.     int hpel1y = (mvy+1-correction)>>1;
  193.     int filter1 = (hpel1x & 1) + ( (hpel1y & 1) << 1 );
  194.     
  195.     
  196.     src1 = src[filter1] + (hpel1y >> 1) * i_src_stride + (hpel1x >> 1);
  197.     
  198.     if ( (mvx|mvy) & 1 ) /* qpel interpolation needed */
  199.     {
  200.         int hpel2x = (mvx+1)>>1;
  201.         int hpel2y = (mvy+correction)>>1;
  202.         int filter2 = (hpel2x & 1) + ( (hpel2y & 1) <<1 );
  203.         
  204.         src2 = src[filter2] + (hpel2y >> 1) * i_src_stride + (hpel2x >> 1);
  205.         
  206.         switch(i_width) {
  207.         case 4:
  208.             pixel_avg_w4( dst, *i_dst_stride, src1, i_src_stride,
  209.                           src2, i_src_stride, i_height );
  210.             break;
  211.         case 8:
  212.             pixel_avg_w8( dst, *i_dst_stride, src1, i_src_stride,
  213.                           src2, i_src_stride, i_height );
  214.             break;
  215.         case 16:
  216.         default:
  217.             pixel_avg_w16( dst, *i_dst_stride, src1, i_src_stride,
  218.                           src2, i_src_stride, i_height );
  219.         }
  220.         return dst;
  222.     }
  223.     else
  224.     {
  225.         *i_dst_stride = i_src_stride;
  226.         return src1;
  227.     }
  228. }
  230. static void mc_chroma_c( uint8_t *src, int i_src_stride,
  231.                          uint8_t *dst, int i_dst_stride,
  232.                          int mvx, int mvy,
  233.                          int i_width, int i_height )
  234. {
  235.     uint8_t *srcp;
  236.     int x, y;
  237.     int d8x = mvx & 0x07;
  238.     int d8y = mvy & 0x07;
  240.     DECLARE_ALIGNED( uint16_t, coeff[4], 16 );
  241.     coeff[0] = (8-d8x)*(8-d8y);
  242.     coeff[1] = d8x    *(8-d8y);
  243.     coeff[2] = (8-d8x)*d8y;
  244.     coeff[3] = d8x    *d8y;
  246.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  247.     srcp  = &src[i_src_stride];
  249.     /* TODO: optimize */
  250.     for( y = 0; y < i_height; y++ )
  251.     {
  252.         for( x = 0; x < i_width; x++ )
  253.         {
  254.             dst[x] = ( coeff[0]*src[x]  + coeff[1]*src[x+1] +
  255.                        coeff[2]*srcp[x] + coeff[3]*srcp[x+1] + 32 ) >> 6;
  256.         }
  257.         dst  += i_dst_stride;
  259.         src   = srcp;
  260.         srcp += i_src_stride;
  261.     }
  262. }
  264. #define DO_PROCESS(a) 
  265.         src##a##v_16 = vec_u8_to_u16( src##a##v_8 ); 
  266.         src##a##v_16 = vec_mladd( coeff##a##v, src##a##v_16, zero_u16v ); 
  267.         dstv_16      = vec_add( dstv_16, src##a##v_16 )
  269. static void mc_chroma_altivec_4xh( uint8_t *src, int i_src_stride,
  270.                                    uint8_t *dst, int i_dst_stride,
  271.                                    int mvx, int mvy,
  272.                                    int i_height )
  273. {
  274.     uint8_t *srcp;
  275.     int y;
  276.     int d8x = mvx & 0x07;
  277.     int d8y = mvy & 0x07;
  279.     DECLARE_ALIGNED( uint16_t, coeff[4], 16 );
  280.     coeff[0] = (8-d8x)*(8-d8y);
  281.     coeff[1] = d8x    *(8-d8y);
  282.     coeff[2] = (8-d8x)*d8y;
  283.     coeff[3] = d8x    *d8y;
  285.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  286.     srcp  = &src[i_src_stride];
  287.     
  288.     LOAD_ZERO;
  289.     PREP_LOAD;
  290.     PREP_STORE4;
  291.     vec_u16_t   coeff0v, coeff1v, coeff2v, coeff3v;
  292.     vec_u8_t    src0v_8, src1v_8, src2v_8, src3v_8;
  293.     vec_u16_t   src0v_16, src1v_16, src2v_16, src3v_16;
  294.     vec_u8_t    dstv_8;
  295.     vec_u16_t   dstv_16;
  296.     vec_u8_t    permv;
  297.     vec_u16_t   shiftv;
  298.     vec_u16_t   k32v;
  299.     
  300.     coeff0v = vec_ld( 0, coeff );
  301.     coeff3v = vec_splat( coeff0v, 3 );
  302.     coeff2v = vec_splat( coeff0v, 2 );
  303.     coeff1v = vec_splat( coeff0v, 1 );
  304.     coeff0v = vec_splat( coeff0v, 0 );
  305.     k32v    = vec_sl( vec_splat_u16( 1 ), vec_splat_u16( 5 ) );
  306.     permv   = vec_lvsl( 0, (uint8_t *) 1 );
  307.     shiftv  = vec_splat_u16( 6 );
  309.     VEC_LOAD( src, src2v_8, 5, vec_u8_t );
  310.     src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  312.     for( y = 0; y < i_height; y++ )
  313.     {
  314.         src0v_8 = src2v_8;
  315.         src1v_8 = src3v_8;
  316.         VEC_LOAD( srcp, src2v_8, 5, vec_u8_t );
  317.         src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  319.         dstv_16 = k32v;
  321.         DO_PROCESS( 0 );
  322.         DO_PROCESS( 1 );
  323.         DO_PROCESS( 2 );
  324.         DO_PROCESS( 3 );
  326.         dstv_16 = vec_sr( dstv_16, shiftv );
  327.         dstv_8  = vec_u16_to_u8( dstv_16 );
  328.         VEC_STORE4( dstv_8, dst );
  330.         dst  += i_dst_stride;
  331.         srcp += i_src_stride;
  332.     }
  333. }
  335. static void mc_chroma_altivec_8xh( uint8_t *src, int i_src_stride,
  336.                                    uint8_t *dst, int i_dst_stride,
  337.                                    int mvx, int mvy,
  338.                                    int i_height )
  339. {
  340.     uint8_t *srcp;
  341.     int y;
  342.     int d8x = mvx & 0x07;
  343.     int d8y = mvy & 0x07;
  345.     DECLARE_ALIGNED( uint16_t, coeff[4], 16 );
  346.     coeff[0] = (8-d8x)*(8-d8y);
  347.     coeff[1] = d8x    *(8-d8y);
  348.     coeff[2] = (8-d8x)*d8y;
  349.     coeff[3] = d8x    *d8y;
  351.     src  += (mvy >> 3) * i_src_stride + (mvx >> 3);
  352.     srcp  = &src[i_src_stride];
  353.     
  354.     LOAD_ZERO;
  355.     PREP_LOAD;
  356.     PREP_STORE8;
  357.     vec_u16_t   coeff0v, coeff1v, coeff2v, coeff3v;
  358.     vec_u8_t    src0v_8, src1v_8, src2v_8, src3v_8;
  359.     vec_u16_t   src0v_16, src1v_16, src2v_16, src3v_16;
  360.     vec_u8_t    dstv_8;
  361.     vec_u16_t   dstv_16;
  362.     vec_u8_t    permv;
  363.     vec_u16_t   shiftv;
  364.     vec_u16_t   k32v;
  365.     
  366.     coeff0v = vec_ld( 0, coeff );
  367.     coeff3v = vec_splat( coeff0v, 3 );
  368.     coeff2v = vec_splat( coeff0v, 2 );
  369.     coeff1v = vec_splat( coeff0v, 1 );
  370.     coeff0v = vec_splat( coeff0v, 0 );
  371.     k32v    = vec_sl( vec_splat_u16( 1 ), vec_splat_u16( 5 ) );
  372.     permv   = vec_lvsl( 0, (uint8_t *) 1 );
  373.     shiftv  = vec_splat_u16( 6 );
  375.     VEC_LOAD( src, src2v_8, 9, vec_u8_t );
  376.     src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  378.     for( y = 0; y < i_height; y++ )
  379.     {
  380.         src0v_8 = src2v_8;
  381.         src1v_8 = src3v_8;
  382.         VEC_LOAD( srcp, src2v_8, 9, vec_u8_t );
  383.         src3v_8 = vec_perm( src2v_8, src2v_8, permv );
  385.         dstv_16 = k32v;
  387.         DO_PROCESS( 0 );
  388.         DO_PROCESS( 1 );
  389.         DO_PROCESS( 2 );
  390.         DO_PROCESS( 3 );
  392.         dstv_16 = vec_sr( dstv_16, shiftv );
  393.         dstv_8  = vec_u16_to_u8( dstv_16 );
  394.         VEC_STORE8( dstv_8, dst );
  396.         dst  += i_dst_stride;
  397.         srcp += i_src_stride;
  398.     }
  399. }
  401. static void mc_chroma_altivec( uint8_t *src, int i_src_stride,
  402.                                uint8_t *dst, int i_dst_stride,
  403.                                int mvx, int mvy,
  404.                                int i_width, int i_height )
  405. {
  406.     if( i_width == 8 )
  407.     {
  408.         mc_chroma_altivec_8xh( src, i_src_stride, dst, i_dst_stride,
  409.                                mvx, mvy, i_height );
  410.         return;
  411.     }
  412.     if( i_width == 4 )
  413.     {
  414.         mc_chroma_altivec_4xh( src, i_src_stride, dst, i_dst_stride,
  415.                                mvx, mvy, i_height );
  416.         return;
  417.     }
  419.     mc_chroma_c( src, i_src_stride, dst, i_dst_stride,
  420.                  mvx, mvy, i_width, i_height );
  421. }
  423. void x264_mc_altivec_init( x264_mc_functions_t *pf )
  424. {
  425.     pf->mc_luma   = mc_luma_altivec;
  426.     pf->get_ref   = get_ref_altivec;
  427.     pf->mc_chroma = mc_chroma_altivec;
  428. }