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

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

Audio

开发平台：

Visual C++

predict-c.c：源码内容
  1. /*****************************************************************************
  2.  * predict.c: h264 encoder
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2008 x264 project
  5.  *
  6.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  7.  *          Loren Merritt <lorenm@u.washington.edu>
  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 "common/common.h"
  25. #include "predict.h"
  26. #include "pixel.h"
  28. extern void predict_16x16_v_mmx( uint8_t *src );
  29. extern void predict_16x16_h_mmxext( uint8_t *src );
  30. extern void predict_16x16_h_ssse3( uint8_t *src );
  31. extern void predict_16x16_dc_core_mmxext( uint8_t *src, int i_dc_left );
  32. extern void predict_16x16_dc_top_mmxext( uint8_t *src );
  33. extern void predict_16x16_p_core_mmxext( uint8_t *src, int i00, int b, int c );
  34. extern void predict_8x8c_p_core_mmxext( uint8_t *src, int i00, int b, int c );
  35. extern void predict_8x8c_dc_core_mmxext( uint8_t *src, int s2, int s3 );
  36. extern void predict_8x8c_v_mmx( uint8_t *src );
  37. extern void predict_8x8c_h_mmxext( uint8_t *src );
  38. extern void predict_8x8c_h_ssse3( uint8_t *src );
  39. extern void predict_8x8_v_mmxext( uint8_t *src, uint8_t edge[33] );
  40. extern void predict_8x8_h_mmxext( uint8_t *src, uint8_t edge[33] );
  41. extern void predict_8x8_dc_mmxext( uint8_t *src, uint8_t edge[33] );
  42. extern void predict_8x8_dc_top_mmxext( uint8_t *src, uint8_t edge[33] );
  43. extern void predict_8x8_dc_left_mmxext( uint8_t *src, uint8_t edge[33] );
  44. extern void predict_8x8_ddl_mmxext( uint8_t *src, uint8_t edge[33] );
  45. extern void predict_8x8_ddr_mmxext( uint8_t *src, uint8_t edge[33] );
  46. extern void predict_8x8_ddl_sse2( uint8_t *src, uint8_t edge[33] );
  47. extern void predict_8x8_ddr_sse2( uint8_t *src, uint8_t edge[33] );
  48. extern void predict_8x8_vl_sse2( uint8_t *src, uint8_t edge[33] );
  49. extern void predict_8x8_vr_core_mmxext( uint8_t *src, uint8_t edge[33] );
  50. extern void predict_4x4_ddl_mmxext( uint8_t *src );
  51. extern void predict_4x4_vl_mmxext( uint8_t *src );
  52. extern void predict_4x4_dc_mmxext( uint8_t *src );
  53. extern void predict_16x16_dc_top_sse2( uint8_t *src );
  54. extern void predict_16x16_dc_core_sse2( uint8_t *src, int i_dc_left );
  55. extern void predict_16x16_v_sse2( uint8_t *src );
  56. extern void predict_16x16_p_core_sse2( uint8_t *src, int i00, int b, int c );
  58. #define PREDICT_16x16_P(name)
  59. static void predict_16x16_p_##name( uint8_t *src )
  60. {
  61.     int a, b, c, i;
  62.     int H = 0;
  63.     int V = 0;
  64.     int i00;
  65.     for( i = 1; i <= 8; i++ )
  66.     {
  67.         H += i * ( src[7+i - FDEC_STRIDE ]  - src[7-i - FDEC_STRIDE ] );
  68.         V += i * ( src[(7+i)*FDEC_STRIDE -1] - src[(7-i)*FDEC_STRIDE -1] );
  69.     }
  70.     a = 16 * ( src[15*FDEC_STRIDE -1] + src[15 - FDEC_STRIDE] );
  71.     b = ( 5 * H + 32 ) >> 6;
  72.     c = ( 5 * V + 32 ) >> 6;
  73.     i00 = a - b * 7 - c * 7 + 16;
  74.     predict_16x16_p_core_##name( src, i00, b, c );
  75. }
  77. PREDICT_16x16_P( mmxext )
  78. PREDICT_16x16_P( sse2   )
  80. static void predict_8x8c_p_mmxext( uint8_t *src )
  81. {
  82.     int a, b, c, i;
  83.     int H = 0;
  84.     int V = 0;
  85.     int i00;
  87.     for( i = 1; i <= 4; i++ )
  88.     {
  89.         H += i * ( src[3+i - FDEC_STRIDE] - src[3-i - FDEC_STRIDE] );
  90.         V += i * ( src[(3+i)*FDEC_STRIDE -1] - src[(3-i)*FDEC_STRIDE -1] );
  91.     }
  93.     a = 16 * ( src[7*FDEC_STRIDE -1] + src[7 - FDEC_STRIDE] );
  94.     b = ( 17 * H + 16 ) >> 5;
  95.     c = ( 17 * V + 16 ) >> 5;
  96.     i00 = a -3*b -3*c + 16;
  98.     predict_8x8c_p_core_mmxext( src, i00, b, c );
  99. }
  101. #define PREDICT_16x16_DC(name)
  102. static void predict_16x16_dc_##name( uint8_t *src )
  103. {
  104.     uint32_t dc=16;
  105.     int i;
  106.     for( i = 0; i < 16; i+=2 )
  107.     {
  108.         dc += src[-1 + i * FDEC_STRIDE];
  109.         dc += src[-1 + (i+1) * FDEC_STRIDE];
  110.     }
  111.     predict_16x16_dc_core_##name( src, dc );
  112. }
  114. PREDICT_16x16_DC( mmxext )
  115. PREDICT_16x16_DC( sse2   )
  117. static void predict_8x8c_dc_mmxext( uint8_t *src )
  118. {
  119.     int s2 = 4
  120.        + src[-1 + 0*FDEC_STRIDE]
  121.        + src[-1 + 1*FDEC_STRIDE]
  122.        + src[-1 + 2*FDEC_STRIDE]
  123.        + src[-1 + 3*FDEC_STRIDE];
  125.     int s3 = 2
  126.        + src[-1 + 4*FDEC_STRIDE]
  127.        + src[-1 + 5*FDEC_STRIDE]
  128.        + src[-1 + 6*FDEC_STRIDE]
  129.        + src[-1 + 7*FDEC_STRIDE];
  131.     predict_8x8c_dc_core_mmxext( src, s2, s3 );
  132. }
  134. #ifdef ARCH_X86_64
  135. static void predict_16x16_dc_left( uint8_t *src )
  136. {
  137.     uint32_t s = 0;
  138.     uint64_t dc;
  139.     int y;
  141.     for( y = 0; y < 16; y++ )
  142.     {
  143.         s += src[-1 + y * FDEC_STRIDE];
  144.     }
  145.     dc = (( s + 8 ) >> 4) * 0x0101010101010101ULL;
  147.     for( y = 0; y < 16; y++ )
  148.     {
  149.         uint64_t *p = (uint64_t*)src;
  150.         p[0] = p[1] = dc;
  151.         src += FDEC_STRIDE;
  152.     }
  153. }
  155. static void predict_8x8c_dc_left( uint8_t *src )
  156. {
  157.     int y;
  158.     uint32_t s0 = 0, s1 = 0;
  159.     uint64_t dc0, dc1;
  161.     for( y = 0; y < 4; y++ )
  162.     {
  163.         s0 += src[y * FDEC_STRIDE     - 1];
  164.         s1 += src[(y+4) * FDEC_STRIDE - 1];
  165.     }
  166.     dc0 = (( s0 + 2 ) >> 2) * 0x0101010101010101ULL;
  167.     dc1 = (( s1 + 2 ) >> 2) * 0x0101010101010101ULL;
  169.     for( y = 0; y < 4; y++ )
  170.     {
  171.         *(uint64_t*)src = dc0;
  172.         src += FDEC_STRIDE;
  173.     }
  174.     for( y = 0; y < 4; y++ )
  175.     {
  176.         *(uint64_t*)src = dc1;
  177.         src += FDEC_STRIDE;
  178.     }
  180. }
  182. static void predict_8x8c_dc_top( uint8_t *src )
  183. {
  184.     int y, x;
  185.     uint32_t s0 = 0, s1 = 0;
  186.     uint64_t dc;
  188.     for( x = 0; x < 4; x++ )
  189.     {
  190.         s0 += src[x     - FDEC_STRIDE];
  191.         s1 += src[x + 4 - FDEC_STRIDE];
  192.     }
  193.     dc = (( s0 + 2 ) >> 2) * 0x01010101
  194.        + (( s1 + 2 ) >> 2) * 0x0101010100000000ULL;
  196.     for( y = 0; y < 8; y++ )
  197.     {
  198.         *(uint64_t*)src = dc;
  199.         src += FDEC_STRIDE;
  200.     }
  201. }
  202. #endif
  204. /* Diagonals */
  206. #define PREDICT_4x4_LOAD_LEFT 
  207.     const int l0 = src[-1+0*FDEC_STRIDE];   
  208.     const int l1 = src[-1+1*FDEC_STRIDE];   
  209.     const int l2 = src[-1+2*FDEC_STRIDE];   
  210.     UNUSED const int l3 = src[-1+3*FDEC_STRIDE];
  212. #define PREDICT_4x4_LOAD_TOP 
  213.     const int t0 = src[0-1*FDEC_STRIDE];   
  214.     const int t1 = src[1-1*FDEC_STRIDE];   
  215.     const int t2 = src[2-1*FDEC_STRIDE];   
  216.     UNUSED const int t3 = src[3-1*FDEC_STRIDE];
  218. #define PREDICT_4x4_LOAD_TOP_RIGHT 
  219.     const int t4 = src[4-1*FDEC_STRIDE];   
  220.     const int t5 = src[5-1*FDEC_STRIDE];   
  221.     const int t6 = src[6-1*FDEC_STRIDE];   
  222.     UNUSED const int t7 = src[7-1*FDEC_STRIDE];
  224. #define F1(a,b)   (((a)+(b)+1)>>1)
  225. #define F2(a,b,c) (((a)+2*(b)+(c)+2)>>2)
  227. #ifdef ARCH_X86_64 // slower on x86
  228. #if 0
  229. static void predict_4x4_ddl( uint8_t *src )
  230. {
  231.     PREDICT_4x4_LOAD_TOP
  232.     PREDICT_4x4_LOAD_TOP_RIGHT
  233.     uint32_t vec = (F2(t3,t4,t5)<< 0)
  234.                  + (F2(t4,t5,t6)<< 8)
  235.                  + (F2(t5,t6,t7)<<16)
  236.                  + (F2(t6,t7,t7)<<24);
  237.     *(uint32_t*)&src[3*FDEC_STRIDE] = vec;
  238.     *(uint32_t*)&src[2*FDEC_STRIDE] = vec = (vec<<8) + F2(t2,t3,t4);
  239.     *(uint32_t*)&src[1*FDEC_STRIDE] = vec = (vec<<8) + F2(t1,t2,t3);
  240.     *(uint32_t*)&src[0*FDEC_STRIDE] = vec = (vec<<8) + F2(t0,t1,t2);
  241. }
  242. #endif
  244. static void predict_4x4_ddr( uint8_t *src )
  245. {
  246.     const int lt = src[-1-FDEC_STRIDE];
  247.     PREDICT_4x4_LOAD_LEFT
  248.     PREDICT_4x4_LOAD_TOP
  249.     uint32_t vec = (F2(l0,lt,t0)<< 0)
  250.                  + (F2(lt,t0,t1)<< 8)
  251.                  + (F2(t0,t1,t2)<<16)
  252.                  + (F2(t1,t2,t3)<<24);
  253.     *(uint32_t*)&src[0*FDEC_STRIDE] = vec;
  254.     *(uint32_t*)&src[1*FDEC_STRIDE] = vec = (vec<<8) + F2(l1,l0,lt);
  255.     *(uint32_t*)&src[2*FDEC_STRIDE] = vec = (vec<<8) + F2(l2,l1,l0);
  256.     *(uint32_t*)&src[3*FDEC_STRIDE] = vec = (vec<<8) + F2(l3,l2,l1);
  257. }
  259. static void predict_4x4_vr( uint8_t *src )
  260. {
  261.     const int lt = src[-1-FDEC_STRIDE];
  262.     PREDICT_4x4_LOAD_LEFT
  263.     PREDICT_4x4_LOAD_TOP
  264.     const int ltt0 = lt + t0 + 1;
  265.     const int t0t1 = t0 + t1 + 1;
  266.     const int t1t2 = t1 + t2 + 1;
  267.     const int t2t3 = t2 + t3 + 1;
  268.     const int l0lt = l0 + lt + 1;
  269.     const int l1l0 = l1 + l0 + 1;
  270.     const int l2l1 = l2 + l1 + 1;
  272.     src[0*FDEC_STRIDE+0]=
  273.     src[2*FDEC_STRIDE+1]= ltt0 >> 1;
  275.     src[0*FDEC_STRIDE+1]=
  276.     src[2*FDEC_STRIDE+2]= t0t1 >> 1;
  278.     src[0*FDEC_STRIDE+2]=
  279.     src[2*FDEC_STRIDE+3]= t1t2 >> 1;
  281.     src[0*FDEC_STRIDE+3]= t2t3 >> 1;
  283.     src[1*FDEC_STRIDE+0]=
  284.     src[3*FDEC_STRIDE+1]= (l0lt + ltt0) >> 2;
  286.     src[1*FDEC_STRIDE+1]=
  287.     src[3*FDEC_STRIDE+2]= (ltt0 + t0t1) >> 2;
  289.     src[1*FDEC_STRIDE+2]=
  290.     src[3*FDEC_STRIDE+3]= (t0t1 + t1t2) >> 2;
  292.     src[1*FDEC_STRIDE+3]= (t1t2 + t2t3) >> 2;
  293.     src[2*FDEC_STRIDE+0]= (l1l0 + l0lt) >> 2;
  294.     src[3*FDEC_STRIDE+0]= (l2l1 + l1l0) >> 2;
  295. }
  297. static void predict_4x4_hd( uint8_t *src )
  298. {
  299.     const int lt= src[-1-1*FDEC_STRIDE];
  300.     PREDICT_4x4_LOAD_LEFT
  301.     PREDICT_4x4_LOAD_TOP
  302.     const int ltt0 = lt + t0 + 1;
  303.     const int t0t1 = t0 + t1 + 1;
  304.     const int t1t2 = t1 + t2 + 1;
  305.     const int l0lt = l0 + lt + 1;
  306.     const int l1l0 = l1 + l0 + 1;
  307.     const int l2l1 = l2 + l1 + 1;
  308.     const int l3l2 = l3 + l2 + 1;
  310.     src[0*FDEC_STRIDE+0]=
  311.     src[1*FDEC_STRIDE+2]= l0lt >> 1;
  312.     src[0*FDEC_STRIDE+1]=
  313.     src[1*FDEC_STRIDE+3]= (l0lt + ltt0) >> 2;
  314.     src[0*FDEC_STRIDE+2]= (ltt0 + t0t1) >> 2;
  315.     src[0*FDEC_STRIDE+3]= (t0t1 + t1t2) >> 2;
  316.     src[1*FDEC_STRIDE+0]=
  317.     src[2*FDEC_STRIDE+2]= l1l0 >> 1;
  318.     src[1*FDEC_STRIDE+1]=
  319.     src[2*FDEC_STRIDE+3]= (l0lt + l1l0) >> 2;
  320.     src[2*FDEC_STRIDE+0]=
  321.     src[3*FDEC_STRIDE+2]= l2l1 >> 1;
  322.     src[2*FDEC_STRIDE+1]=
  323.     src[3*FDEC_STRIDE+3]= (l1l0 + l2l1) >> 2;
  324.     src[3*FDEC_STRIDE+0]= l3l2 >> 1;
  325.     src[3*FDEC_STRIDE+1]= (l2l1 + l3l2) >> 2;
  326. }
  328. #if 0
  329. static void predict_4x4_vl( uint8_t *src )
  330. {
  331.     PREDICT_4x4_LOAD_TOP
  332.     PREDICT_4x4_LOAD_TOP_RIGHT
  333.     const int t0t1 = t0 + t1 + 1;
  334.     const int t1t2 = t1 + t2 + 1;
  335.     const int t2t3 = t2 + t3 + 1;
  336.     const int t3t4 = t3 + t4 + 1;
  337.     const int t4t5 = t4 + t5 + 1;
  338.     const int t5t6 = t5 + t6 + 1;
  340.     src[0*FDEC_STRIDE+0]= t0t1 >> 1;
  341.     src[0*FDEC_STRIDE+1]=
  342.     src[2*FDEC_STRIDE+0]= t1t2 >> 1;
  343.     src[0*FDEC_STRIDE+2]=
  344.     src[2*FDEC_STRIDE+1]= t2t3 >> 1;
  345.     src[0*FDEC_STRIDE+3]=
  346.     src[2*FDEC_STRIDE+2]= t3t4 >> 1;
  347.     src[2*FDEC_STRIDE+3]= t4t5 >> 1;
  348.     src[1*FDEC_STRIDE+0]= (t0t1 + t1t2) >> 2;
  349.     src[1*FDEC_STRIDE+1]=
  350.     src[3*FDEC_STRIDE+0]= (t1t2 + t2t3) >> 2;
  351.     src[1*FDEC_STRIDE+2]=
  352.     src[3*FDEC_STRIDE+1]= (t2t3 + t3t4) >> 2;
  353.     src[1*FDEC_STRIDE+3]=
  354.     src[3*FDEC_STRIDE+2]= (t3t4 + t4t5) >> 2;
  355.     src[3*FDEC_STRIDE+3]= (t4t5 + t5t6) >> 2;
  356. }
  357. #endif
  359. static void predict_4x4_hu( uint8_t *src )
  360. {
  361.     PREDICT_4x4_LOAD_LEFT
  362.     const int l1l0 = l1 + l0 + 1;
  363.     const int l2l1 = l2 + l1 + 1;
  364.     const int l3l2 = l3 + l2 + 1;
  366.     src[0*FDEC_STRIDE+0]= l1l0 >> 1;
  367.     src[0*FDEC_STRIDE+1]= (l1l0 + l2l1) >> 2;
  369.     src[0*FDEC_STRIDE+2]=
  370.     src[1*FDEC_STRIDE+0]= l2l1 >> 1;
  372.     src[0*FDEC_STRIDE+3]=
  373.     src[1*FDEC_STRIDE+1]= (l2l1 + l3l2) >> 2;
  375.     src[1*FDEC_STRIDE+2]=
  376.     src[2*FDEC_STRIDE+0]= l3l2 >> 1;
  378.     src[1*FDEC_STRIDE+3]=
  379.     src[2*FDEC_STRIDE+1]= (l2 + 3*l3 + 2) >> 2;
  381.     src[2*FDEC_STRIDE+3]=
  382.     src[3*FDEC_STRIDE+1]=
  383.     src[3*FDEC_STRIDE+0]=
  384.     src[2*FDEC_STRIDE+2]=
  385.     src[3*FDEC_STRIDE+2]=
  386.     src[3*FDEC_STRIDE+3]= l3;
  387. }
  388. #endif
  390. /****************************************************************************
  391.  * 8x8 prediction for intra luma block
  392.  ****************************************************************************/
  394. #define PL(y) 
  395.     UNUSED int l##y = edge[14-y];
  396. #define PT(x) 
  397.     UNUSED int t##x = edge[16+x];
  398. #define PREDICT_8x8_LOAD_TOPLEFT 
  399.     int lt = edge[15];
  400. #define PREDICT_8x8_LOAD_LEFT 
  401.     PL(0) PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) PL(7)
  402. #define PREDICT_8x8_LOAD_TOP 
  403.     PT(0) PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) PT(7)
  405. #define PREDICT_8x8_DC(v) 
  406.     int y; 
  407.     for( y = 0; y < 8; y++ ) { 
  408.         ((uint32_t*)src)[0] = 
  409.         ((uint32_t*)src)[1] = v; 
  410.         src += FDEC_STRIDE; 
  411.     }
  413. #define SRC(x,y) src[(x)+(y)*FDEC_STRIDE]
  415. static void predict_8x8_vr_mmxext( uint8_t *src, uint8_t edge[33] )
  416. {
  417.     predict_8x8_vr_core_mmxext( src, edge );
  418.     {
  419.         PREDICT_8x8_LOAD_TOPLEFT
  420.         PREDICT_8x8_LOAD_LEFT
  421.         SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
  422.         SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  423.         SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
  424.         SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  425.         SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
  426.         SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  427.     }
  428. }
  430. #define SUMSUB(a,b,c,d,e,f,g,h)
  431.     t=a; a+=b; b-=t;
  432.     t=c; c+=d; d-=t;
  433.     t=e; e+=f; f-=t;
  434.     t=g; g+=h; h-=t;
  436. #define INTRA_SA8D_X3(cpu) 
  437. void x264_intra_sa8d_x3_8x8_##cpu( uint8_t *fenc, uint8_t edge[33], int res[3] )
  438. {
  439.     PREDICT_8x8_LOAD_TOP
  440.     PREDICT_8x8_LOAD_LEFT
  441.     int t;
  442.     DECLARE_ALIGNED_16( int16_t sa8d_1d[2][8] );
  443.     SUMSUB(l0,l4,l1,l5,l2,l6,l3,l7);
  444.     SUMSUB(l0,l2,l1,l3,l4,l6,l5,l7);
  445.     SUMSUB(l0,l1,l2,l3,l4,l5,l6,l7);
  446.     sa8d_1d[0][0] = l0;
  447.     sa8d_1d[0][1] = l1;
  448.     sa8d_1d[0][2] = l2;
  449.     sa8d_1d[0][3] = l3;
  450.     sa8d_1d[0][4] = l4;
  451.     sa8d_1d[0][5] = l5;
  452.     sa8d_1d[0][6] = l6;
  453.     sa8d_1d[0][7] = l7;
  454.     SUMSUB(t0,t4,t1,t5,t2,t6,t3,t7);
  455.     SUMSUB(t0,t2,t1,t3,t4,t6,t5,t7);
  456.     SUMSUB(t0,t1,t2,t3,t4,t5,t6,t7);
  457.     sa8d_1d[1][0] = t0;
  458.     sa8d_1d[1][1] = t1;
  459.     sa8d_1d[1][2] = t2;
  460.     sa8d_1d[1][3] = t3;
  461.     sa8d_1d[1][4] = t4;
  462.     sa8d_1d[1][5] = t5;
  463.     sa8d_1d[1][6] = t6;
  464.     sa8d_1d[1][7] = t7;
  465.     x264_intra_sa8d_x3_8x8_core_##cpu( fenc, sa8d_1d, res );
  466. }
  468. #ifdef ARCH_X86_64
  469. INTRA_SA8D_X3(sse2)
  470. INTRA_SA8D_X3(ssse3)
  471. #else
  472. INTRA_SA8D_X3(mmxext)
  473. #endif
  475. /****************************************************************************
  476.  * Exported functions:
  477.  ****************************************************************************/
  478. void x264_predict_16x16_init_mmx( int cpu, x264_predict_t pf[7] )
  479. {
  480.     if( !(cpu&X264_CPU_MMX) )
  481.         return;
  482. #ifdef ARCH_X86_64
  483.     pf[I_PRED_16x16_DC_LEFT] = predict_16x16_dc_left;
  484. #endif
  485.     pf[I_PRED_16x16_V]       = predict_16x16_v_mmx;
  486.     if( !(cpu&X264_CPU_MMXEXT) )
  487.         return;
  488.     pf[I_PRED_16x16_DC]      = predict_16x16_dc_mmxext;
  489.     pf[I_PRED_16x16_DC_TOP]  = predict_16x16_dc_top_mmxext;
  490.     pf[I_PRED_16x16_P]       = predict_16x16_p_mmxext;
  491.     pf[I_PRED_16x16_H]       = predict_16x16_h_mmxext;
  492.     if( !(cpu&X264_CPU_SSE2) )
  493.         return;
  494.     pf[I_PRED_16x16_DC]     = predict_16x16_dc_sse2;
  495.     pf[I_PRED_16x16_V]      = predict_16x16_v_sse2;
  496.     if( cpu&X264_CPU_SSE2_IS_SLOW )
  497.         return;
  498.     pf[I_PRED_16x16_DC_TOP] = predict_16x16_dc_top_sse2;
  499.     pf[I_PRED_16x16_P]      = predict_16x16_p_sse2;
  500.     if( !(cpu&X264_CPU_SSSE3) )
  501.         return;
  502.     pf[I_PRED_16x16_H]      = predict_16x16_h_ssse3;
  503. }
  505. void x264_predict_8x8c_init_mmx( int cpu, x264_predict_t pf[7] )
  506. {
  507.     if( !(cpu&X264_CPU_MMX) )
  508.         return;
  509. #ifdef ARCH_X86_64
  510.     pf[I_PRED_CHROMA_DC_LEFT] = predict_8x8c_dc_left;
  511.     pf[I_PRED_CHROMA_DC_TOP]  = predict_8x8c_dc_top;
  512. #endif
  513.     pf[I_PRED_CHROMA_V]       = predict_8x8c_v_mmx;
  514.     if( !(cpu&X264_CPU_MMXEXT) )
  515.         return;
  516.     pf[I_PRED_CHROMA_H]       = predict_8x8c_h_mmxext;
  517.     pf[I_PRED_CHROMA_P]       = predict_8x8c_p_mmxext;
  518.     pf[I_PRED_CHROMA_DC]      = predict_8x8c_dc_mmxext;
  519.     if( !(cpu&X264_CPU_SSSE3) )
  520.         return;
  521.     pf[I_PRED_CHROMA_H]       = predict_8x8c_h_ssse3;
  522. }
  524. void x264_predict_8x8_init_mmx( int cpu, x264_predict8x8_t pf[12] )
  525. {
  526.     if( !(cpu&X264_CPU_MMXEXT) )
  527.         return;
  528.     pf[I_PRED_8x8_V]   = predict_8x8_v_mmxext;
  529.     pf[I_PRED_8x8_H]   = predict_8x8_h_mmxext;
  530.     pf[I_PRED_8x8_DC]  = predict_8x8_dc_mmxext;
  531.     pf[I_PRED_8x8_DC_TOP] = predict_8x8_dc_top_mmxext;
  532.     pf[I_PRED_8x8_DC_LEFT]= predict_8x8_dc_left_mmxext;
  533.     pf[I_PRED_8x8_VR]  = predict_8x8_vr_mmxext;
  534. #ifdef ARCH_X86
  535.     pf[I_PRED_8x8_DDL] = predict_8x8_ddl_mmxext;
  536.     pf[I_PRED_8x8_DDR] = predict_8x8_ddr_mmxext;
  537. #endif
  538.     if( !(cpu&X264_CPU_SSE2) )
  539.         return;
  540.     pf[I_PRED_8x8_DDL] = predict_8x8_ddl_sse2;
  541.     pf[I_PRED_8x8_VL]  = predict_8x8_vl_sse2;
  542.     pf[I_PRED_8x8_DDR] = predict_8x8_ddr_sse2;
  543. }
  545. void x264_predict_4x4_init_mmx( int cpu, x264_predict_t pf[12] )
  546. {
  547.     if( !(cpu&X264_CPU_MMX) )
  548.         return;
  549. #ifdef ARCH_X86_64
  550.     pf[I_PRED_4x4_DDR] = predict_4x4_ddr;
  551.     pf[I_PRED_4x4_VR]  = predict_4x4_vr;
  552.     pf[I_PRED_4x4_HD]  = predict_4x4_hd;
  553.     pf[I_PRED_4x4_HU]  = predict_4x4_hu;
  554. #endif
  555.     if( !(cpu&X264_CPU_MMXEXT) )
  556.         return;
  557.     pf[I_PRED_4x4_DDL] = predict_4x4_ddl_mmxext;
  558.     pf[I_PRED_4x4_VL]  = predict_4x4_vl_mmxext;
  559.     pf[I_PRED_4x4_DC]  = predict_4x4_dc_mmxext;
  560. }