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

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

Audio

开发平台：

Visual C++

predict.c：源码内容
  1. /*****************************************************************************
  2.  * predict.c: h264 encoder
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 Laurent Aimar
  5.  * $Id: predict.c,v 1.1 2004/06/03 19:27:07 fenrir Exp $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  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 "common/common.h"
  25. #include "common/clip1.h"
  26. #include "predict.h"
  28. extern void predict_16x16_v_mmx( uint8_t *src );
  29. extern void predict_16x16_dc_core_mmxext( uint8_t *src, int i_dc_left );
  30. extern void predict_16x16_dc_top_mmxext( uint8_t *src );
  31. extern void predict_16x16_p_core_mmxext( uint8_t *src, int i00, int b, int c );
  32. extern void predict_8x8c_p_core_mmxext( uint8_t *src, int i00, int b, int c );
  33. extern void predict_8x8c_dc_core_mmxext( uint8_t *src, int s2, int s3 );
  34. extern void predict_8x8c_v_mmx( uint8_t *src );
  35. extern void predict_8x8_v_mmxext( uint8_t *src, int i_neighbors );
  36. extern void predict_8x8_ddl_mmxext( uint8_t *src, int i_neighbors );
  37. extern void predict_8x8_ddl_sse2( uint8_t *src, int i_neighbors );
  38. extern void predict_8x8_ddr_sse2( uint8_t *src, int i_neighbors );
  39. extern void predict_8x8_vl_sse2( uint8_t *src, int i_neighbors );
  40. extern void predict_8x8_vr_core_mmxext( uint8_t *src, int i_neighbors, uint16_t ltt0 );
  41. extern void predict_8x8_dc_core_mmxext( uint8_t *src, int i_neighbors, uint8_t *pix_left );
  42. extern void predict_4x4_ddl_mmxext( uint8_t *src );
  43. extern void predict_4x4_vl_mmxext( uint8_t *src );
  45. static void predict_16x16_p( uint8_t *src )
  46. {
  47.     int a, b, c, i;
  48.     int H = 0;
  49.     int V = 0;
  50.     int i00;
  52.     for( i = 1; i <= 8; i++ )
  53.     {
  54.         H += i * ( src[7+i - FDEC_STRIDE ]  - src[7-i - FDEC_STRIDE ] );
  55.         V += i * ( src[(7+i)*FDEC_STRIDE -1] - src[(7-i)*FDEC_STRIDE -1] );
  56.     }
  58.     a = 16 * ( src[15*FDEC_STRIDE -1] + src[15 - FDEC_STRIDE] );
  59.     b = ( 5 * H + 32 ) >> 6;
  60.     c = ( 5 * V + 32 ) >> 6;
  61.     i00 = a - b * 7 - c * 7 + 16;
  63.     predict_16x16_p_core_mmxext( src, i00, b, c );
  64. }
  66. static void predict_8x8c_p( uint8_t *src )
  67. {
  68.     int a, b, c, i;
  69.     int H = 0;
  70.     int V = 0;
  71.     int i00;
  73.     for( i = 1; i <= 4; i++ )
  74.     {
  75.         H += i * ( src[3+i - FDEC_STRIDE] - src[3-i - FDEC_STRIDE] );
  76.         V += i * ( src[(3+i)*FDEC_STRIDE -1] - src[(3-i)*FDEC_STRIDE -1] );
  77.     }
  79.     a = 16 * ( src[7*FDEC_STRIDE -1] + src[7 - FDEC_STRIDE] );
  80.     b = ( 17 * H + 16 ) >> 5;
  81.     c = ( 17 * V + 16 ) >> 5;
  82.     i00 = a -3*b -3*c + 16;
  84.     predict_8x8c_p_core_mmxext( src, i00, b, c );
  85. }
  87. static void predict_16x16_dc( uint8_t *src )
  88. {
  89.     uint32_t dc=16;
  90.     int i;
  92.     for( i = 0; i < 16; i+=2 )
  93.     {
  94.         dc += src[-1 + i * FDEC_STRIDE];
  95.         dc += src[-1 + (i+1) * FDEC_STRIDE];
  96.     }
  98.     predict_16x16_dc_core_mmxext( src, dc );
  99. }
  101. static void predict_8x8c_dc( uint8_t *src )
  102. {
  103.     int s2 = 4
  104.        + src[-1 + 0*FDEC_STRIDE]
  105.        + src[-1 + 1*FDEC_STRIDE]
  106.        + src[-1 + 2*FDEC_STRIDE]
  107.        + src[-1 + 3*FDEC_STRIDE];
  109.     int s3 = 2
  110.        + src[-1 + 4*FDEC_STRIDE]
  111.        + src[-1 + 5*FDEC_STRIDE]
  112.        + src[-1 + 6*FDEC_STRIDE]
  113.        + src[-1 + 7*FDEC_STRIDE];
  115.     predict_8x8c_dc_core_mmxext( src, s2, s3 );
  116. }
  118. #define SRC(x,y) src[(x)+(y)*FDEC_STRIDE]
  119. static void predict_8x8_dc( uint8_t *src, int i_neighbor )
  120. {
  121.     uint8_t l[10];
  122.     l[0] = i_neighbor&MB_TOPLEFT ? SRC(-1,-1) : SRC(-1,0);
  123.     l[1] = SRC(-1,0);
  124.     l[2] = SRC(-1,1);
  125.     l[3] = SRC(-1,2);
  126.     l[4] = SRC(-1,3);
  127.     l[5] = SRC(-1,4);
  128.     l[6] = SRC(-1,5);
  129.     l[7] = SRC(-1,6);
  130.     l[8] =
  131.     l[9] = SRC(-1,7);
  133.     predict_8x8_dc_core_mmxext( src, i_neighbor, l+1 );
  134. }
  136. #ifdef ARCH_X86_64
  137. static void predict_16x16_h( uint8_t *src )
  138. {
  139.     int y;
  140.     for( y = 0; y < 16; y++ )
  141.     {
  142.         const uint64_t v = 0x0101010101010101ULL * src[-1];
  143.         uint64_t *p = (uint64_t*)src;
  144.         p[0] = p[1] = v;
  145.         src += FDEC_STRIDE;
  146.     }
  147. }
  149. static void predict_8x8c_h( uint8_t *src )
  150. {
  151.     int y;
  152.     for( y = 0; y < 8; y++ )
  153.     {
  154.         *(uint64_t*)src = 0x0101010101010101ULL * src[-1];
  155.         src += FDEC_STRIDE;
  156.     }
  157. }
  159. static void predict_16x16_dc_left( uint8_t *src )
  160. {
  161.     uint32_t s = 0;
  162.     uint64_t dc; 
  163.     int y;
  164.     
  165.     for( y = 0; y < 16; y++ )
  166.     {
  167.         s += src[-1 + y * FDEC_STRIDE];
  168.     }   
  169.     dc = (( s + 8 ) >> 4) * 0x0101010101010101ULL;
  170.     
  171.     for( y = 0; y < 16; y++ )
  172.     {
  173.         uint64_t *p = (uint64_t*)src;
  174.         p[0] = p[1] = dc;
  175.         src += FDEC_STRIDE;
  176.     }
  177. }
  179. static void predict_8x8c_dc_left( uint8_t *src )
  180. {
  181.     int y;
  182.     uint32_t s0 = 0, s1 = 0;
  183.     uint64_t dc0, dc1;
  185.     for( y = 0; y < 4; y++ )
  186.     {
  187.         s0 += src[y * FDEC_STRIDE     - 1];
  188.         s1 += src[(y+4) * FDEC_STRIDE - 1];
  189.     }
  190.     dc0 = (( s0 + 2 ) >> 2) * 0x0101010101010101ULL;
  191.     dc1 = (( s1 + 2 ) >> 2) * 0x0101010101010101ULL;
  193.     for( y = 0; y < 4; y++ )
  194.     {
  195.         *(uint64_t*)src = dc0;
  196.         src += FDEC_STRIDE;
  197.     }
  198.     for( y = 0; y < 4; y++ )
  199.     {
  200.         *(uint64_t*)src = dc1;
  201.         src += FDEC_STRIDE;
  202.     }
  204. }
  206. static void predict_8x8c_dc_top( uint8_t *src )
  207. {
  208.     int y, x;
  209.     uint32_t s0 = 0, s1 = 0;
  210.     uint64_t dc;
  212.     for( x = 0; x < 4; x++ )
  213.     {
  214.         s0 += src[x     - FDEC_STRIDE];
  215.         s1 += src[x + 4 - FDEC_STRIDE];
  216.     }
  217.     dc = (( s0 + 2 ) >> 2) * 0x01010101
  218.        + (( s1 + 2 ) >> 2) * 0x0101010100000000ULL;
  220.     for( y = 0; y < 8; y++ )
  221.     {
  222.         *(uint64_t*)src = dc;
  223.         src += FDEC_STRIDE;
  224.     }
  225. }
  226. #endif
  228. /* Diagonals */
  230. #define PREDICT_4x4_LOAD_LEFT 
  231.     const int l0 = src[-1+0*FDEC_STRIDE];   
  232.     const int l1 = src[-1+1*FDEC_STRIDE];   
  233.     const int l2 = src[-1+2*FDEC_STRIDE];   
  234.     UNUSED const int l3 = src[-1+3*FDEC_STRIDE];
  236. #define PREDICT_4x4_LOAD_TOP 
  237.     const int t0 = src[0-1*FDEC_STRIDE];   
  238.     const int t1 = src[1-1*FDEC_STRIDE];   
  239.     const int t2 = src[2-1*FDEC_STRIDE];   
  240.     UNUSED const int t3 = src[3-1*FDEC_STRIDE];
  242. #define PREDICT_4x4_LOAD_TOP_RIGHT 
  243.     const int t4 = src[4-1*FDEC_STRIDE];   
  244.     const int t5 = src[5-1*FDEC_STRIDE];   
  245.     const int t6 = src[6-1*FDEC_STRIDE];   
  246.     UNUSED const int t7 = src[7-1*FDEC_STRIDE];
  248. #define F1(a,b)   (((a)+(b)+1)>>1)
  249. #define F2(a,b,c) (((a)+2*(b)+(c)+2)>>2)
  251. #ifdef ARCH_X86_64 // slower on x86
  252. #if 0
  253. static void predict_4x4_ddl( uint8_t *src )
  254. {
  255.     PREDICT_4x4_LOAD_TOP
  256.     PREDICT_4x4_LOAD_TOP_RIGHT
  257.     uint32_t vec = (F2(t3,t4,t5)<< 0)
  258.                  + (F2(t4,t5,t6)<< 8)
  259.                  + (F2(t5,t6,t7)<<16)
  260.                  + (F2(t6,t7,t7)<<24);
  261.     *(uint32_t*)&src[3*FDEC_STRIDE] = vec;
  262.     *(uint32_t*)&src[2*FDEC_STRIDE] = vec = (vec<<8) + F2(t2,t3,t4);
  263.     *(uint32_t*)&src[1*FDEC_STRIDE] = vec = (vec<<8) + F2(t1,t2,t3);
  264.     *(uint32_t*)&src[0*FDEC_STRIDE] = vec = (vec<<8) + F2(t0,t1,t2);
  265. }
  266. #endif
  268. static void predict_4x4_ddr( uint8_t *src )
  269. {
  270.     const int lt = src[-1-FDEC_STRIDE];
  271.     PREDICT_4x4_LOAD_LEFT
  272.     PREDICT_4x4_LOAD_TOP
  273.     uint32_t vec = (F2(l0,lt,t0)<< 0)
  274.                  + (F2(lt,t0,t1)<< 8)
  275.                  + (F2(t0,t1,t2)<<16)
  276.                  + (F2(t1,t2,t3)<<24);
  277.     *(uint32_t*)&src[0*FDEC_STRIDE] = vec;
  278.     *(uint32_t*)&src[1*FDEC_STRIDE] = vec = (vec<<8) + F2(l1,l0,lt);
  279.     *(uint32_t*)&src[2*FDEC_STRIDE] = vec = (vec<<8) + F2(l2,l1,l0);
  280.     *(uint32_t*)&src[3*FDEC_STRIDE] = vec = (vec<<8) + F2(l3,l2,l1);
  281. }
  283. static void predict_4x4_vr( uint8_t *src )
  284. {
  285.     const int lt = src[-1-FDEC_STRIDE];
  286.     PREDICT_4x4_LOAD_LEFT
  287.     PREDICT_4x4_LOAD_TOP
  288.     const int ltt0 = lt + t0 + 1;
  289.     const int t0t1 = t0 + t1 + 1;
  290.     const int t1t2 = t1 + t2 + 1;
  291.     const int t2t3 = t2 + t3 + 1;
  292.     const int l0lt = l0 + lt + 1;
  293.     const int l1l0 = l1 + l0 + 1;
  294.     const int l2l1 = l2 + l1 + 1;
  296.     src[0*FDEC_STRIDE+0]=
  297.     src[2*FDEC_STRIDE+1]= ltt0 >> 1;
  299.     src[0*FDEC_STRIDE+1]=
  300.     src[2*FDEC_STRIDE+2]= t0t1 >> 1;
  302.     src[0*FDEC_STRIDE+2]=
  303.     src[2*FDEC_STRIDE+3]= t1t2 >> 1;
  305.     src[0*FDEC_STRIDE+3]= t2t3 >> 1;
  307.     src[1*FDEC_STRIDE+0]=
  308.     src[3*FDEC_STRIDE+1]= (l0lt + ltt0) >> 2;
  310.     src[1*FDEC_STRIDE+1]=
  311.     src[3*FDEC_STRIDE+2]= (ltt0 + t0t1) >> 2;
  313.     src[1*FDEC_STRIDE+2]=
  314.     src[3*FDEC_STRIDE+3]= (t0t1 + t1t2) >> 2;
  316.     src[1*FDEC_STRIDE+3]= (t1t2 + t2t3) >> 2;
  317.     src[2*FDEC_STRIDE+0]= (l1l0 + l0lt) >> 2;
  318.     src[3*FDEC_STRIDE+0]= (l2l1 + l1l0) >> 2;
  319. }
  321. static void predict_4x4_hd( uint8_t *src )
  322. {
  323.     const int lt= src[-1-1*FDEC_STRIDE];
  324.     PREDICT_4x4_LOAD_LEFT
  325.     PREDICT_4x4_LOAD_TOP
  326.     const int ltt0 = lt + t0 + 1;
  327.     const int t0t1 = t0 + t1 + 1;
  328.     const int t1t2 = t1 + t2 + 1;
  329.     const int l0lt = l0 + lt + 1;
  330.     const int l1l0 = l1 + l0 + 1;
  331.     const int l2l1 = l2 + l1 + 1;
  332.     const int l3l2 = l3 + l2 + 1;
  334.     src[0*FDEC_STRIDE+0]=
  335.     src[1*FDEC_STRIDE+2]= l0lt >> 1;
  336.     src[0*FDEC_STRIDE+1]=
  337.     src[1*FDEC_STRIDE+3]= (l0lt + ltt0) >> 2;
  338.     src[0*FDEC_STRIDE+2]= (ltt0 + t0t1) >> 2;
  339.     src[0*FDEC_STRIDE+3]= (t0t1 + t1t2) >> 2;
  340.     src[1*FDEC_STRIDE+0]=
  341.     src[2*FDEC_STRIDE+2]= l1l0 >> 1;
  342.     src[1*FDEC_STRIDE+1]=
  343.     src[2*FDEC_STRIDE+3]= (l0lt + l1l0) >> 2;
  344.     src[2*FDEC_STRIDE+0]=
  345.     src[3*FDEC_STRIDE+2]= l2l1 >> 1;
  346.     src[2*FDEC_STRIDE+1]=
  347.     src[3*FDEC_STRIDE+3]= (l1l0 + l2l1) >> 2;
  348.     src[3*FDEC_STRIDE+0]= l3l2 >> 1;
  349.     src[3*FDEC_STRIDE+1]= (l2l1 + l3l2) >> 2;
  350. }
  352. #if 0
  353. static void predict_4x4_vl( uint8_t *src )
  354. {
  355.     PREDICT_4x4_LOAD_TOP
  356.     PREDICT_4x4_LOAD_TOP_RIGHT
  357.     const int t0t1 = t0 + t1 + 1;
  358.     const int t1t2 = t1 + t2 + 1;
  359.     const int t2t3 = t2 + t3 + 1;
  360.     const int t3t4 = t3 + t4 + 1;
  361.     const int t4t5 = t4 + t5 + 1;
  362.     const int t5t6 = t5 + t6 + 1;
  364.     src[0*FDEC_STRIDE+0]= t0t1 >> 1;
  365.     src[0*FDEC_STRIDE+1]=
  366.     src[2*FDEC_STRIDE+0]= t1t2 >> 1;
  367.     src[0*FDEC_STRIDE+2]=
  368.     src[2*FDEC_STRIDE+1]= t2t3 >> 1;
  369.     src[0*FDEC_STRIDE+3]=
  370.     src[2*FDEC_STRIDE+2]= t3t4 >> 1;
  371.     src[2*FDEC_STRIDE+3]= t4t5 >> 1;
  372.     src[1*FDEC_STRIDE+0]= (t0t1 + t1t2) >> 2;
  373.     src[1*FDEC_STRIDE+1]=
  374.     src[3*FDEC_STRIDE+0]= (t1t2 + t2t3) >> 2;
  375.     src[1*FDEC_STRIDE+2]=
  376.     src[3*FDEC_STRIDE+1]= (t2t3 + t3t4) >> 2;
  377.     src[1*FDEC_STRIDE+3]=
  378.     src[3*FDEC_STRIDE+2]= (t3t4 + t4t5) >> 2;
  379.     src[3*FDEC_STRIDE+3]= (t4t5 + t5t6) >> 2;
  380. }
  381. #endif
  383. static void predict_4x4_hu( uint8_t *src )
  384. {
  385.     PREDICT_4x4_LOAD_LEFT
  386.     const int l1l0 = l1 + l0 + 1;
  387.     const int l2l1 = l2 + l1 + 1;
  388.     const int l3l2 = l3 + l2 + 1;
  390.     src[0*FDEC_STRIDE+0]= l1l0 >> 1;
  391.     src[0*FDEC_STRIDE+1]= (l1l0 + l2l1) >> 2;
  393.     src[0*FDEC_STRIDE+2]=
  394.     src[1*FDEC_STRIDE+0]= l2l1 >> 1;
  396.     src[0*FDEC_STRIDE+3]=
  397.     src[1*FDEC_STRIDE+1]= (l2l1 + l3l2) >> 2;
  399.     src[1*FDEC_STRIDE+2]=
  400.     src[2*FDEC_STRIDE+0]= l3l2 >> 1;
  402.     src[1*FDEC_STRIDE+3]=
  403.     src[2*FDEC_STRIDE+1]= (l2 + 3*l3 + 2) >> 2;
  405.     src[2*FDEC_STRIDE+3]=
  406.     src[3*FDEC_STRIDE+1]=
  407.     src[3*FDEC_STRIDE+0]=
  408.     src[2*FDEC_STRIDE+2]=
  409.     src[3*FDEC_STRIDE+2]=
  410.     src[3*FDEC_STRIDE+3]= l3;
  411. }
  412. #endif
  414. /****************************************************************************
  415.  * 8x8 prediction for intra luma block
  416.  ****************************************************************************/
  418. #define PL(y) 
  419.     const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
  420. #define PREDICT_8x8_LOAD_LEFT(have_tl) 
  421.     const int l0 = ((have_tl || (i_neighbor&MB_TOPLEFT) ? SRC(-1,-1) : SRC(-1,0)) 
  422.                      + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; 
  423.     PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) 
  424.     UNUSED const int l7 = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2;
  426. #define PT(x) 
  427.     const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  428. #define PREDICT_8x8_LOAD_TOP(have_tl) 
  429.     const int t0 = ((have_tl || (i_neighbor&MB_TOPLEFT) ? SRC(-1,-1) : SRC(0,-1)) 
  430.                      + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; 
  431.     PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) 
  432.     UNUSED const int t7 = ((i_neighbor&MB_TOPRIGHT ? SRC(8,-1) : SRC(7,-1)) 
  433.                      + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2; 
  435. #define PTR(x) 
  436.     t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  437. #define PREDICT_8x8_LOAD_TOPRIGHT 
  438.     int t8, t9, t10, t11, t12, t13, t14, t15; 
  439.     if(i_neighbor&MB_TOPRIGHT) { 
  440.         PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) 
  441.         t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; 
  442.     } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
  444. #define PREDICT_8x8_LOAD_TOPLEFT 
  445.     const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2;
  447. #define PREDICT_8x8_DC(v) 
  448.     int y; 
  449.     for( y = 0; y < 8; y++ ) { 
  450.         ((uint32_t*)src)[0] = 
  451.         ((uint32_t*)src)[1] = v; 
  452.         src += FDEC_STRIDE; 
  453.     }
  455. #define SRC4(x,y) *(uint32_t*)&SRC(x,y)
  457. #if 0
  458. static void predict_8x8_ddl( uint8_t *src, int i_neighbor )
  459. {
  460.     PREDICT_8x8_LOAD_TOP(0)
  461.     uint32_t vec0, vec1;
  462.     int t8b;
  463.     if(i_neighbor&MB_TOPRIGHT)
  464.     {
  465.         PREDICT_8x8_LOAD_TOPRIGHT
  466.         vec1 = (F2(t14,t15,t15)<<24)
  467.              + (F2(t13,t14,t15)<<16)
  468.              + (F2(t12,t13,t14)<< 8)
  469.              + (F2(t11,t12,t13)<< 0);
  470.         vec0 = (F2(t10,t11,t12)<<24)
  471.              + (F2( t9,t10,t11)<<16)
  472.              + (F2( t8, t9,t10)<< 8)
  473.              + (F2( t7, t8, t9)<< 0);
  474.         t8b = t8;
  475.     }
  476.     else
  477.     {
  478.         t8b = SRC(7,-1);
  479.         vec1 = t8b * 0x01010101;
  480.         vec0 = (vec1&0xffffff00) + F2(t7,t8b,t8b);
  481.     }
  482.     SRC4(4,7) = vec1;
  483.     SRC4(4,3) =
  484.     SRC4(0,7) = vec0;
  485.     SRC4(4,6) = vec1 = (vec1<<8) + (vec0>>24);
  486.     SRC4(4,2) =
  487.     SRC4(0,6) = vec0 = (vec0<<8) + F2(t6,t7,t8b);
  488.     SRC4(4,5) = vec1 = (vec1<<8) + (vec0>>24);
  489.     SRC4(4,1) =
  490.     SRC4(0,5) = vec0 = (vec0<<8) + F2(t5,t6,t7);
  491.     SRC4(4,4) = vec1 = (vec1<<8) + (vec0>>24);
  492.     SRC4(4,0) =
  493.     SRC4(0,4) = vec0 = (vec0<<8) + F2(t4,t5,t6);
  494.     SRC4(0,3) = vec0 = (vec0<<8) + F2(t3,t4,t5);
  495.     SRC4(0,2) = vec0 = (vec0<<8) + F2(t2,t3,t4);
  496.     SRC4(0,1) = vec0 = (vec0<<8) + F2(t1,t2,t3);
  497.     SRC4(0,0) = vec0 = (vec0<<8) + F2(t0,t1,t2);
  498. }
  499. #endif
  501. static void predict_8x8_ddr( uint8_t *src, int i_neighbor )
  502. {
  503.     PREDICT_8x8_LOAD_TOP(1)
  504.     PREDICT_8x8_LOAD_LEFT(1)
  505.     PREDICT_8x8_LOAD_TOPLEFT
  506.     uint32_t vec0, vec1;
  507.     vec1 = (F2(t7,t6,t5)<<24)
  508.          + (F2(t6,t5,t4)<<16)
  509.          + (F2(t5,t4,t3)<< 8)
  510.          + (F2(t4,t3,t2)<< 0);
  511.     vec0 = (F2(t3,t2,t1)<<24)
  512.          + (F2(t2,t1,t0)<<16)
  513.          + (F2(t1,t0,lt)<< 8)
  514.          + (F2(t0,lt,l0)<< 0);
  515.     SRC4(4,0) = vec1;
  516.     SRC4(0,0) =
  517.     SRC4(4,4) = vec0;
  518.     SRC4(4,1) = vec1 = (vec1<<8) + (vec0>>24);
  519.     SRC4(0,1) =
  520.     SRC4(4,5) = vec0 = (vec0<<8) + F2(lt,l0,l1);
  521.     SRC4(4,2) = vec1 = (vec1<<8) + (vec0>>24);
  522.     SRC4(0,2) =
  523.     SRC4(4,6) = vec0 = (vec0<<8) + F2(l0,l1,l2);
  524.     SRC4(4,3) = vec1 = (vec1<<8) + (vec0>>24);
  525.     SRC4(0,3) =
  526.     SRC4(4,7) = vec0 = (vec0<<8) + F2(l1,l2,l3);
  527.     SRC4(0,4) = vec0 = (vec0<<8) + F2(l2,l3,l4);
  528.     SRC4(0,5) = vec0 = (vec0<<8) + F2(l3,l4,l5);
  529.     SRC4(0,6) = vec0 = (vec0<<8) + F2(l4,l5,l6);
  530.     SRC4(0,7) = vec0 = (vec0<<8) + F2(l5,l6,l7);
  531. }
  533. #ifdef ARCH_X86_64
  534. static void predict_8x8_vr_mmxext( uint8_t *src, int i_neighbor )
  535. {
  536.     PREDICT_8x8_LOAD_TOPLEFT
  537.     const int t0 = F2(SRC(-1,-1), SRC(0,-1), SRC(1,-1));
  538.     predict_8x8_vr_core_mmxext( src, i_neighbor, lt+(t0<<8) );
  539.     {
  540.         PREDICT_8x8_LOAD_LEFT(1)
  541.         SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
  542.         SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
  543.         SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  544.         SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
  545.         SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  546.         SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
  547.         SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  548.     }
  549. }
  550. #endif
  552. /****************************************************************************
  553.  * Exported functions:
  554.  ****************************************************************************/
  555. void x264_predict_16x16_init_mmxext( x264_predict_t pf[7] )
  556. {
  557.     pf[I_PRED_16x16_V]       = predict_16x16_v_mmx;
  558.     pf[I_PRED_16x16_DC]      = predict_16x16_dc;
  559.     pf[I_PRED_16x16_DC_TOP]  = predict_16x16_dc_top_mmxext;
  560.     pf[I_PRED_16x16_P]       = predict_16x16_p;
  562. #ifdef ARCH_X86_64
  563.     pf[I_PRED_16x16_H]       = predict_16x16_h;
  564.     pf[I_PRED_16x16_DC_LEFT] = predict_16x16_dc_left;
  565. #endif
  566. }
  568. void x264_predict_8x8c_init_mmxext( x264_predict_t pf[7] )
  569. {
  570.     pf[I_PRED_CHROMA_V]       = predict_8x8c_v_mmx;
  571.     pf[I_PRED_CHROMA_P]       = predict_8x8c_p;
  572.     pf[I_PRED_CHROMA_DC]      = predict_8x8c_dc;
  574. #ifdef ARCH_X86_64
  575.     pf[I_PRED_CHROMA_H]       = predict_8x8c_h;
  576.     pf[I_PRED_CHROMA_DC_LEFT] = predict_8x8c_dc_left;
  577.     pf[I_PRED_CHROMA_DC_TOP]  = predict_8x8c_dc_top;
  578. #endif
  579. }
  581. void x264_predict_8x8_init_mmxext( x264_predict8x8_t pf[12] )
  582. {
  583.     pf[I_PRED_8x8_V]   = predict_8x8_v_mmxext;
  584.     pf[I_PRED_8x8_DC]  = predict_8x8_dc;
  585.     pf[I_PRED_8x8_DDR] = predict_8x8_ddr;
  586. #ifdef ARCH_X86_64 // x86 not written yet
  587.     pf[I_PRED_8x8_DDL] = predict_8x8_ddl_mmxext;
  588.     pf[I_PRED_8x8_VR]  = predict_8x8_vr_mmxext;
  589. #endif
  590. }
  592. void x264_predict_8x8_init_sse2( x264_predict8x8_t pf[12] )
  593. {
  594. #ifdef ARCH_X86_64 // x86 not written yet
  595.     pf[I_PRED_8x8_DDL] = predict_8x8_ddl_sse2;
  596.     pf[I_PRED_8x8_DDR] = predict_8x8_ddr_sse2;
  597.     pf[I_PRED_8x8_VL]  = predict_8x8_vl_sse2;
  598. #endif
  599. }
  601. void x264_predict_4x4_init_mmxext( x264_predict_t pf[12] )
  602. {
  603. #ifdef ARCH_X86_64 // x86 not written yet
  604.     pf[I_PRED_4x4_DDL] = predict_4x4_ddl_mmxext;
  605.     pf[I_PRED_4x4_VL]  = predict_4x4_vl_mmxext;
  606. #endif
  607. #ifdef ARCH_X86_64 // slower on x86
  608.     pf[I_PRED_4x4_DDR] = predict_4x4_ddr;
  609.     pf[I_PRED_4x4_VR]  = predict_4x4_vr;
  610.     pf[I_PRED_4x4_HD]  = predict_4x4_hd;
  611.     pf[I_PRED_4x4_HU]  = predict_4x4_hu;
  612. #endif
  613. }