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

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

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.  *          Loren Merritt <lorenm@u.washington.edu>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. /* predict4x4 are inspired from ffmpeg h264 decoder */
  28. #include "common.h"
  29. #include "clip1.h"
  31. #ifdef _MSC_VER
  32. #undef HAVE_MMXEXT  /* not finished now */
  33. #endif
  34. #ifdef HAVE_MMXEXT
  35. #   include "i386/predict.h"
  36. #endif
  38. /****************************************************************************
  39.  * 16x16 prediction for intra luma block
  40.  ****************************************************************************/
  42. #define PREDICT_16x16_DC(v) 
  43.     for( i = 0; i < 16; i++ )
  44.     {
  45.         uint32_t *p = (uint32_t*)src;
  46.         *p++ = v;
  47.         *p++ = v;
  48.         *p++ = v;
  49.         *p++ = v;
  50.         src += FDEC_STRIDE;
  51.     }
  53. static void predict_16x16_dc( uint8_t *src )
  54. {
  55.     uint32_t dc = 0;
  56.     int i;
  58.     for( i = 0; i < 16; i++ )
  59.     {
  60.         dc += src[-1 + i * FDEC_STRIDE];
  61.         dc += src[i - FDEC_STRIDE];
  62.     }
  63.     dc = (( dc + 16 ) >> 5) * 0x01010101;
  65.     PREDICT_16x16_DC(dc);
  66. }
  67. static void predict_16x16_dc_left( uint8_t *src )
  68. {
  69.     uint32_t dc = 0;
  70.     int i;
  72.     for( i = 0; i < 16; i++ )
  73.     {
  74.         dc += src[-1 + i * FDEC_STRIDE];
  75.     }
  76.     dc = (( dc + 8 ) >> 4) * 0x01010101;
  78.     PREDICT_16x16_DC(dc);
  79. }
  80. static void predict_16x16_dc_top( uint8_t *src )
  81. {
  82.     uint32_t dc = 0;
  83.     int i;
  85.     for( i = 0; i < 16; i++ )
  86.     {
  87.         dc += src[i - FDEC_STRIDE];
  88.     }
  89.     dc = (( dc + 8 ) >> 4) * 0x01010101;
  91.     PREDICT_16x16_DC(dc);
  92. }
  93. static void predict_16x16_dc_128( uint8_t *src )
  94. {
  95.     int i;
  96.     PREDICT_16x16_DC(0x80808080);
  97. }
  98. static void predict_16x16_h( uint8_t *src )
  99. {
  100.     int i;
  102.     for( i = 0; i < 16; i++ )
  103.     {
  104.         const uint32_t v = 0x01010101 * src[-1];
  105.         uint32_t *p = (uint32_t*)src;
  107.         *p++ = v;
  108.         *p++ = v;
  109.         *p++ = v;
  110.         *p++ = v;
  112.         src += FDEC_STRIDE;
  114.     }
  115. }
  116. static void predict_16x16_v( uint8_t *src )
  117. {
  118.     uint32_t v0 = *(uint32_t*)&src[ 0-FDEC_STRIDE];
  119.     uint32_t v1 = *(uint32_t*)&src[ 4-FDEC_STRIDE];
  120.     uint32_t v2 = *(uint32_t*)&src[ 8-FDEC_STRIDE];
  121.     uint32_t v3 = *(uint32_t*)&src[12-FDEC_STRIDE];
  122.     int i;
  124.     for( i = 0; i < 16; i++ )
  125.     {
  126.         uint32_t *p = (uint32_t*)src;
  127.         *p++ = v0;
  128.         *p++ = v1;
  129.         *p++ = v2;
  130.         *p++ = v3;
  131.         src += FDEC_STRIDE;
  132.     }
  133. }
  134. static void predict_16x16_p( uint8_t *src )
  135. {
  136.     int x, y, i;
  137.     int a, b, c;
  138.     int H = 0;
  139.     int V = 0;
  140.     int i00;
  142.     /* calcule H and V */
  143.     for( i = 0; i <= 7; i++ )
  144.     {
  145.         H += ( i + 1 ) * ( src[ 8 + i - FDEC_STRIDE ] - src[6 -i -FDEC_STRIDE] );
  146.         V += ( i + 1 ) * ( src[-1 + (8+i)*FDEC_STRIDE] - src[-1 + (6-i)*FDEC_STRIDE] );
  147.     }
  149.     a = 16 * ( src[-1 + 15*FDEC_STRIDE] + src[15 - FDEC_STRIDE] );
  150.     b = ( 5 * H + 32 ) >> 6;
  151.     c = ( 5 * V + 32 ) >> 6;
  153.     i00 = a - b * 7 - c * 7 + 16;
  155.     for( y = 0; y < 16; y++ )
  156.     {
  157.         int pix = i00;
  158.         for( x = 0; x < 16; x++ )
  159.         {
  160.             src[x] = x264_clip_uint8( pix>>5 );
  161.             pix += b;
  162.         }
  163.         src += FDEC_STRIDE;
  164.         i00 += c;
  165.     }
  166. }
  169. /****************************************************************************
  170.  * 8x8 prediction for intra chroma block
  171.  ****************************************************************************/
  173. static void predict_8x8c_dc_128( uint8_t *src )
  174. {
  175.     int y;
  177.     for( y = 0; y < 8; y++ )
  178.     {
  179.         uint32_t *p = (uint32_t*)src;
  180.         *p++ = 0x80808080;
  181.         *p++ = 0x80808080;
  182.         src += FDEC_STRIDE;
  183.     }
  184. }
  185. static void predict_8x8c_dc_left( uint8_t *src )
  186. {
  187.     int y;
  188.     uint32_t dc0 = 0, dc1 = 0;
  190.     for( y = 0; y < 4; y++ )
  191.     {
  192.         dc0 += src[y * FDEC_STRIDE     - 1];
  193.         dc1 += src[(y+4) * FDEC_STRIDE - 1];
  194.     }
  195.     dc0 = (( dc0 + 2 ) >> 2)*0x01010101;
  196.     dc1 = (( dc1 + 2 ) >> 2)*0x01010101;
  198.     for( y = 0; y < 4; y++ )
  199.     {
  200.         uint32_t *p = (uint32_t*)src;
  201.         *p++ = dc0;
  202.         *p++ = dc0;
  203.         src += FDEC_STRIDE;
  204.     }
  205.     for( y = 0; y < 4; y++ )
  206.     {
  207.         uint32_t *p = (uint32_t*)src;
  208.         *p++ = dc1;
  209.         *p++ = dc1;
  210.         src += FDEC_STRIDE;
  211.     }
  213. }
  214. static void predict_8x8c_dc_top( uint8_t *src )
  215. {
  216.     int y, x;
  217.     uint32_t dc0 = 0, dc1 = 0;
  219.     for( x = 0; x < 4; x++ )
  220.     {
  221.         dc0 += src[x     - FDEC_STRIDE];
  222.         dc1 += src[x + 4 - FDEC_STRIDE];
  223.     }
  224.     dc0 = (( dc0 + 2 ) >> 2)*0x01010101;
  225.     dc1 = (( dc1 + 2 ) >> 2)*0x01010101;
  227.     for( y = 0; y < 8; y++ )
  228.     {
  229.         uint32_t *p = (uint32_t*)src;
  230.         *p++ = dc0;
  231.         *p++ = dc1;
  232.         src += FDEC_STRIDE;
  233.     }
  234. }
  235. static void predict_8x8c_dc( uint8_t *src )
  236. {
  237.     int y;
  238.     int s0 = 0, s1 = 0, s2 = 0, s3 = 0;
  239.     uint32_t dc0, dc1, dc2, dc3;
  240.     int i;
  242.     /*
  243.           s0 s1
  244.        s2
  245.        s3
  246.     */
  247.     for( i = 0; i < 4; i++ )
  248.     {
  249.         s0 += src[i - FDEC_STRIDE];
  250.         s1 += src[i + 4 - FDEC_STRIDE];
  251.         s2 += src[-1 + i * FDEC_STRIDE];
  252.         s3 += src[-1 + (i+4)*FDEC_STRIDE];
  253.     }
  254.     /*
  255.        dc0 dc1
  256.        dc2 dc3
  257.      */
  258.     dc0 = (( s0 + s2 + 4 ) >> 3)*0x01010101;
  259.     dc1 = (( s1 + 2 ) >> 2)*0x01010101;
  260.     dc2 = (( s3 + 2 ) >> 2)*0x01010101;
  261.     dc3 = (( s1 + s3 + 4 ) >> 3)*0x01010101;
  263.     for( y = 0; y < 4; y++ )
  264.     {
  265.         uint32_t *p = (uint32_t*)src;
  266.         *p++ = dc0;
  267.         *p++ = dc1;
  268.         src += FDEC_STRIDE;
  269.     }
  271.     for( y = 0; y < 4; y++ )
  272.     {
  273.         uint32_t *p = (uint32_t*)src;
  274.         *p++ = dc2;
  275.         *p++ = dc3;
  276.         src += FDEC_STRIDE;
  277.     }
  278. }
  279. static void predict_8x8c_h( uint8_t *src )
  280. {
  281.     int i;
  283.     for( i = 0; i < 8; i++ )
  284.     {
  285.         uint32_t v = 0x01010101 * src[-1];
  286.         uint32_t *p = (uint32_t*)src;
  287.         *p++ = v;
  288.         *p++ = v;
  289.         src += FDEC_STRIDE;
  290.     }
  291. }
  292. static void predict_8x8c_v( uint8_t *src )
  293. {
  294.     uint32_t v0 = *(uint32_t*)&src[0-FDEC_STRIDE];
  295.     uint32_t v1 = *(uint32_t*)&src[4-FDEC_STRIDE];
  296.     int i;
  298.     for( i = 0; i < 8; i++ )
  299.     {
  300.         uint32_t *p = (uint32_t*)src;
  301.         *p++ = v0;
  302.         *p++ = v1;
  303.         src += FDEC_STRIDE;
  304.     }
  305. }
  306. static void predict_8x8c_p( uint8_t *src )
  307. {
  308.     int i;
  309.     int x,y;
  310.     int a, b, c;
  311.     int H = 0;
  312.     int V = 0;
  313.     int i00;
  315.     for( i = 0; i < 4; i++ )
  316.     {
  317.         H += ( i + 1 ) * ( src[4+i - FDEC_STRIDE] - src[2 - i -FDEC_STRIDE] );
  318.         V += ( i + 1 ) * ( src[-1 +(i+4)*FDEC_STRIDE] - src[-1+(2-i)*FDEC_STRIDE] );
  319.     }
  321.     a = 16 * ( src[-1+7*FDEC_STRIDE] + src[7 - FDEC_STRIDE] );
  322.     b = ( 17 * H + 16 ) >> 5;
  323.     c = ( 17 * V + 16 ) >> 5;
  324.     i00 = a -3*b -3*c + 16;
  326.     for( y = 0; y < 8; y++ )
  327.     {
  328.         int pix = i00;
  329.         for( x = 0; x < 8; x++ )
  330.         {
  331.             src[x] = x264_clip_uint8( pix>>5 );
  332.             pix += b;
  333.         }
  334.         src += FDEC_STRIDE;
  335.         i00 += c;
  336.     }
  337. }
  339. /****************************************************************************
  340.  * 4x4 prediction for intra luma block
  341.  ****************************************************************************/
  343. #define PREDICT_4x4_DC(v) 
  344. {
  345.     *(uint32_t*)&src[0*FDEC_STRIDE] =
  346.     *(uint32_t*)&src[1*FDEC_STRIDE] =
  347.     *(uint32_t*)&src[2*FDEC_STRIDE] =
  348.     *(uint32_t*)&src[3*FDEC_STRIDE] = v;
  349. }
  351. static void predict_4x4_dc_128( uint8_t *src )
  352. {
  353.     PREDICT_4x4_DC(0x80808080);
  354. }
  355. static void predict_4x4_dc_left( uint8_t *src )
  356. {
  357.     uint32_t dc = (( src[-1+0*FDEC_STRIDE] + src[-1+FDEC_STRIDE]+
  358.                      src[-1+2*FDEC_STRIDE] + src[-1+3*FDEC_STRIDE] + 2 ) >> 2)*0x01010101;
  359.     PREDICT_4x4_DC(dc);
  360. }
  361. static void predict_4x4_dc_top( uint8_t *src )
  362. {
  363.     uint32_t dc = (( src[0 - FDEC_STRIDE] + src[1 - FDEC_STRIDE] +
  364.                      src[2 - FDEC_STRIDE] + src[3 - FDEC_STRIDE] + 2 ) >> 2)*0x01010101;
  365.     PREDICT_4x4_DC(dc);
  366. }
  367. static void predict_4x4_dc( uint8_t *src )
  368. {
  369.     uint32_t dc = (( src[-1+0*FDEC_STRIDE] + src[-1+FDEC_STRIDE] +
  370.                      src[-1+2*FDEC_STRIDE] + src[-1+3*FDEC_STRIDE] +
  371.                      src[0 - FDEC_STRIDE]  + src[1 - FDEC_STRIDE] +
  372.                      src[2 - FDEC_STRIDE]  + src[3 - FDEC_STRIDE] + 4 ) >> 3)*0x01010101;
  373.     PREDICT_4x4_DC(dc);
  374. }
  375. static void predict_4x4_h( uint8_t *src )
  376. {
  377.     *(uint32_t*)&src[0*FDEC_STRIDE] = src[0*FDEC_STRIDE-1] * 0x01010101;
  378.     *(uint32_t*)&src[1*FDEC_STRIDE] = src[1*FDEC_STRIDE-1] * 0x01010101;
  379.     *(uint32_t*)&src[2*FDEC_STRIDE] = src[2*FDEC_STRIDE-1] * 0x01010101;
  380.     *(uint32_t*)&src[3*FDEC_STRIDE] = src[3*FDEC_STRIDE-1] * 0x01010101;
  381. }
  382. static void predict_4x4_v( uint8_t *src )
  383. {
  384.     uint32_t top = *((uint32_t*)&src[-FDEC_STRIDE]);
  385.     PREDICT_4x4_DC(top);
  386. }
  388. #define PREDICT_4x4_LOAD_LEFT 
  389.     const int l0 = src[-1+0*FDEC_STRIDE];   
  390.     const int l1 = src[-1+1*FDEC_STRIDE];   
  391.     const int l2 = src[-1+2*FDEC_STRIDE];   
  392.     UNUSED const int l3 = src[-1+3*FDEC_STRIDE];
  394. #define PREDICT_4x4_LOAD_TOP 
  395.     const int t0 = src[0-1*FDEC_STRIDE];   
  396.     const int t1 = src[1-1*FDEC_STRIDE];   
  397.     const int t2 = src[2-1*FDEC_STRIDE];   
  398.     UNUSED const int t3 = src[3-1*FDEC_STRIDE];
  400. #define PREDICT_4x4_LOAD_TOP_RIGHT 
  401.     const int t4 = src[4-1*FDEC_STRIDE];   
  402.     const int t5 = src[5-1*FDEC_STRIDE];   
  403.     const int t6 = src[6-1*FDEC_STRIDE];   
  404.     UNUSED const int t7 = src[7-1*FDEC_STRIDE];
  406. static void predict_4x4_ddl( uint8_t *src )
  407. {
  408.     PREDICT_4x4_LOAD_TOP
  409.     PREDICT_4x4_LOAD_TOP_RIGHT
  411.     src[0*FDEC_STRIDE+0] = ( t0 + 2*t1 + t2 + 2 ) >> 2;
  413.     src[0*FDEC_STRIDE+1] =
  414.     src[1*FDEC_STRIDE+0] = ( t1 + 2*t2 + t3 + 2 ) >> 2;
  416.     src[0*FDEC_STRIDE+2] =
  417.     src[1*FDEC_STRIDE+1] =
  418.     src[2*FDEC_STRIDE+0] = ( t2 + 2*t3 + t4 + 2 ) >> 2;
  420.     src[0*FDEC_STRIDE+3] =
  421.     src[1*FDEC_STRIDE+2] =
  422.     src[2*FDEC_STRIDE+1] =
  423.     src[3*FDEC_STRIDE+0] = ( t3 + 2*t4 + t5 + 2 ) >> 2;
  425.     src[1*FDEC_STRIDE+3] =
  426.     src[2*FDEC_STRIDE+2] =
  427.     src[3*FDEC_STRIDE+1] = ( t4 + 2*t5 + t6 + 2 ) >> 2;
  429.     src[2*FDEC_STRIDE+3] =
  430.     src[3*FDEC_STRIDE+2] = ( t5 + 2*t6 + t7 + 2 ) >> 2;
  432.     src[3*FDEC_STRIDE+3] = ( t6 + 3*t7 + 2 ) >> 2;
  433. }
  434. static void predict_4x4_ddr( uint8_t *src )
  435. {
  436.     const int lt = src[-1-FDEC_STRIDE];
  437.     PREDICT_4x4_LOAD_LEFT
  438.     PREDICT_4x4_LOAD_TOP
  440.     src[0*FDEC_STRIDE+0] =
  441.     src[1*FDEC_STRIDE+1] =
  442.     src[2*FDEC_STRIDE+2] =
  443.     src[3*FDEC_STRIDE+3] = ( t0 + 2 * lt + l0 + 2 ) >> 2;
  445.     src[0*FDEC_STRIDE+1] =
  446.     src[1*FDEC_STRIDE+2] =
  447.     src[2*FDEC_STRIDE+3] = ( lt + 2 * t0 + t1 + 2 ) >> 2;
  449.     src[0*FDEC_STRIDE+2] =
  450.     src[1*FDEC_STRIDE+3] = ( t0 + 2 * t1 + t2 + 2 ) >> 2;
  452.     src[0*FDEC_STRIDE+3] = ( t1 + 2 * t2 + t3 + 2 ) >> 2;
  454.     src[1*FDEC_STRIDE+0] =
  455.     src[2*FDEC_STRIDE+1] =
  456.     src[3*FDEC_STRIDE+2] = ( lt + 2 * l0 + l1 + 2 ) >> 2;
  458.     src[2*FDEC_STRIDE+0] =
  459.     src[3*FDEC_STRIDE+1] = ( l0 + 2 * l1 + l2 + 2 ) >> 2;
  461.     src[3*FDEC_STRIDE+0] = ( l1 + 2 * l2 + l3 + 2 ) >> 2;
  462. }
  464. static void predict_4x4_vr( uint8_t *src )
  465. {
  466.     const int lt = src[-1-FDEC_STRIDE];
  467.     PREDICT_4x4_LOAD_LEFT
  468.     PREDICT_4x4_LOAD_TOP
  470.     src[0*FDEC_STRIDE+0]=
  471.     src[2*FDEC_STRIDE+1]= ( lt + t0 + 1 ) >> 1;
  473.     src[0*FDEC_STRIDE+1]=
  474.     src[2*FDEC_STRIDE+2]= ( t0 + t1 + 1 ) >> 1;
  476.     src[0*FDEC_STRIDE+2]=
  477.     src[2*FDEC_STRIDE+3]= ( t1 + t2 + 1 ) >> 1;
  479.     src[0*FDEC_STRIDE+3]= ( t2 + t3 + 1 ) >> 1;
  481.     src[1*FDEC_STRIDE+0]=
  482.     src[3*FDEC_STRIDE+1]= ( l0 + 2 * lt + t0 + 2 ) >> 2;
  484.     src[1*FDEC_STRIDE+1]=
  485.     src[3*FDEC_STRIDE+2]= ( lt + 2 * t0 + t1 + 2 ) >> 2;
  487.     src[1*FDEC_STRIDE+2]=
  488.     src[3*FDEC_STRIDE+3]= ( t0 + 2 * t1 + t2 + 2) >> 2;
  490.     src[1*FDEC_STRIDE+3]= ( t1 + 2 * t2 + t3 + 2 ) >> 2;
  491.     src[2*FDEC_STRIDE+0]= ( lt + 2 * l0 + l1 + 2 ) >> 2;
  492.     src[3*FDEC_STRIDE+0]= ( l0 + 2 * l1 + l2 + 2 ) >> 2;
  493. }
  495. static void predict_4x4_hd( uint8_t *src )
  496. {
  497.     const int lt= src[-1-1*FDEC_STRIDE];
  498.     PREDICT_4x4_LOAD_LEFT
  499.     PREDICT_4x4_LOAD_TOP
  501.     src[0*FDEC_STRIDE+0]=
  502.     src[1*FDEC_STRIDE+2]= ( lt + l0 + 1 ) >> 1;
  503.     src[0*FDEC_STRIDE+1]=
  504.     src[1*FDEC_STRIDE+3]= ( l0 + 2 * lt + t0 + 2 ) >> 2;
  505.     src[0*FDEC_STRIDE+2]= ( lt + 2 * t0 + t1 + 2 ) >> 2;
  506.     src[0*FDEC_STRIDE+3]= ( t0 + 2 * t1 + t2 + 2 ) >> 2;
  507.     src[1*FDEC_STRIDE+0]=
  508.     src[2*FDEC_STRIDE+2]= ( l0 + l1 + 1 ) >> 1;
  509.     src[1*FDEC_STRIDE+1]=
  510.     src[2*FDEC_STRIDE+3]= ( lt + 2 * l0 + l1 + 2 ) >> 2;
  511.     src[2*FDEC_STRIDE+0]=
  512.     src[3*FDEC_STRIDE+2]= ( l1 + l2+ 1 ) >> 1;
  513.     src[2*FDEC_STRIDE+1]=
  514.     src[3*FDEC_STRIDE+3]= ( l0 + 2 * l1 + l2 + 2 ) >> 2;
  515.     src[3*FDEC_STRIDE+0]= ( l2 + l3 + 1 ) >> 1;
  516.     src[3*FDEC_STRIDE+1]= ( l1 + 2 * l2 + l3 + 2 ) >> 2;
  517. }
  519. static void predict_4x4_vl( uint8_t *src )
  520. {
  521.     PREDICT_4x4_LOAD_TOP
  522.     PREDICT_4x4_LOAD_TOP_RIGHT
  524.     src[0*FDEC_STRIDE+0]= ( t0 + t1 + 1 ) >> 1;
  525.     src[0*FDEC_STRIDE+1]=
  526.     src[2*FDEC_STRIDE+0]= ( t1 + t2 + 1 ) >> 1;
  527.     src[0*FDEC_STRIDE+2]=
  528.     src[2*FDEC_STRIDE+1]= ( t2 + t3 + 1 ) >> 1;
  529.     src[0*FDEC_STRIDE+3]=
  530.     src[2*FDEC_STRIDE+2]= ( t3 + t4 + 1 ) >> 1;
  531.     src[2*FDEC_STRIDE+3]= ( t4 + t5 + 1 ) >> 1;
  532.     src[1*FDEC_STRIDE+0]= ( t0 + 2 * t1 + t2 + 2 ) >> 2;
  533.     src[1*FDEC_STRIDE+1]=
  534.     src[3*FDEC_STRIDE+0]= ( t1 + 2 * t2 + t3 + 2 ) >> 2;
  535.     src[1*FDEC_STRIDE+2]=
  536.     src[3*FDEC_STRIDE+1]= ( t2 + 2 * t3 + t4 + 2 ) >> 2;
  537.     src[1*FDEC_STRIDE+3]=
  538.     src[3*FDEC_STRIDE+2]= ( t3 + 2 * t4 + t5 + 2 ) >> 2;
  539.     src[3*FDEC_STRIDE+3]= ( t4 + 2 * t5 + t6 + 2 ) >> 2;
  540. }
  542. static void predict_4x4_hu( uint8_t *src )
  543. {
  544.     PREDICT_4x4_LOAD_LEFT
  546.     src[0*FDEC_STRIDE+0]= ( l0 + l1 + 1 ) >> 1;
  547.     src[0*FDEC_STRIDE+1]= ( l0 + 2 * l1 + l2 + 2 ) >> 2;
  549.     src[0*FDEC_STRIDE+2]=
  550.     src[1*FDEC_STRIDE+0]= ( l1 + l2 + 1 ) >> 1;
  552.     src[0*FDEC_STRIDE+3]=
  553.     src[1*FDEC_STRIDE+1]= ( l1 + 2*l2 + l3 + 2 ) >> 2;
  555.     src[1*FDEC_STRIDE+2]=
  556.     src[2*FDEC_STRIDE+0]= ( l2 + l3 + 1 ) >> 1;
  558.     src[1*FDEC_STRIDE+3]=
  559.     src[2*FDEC_STRIDE+1]= ( l2 + 2 * l3 + l3 + 2 ) >> 2;
  561.     src[2*FDEC_STRIDE+3]=
  562.     src[3*FDEC_STRIDE+1]=
  563.     src[3*FDEC_STRIDE+0]=
  564.     src[2*FDEC_STRIDE+2]=
  565.     src[3*FDEC_STRIDE+2]=
  566.     src[3*FDEC_STRIDE+3]= l3;
  567. }
  569. /****************************************************************************
  570.  * 8x8 prediction for intra luma block
  571.  ****************************************************************************/
  573. #define SRC(x,y) src[(x)+(y)*FDEC_STRIDE]
  574. #define PL(y) 
  575.     const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
  576. #define PREDICT_8x8_LOAD_LEFT(have_tl) 
  577.     const int l0 = ((have_tl || (i_neighbor&MB_TOPLEFT) ? SRC(-1,-1) : SRC(-1,0)) 
  578.                      + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; 
  579.     PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) 
  580.     UNUSED const int l7 = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2;
  582. #define PT(x) 
  583.     const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  584. #define PREDICT_8x8_LOAD_TOP(have_tl) 
  585.     const int t0 = ((have_tl || (i_neighbor&MB_TOPLEFT) ? SRC(-1,-1) : SRC(0,-1)) 
  586.                      + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; 
  587.     PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) 
  588.     UNUSED const int t7 = ((i_neighbor&MB_TOPRIGHT ? SRC(8,-1) : SRC(7,-1)) 
  589.                      + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2; 
  591. #define PTR(x) 
  592.     t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
  593. #define PREDICT_8x8_LOAD_TOPRIGHT 
  594.     int t8, t9, t10, t11, t12, t13, t14, t15; 
  595.     if(i_neighbor&MB_TOPRIGHT) { 
  596.         PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) 
  597.         t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; 
  598.     } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
  600. #define PREDICT_8x8_LOAD_TOPLEFT 
  601.     const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2;
  603. #define PREDICT_8x8_DC(v) 
  604.     int y; 
  605.     for( y = 0; y < 8; y++ ) { 
  606.         ((uint32_t*)src)[0] = 
  607.         ((uint32_t*)src)[1] = v; 
  608.         src += FDEC_STRIDE; 
  609.     }
  611. static void predict_8x8_dc_128( uint8_t *src, int i_neighbor )
  612. {
  613.     PREDICT_8x8_DC(0x80808080);
  614. }
  615. static void predict_8x8_dc_left( uint8_t *src, int i_neighbor )
  616. {
  617.     PREDICT_8x8_LOAD_LEFT(0)
  618.     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101;
  619.     PREDICT_8x8_DC(dc);
  620. }
  621. static void predict_8x8_dc_top( uint8_t *src, int i_neighbor )
  622. {
  623.     PREDICT_8x8_LOAD_TOP(0)
  624.     const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101;
  625.     PREDICT_8x8_DC(dc);
  626. }
  627. static void predict_8x8_dc( uint8_t *src, int i_neighbor )
  628. {
  629.     PREDICT_8x8_LOAD_LEFT(0)
  630.     PREDICT_8x8_LOAD_TOP(0)
  631.     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7
  632.                          +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101;
  633.     PREDICT_8x8_DC(dc);
  634. }
  635. static void predict_8x8_h( uint8_t *src, int i_neighbor )
  636. {
  637.     PREDICT_8x8_LOAD_LEFT(0)
  638. #define ROW(y) ((uint32_t*)(src+y*FDEC_STRIDE))[0] =
  639.                ((uint32_t*)(src+y*FDEC_STRIDE))[1] = 0x01010101U * l##y
  640.     ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);
  641. #undef ROW
  642. }
  643. static void predict_8x8_v( uint8_t *src, int i_neighbor )
  644. {
  645.     int y;
  646.     PREDICT_8x8_LOAD_TOP(0);
  647.     src[0] = t0;
  648.     src[1] = t1;
  649.     src[2] = t2;
  650.     src[3] = t3;
  651.     src[4] = t4;
  652.     src[5] = t5;
  653.     src[6] = t6;
  654.     src[7] = t7;
  655.     for( y = 1; y < 8; y++ )
  656.         *(uint64_t*)(src+y*FDEC_STRIDE) = *(uint64_t*)src;
  657. }
  658. static void predict_8x8_ddl( uint8_t *src, int i_neighbor )
  659. {
  660.     PREDICT_8x8_LOAD_TOP(0)
  661.     PREDICT_8x8_LOAD_TOPRIGHT
  662.     SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
  663.     SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;
  664.     SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;
  665.     SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;
  666.     SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;
  667.     SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;
  668.     SRC(0,6)=SRC(1,5)=SRC(2,4)=SRC(3,3)=SRC(4,2)=SRC(5,1)=SRC(6,0)= (t6 + 2*t7 + t8 + 2) >> 2;
  669.     SRC(0,7)=SRC(1,6)=SRC(2,5)=SRC(3,4)=SRC(4,3)=SRC(5,2)=SRC(6,1)=SRC(7,0)= (t7 + 2*t8 + t9 + 2) >> 2;
  670.     SRC(1,7)=SRC(2,6)=SRC(3,5)=SRC(4,4)=SRC(5,3)=SRC(6,2)=SRC(7,1)= (t8 + 2*t9 + t10 + 2) >> 2;
  671.     SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;
  672.     SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;
  673.     SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;
  674.     SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;
  675.     SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
  676.     SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
  677. }
  678. static void predict_8x8_ddr( uint8_t *src, int i_neighbor )
  679. {
  680.     PREDICT_8x8_LOAD_TOP(1)
  681.     PREDICT_8x8_LOAD_LEFT(1)
  682.     PREDICT_8x8_LOAD_TOPLEFT
  683.     SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;
  684.     SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  685.     SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;
  686.     SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  687.     SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;
  688.     SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  689.     SRC(0,1)=SRC(1,2)=SRC(2,3)=SRC(3,4)=SRC(4,5)=SRC(5,6)=SRC(6,7)= (l1 + 2*l0 + lt + 2) >> 2;
  690.     SRC(0,0)=SRC(1,1)=SRC(2,2)=SRC(3,3)=SRC(4,4)=SRC(5,5)=SRC(6,6)=SRC(7,7)= (l0 + 2*lt + t0 + 2) >> 2;
  691.     SRC(1,0)=SRC(2,1)=SRC(3,2)=SRC(4,3)=SRC(5,4)=SRC(6,5)=SRC(7,6)= (lt + 2*t0 + t1 + 2) >> 2;
  692.     SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;
  693.     SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;
  694.     SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;
  695.     SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;
  696.     SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
  697.     SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
  698.   
  699. }
  700. static void predict_8x8_vr( uint8_t *src, int i_neighbor )
  701. {
  702.     PREDICT_8x8_LOAD_TOP(1)
  703.     PREDICT_8x8_LOAD_LEFT(1)
  704.     PREDICT_8x8_LOAD_TOPLEFT
  705.     SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
  706.     SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
  707.     SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
  708.     SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
  709.     SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
  710.     SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
  711.     SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
  712.     SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;
  713.     SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;
  714.     SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;
  715.     SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;
  716.     SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;
  717.     SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;
  718.     SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;
  719.     SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;
  720.     SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;
  721.     SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;
  722.     SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;
  723.     SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;
  724.     SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;
  725.     SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
  726.     SRC(7,0)= (t6 + t7 + 1) >> 1;
  727. }
  728. static void predict_8x8_hd( uint8_t *src, int i_neighbor )
  729. {
  730.     PREDICT_8x8_LOAD_TOP(1)
  731.     PREDICT_8x8_LOAD_LEFT(1)
  732.     PREDICT_8x8_LOAD_TOPLEFT
  733.     SRC(0,7)= (l6 + l7 + 1) >> 1;
  734.     SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;
  735.     SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;
  736.     SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;
  737.     SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;
  738.     SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;
  739.     SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;
  740.     SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;
  741.     SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;
  742.     SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;
  743.     SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;
  744.     SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;
  745.     SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;
  746.     SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;
  747.     SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;
  748.     SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;
  749.     SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;
  750.     SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;
  751.     SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;
  752.     SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;
  753.     SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
  754.     SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
  755. }
  756. static void predict_8x8_vl( uint8_t *src, int i_neighbor )
  757. {
  758.     PREDICT_8x8_LOAD_TOP(0)
  759.     PREDICT_8x8_LOAD_TOPRIGHT
  760.     SRC(0,0)= (t0 + t1 + 1) >> 1;
  761.     SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;
  762.     SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;
  763.     SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;
  764.     SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;
  765.     SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;
  766.     SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;
  767.     SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;
  768.     SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;
  769.     SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;
  770.     SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;
  771.     SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;
  772.     SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;
  773.     SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;
  774.     SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;
  775.     SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;
  776.     SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;
  777.     SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;
  778.     SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;
  779.     SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;
  780.     SRC(7,6)= (t10 + t11 + 1) >> 1;
  781.     SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
  782. }
  783. static void predict_8x8_hu( uint8_t *src, int i_neighbor )
  784. {
  785.     PREDICT_8x8_LOAD_LEFT(0)
  786.     SRC(0,0)= (l0 + l1 + 1) >> 1;
  787.     SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
  788.     SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;
  789.     SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;
  790.     SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;
  791.     SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;
  792.     SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;
  793.     SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;
  794.     SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;
  795.     SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;
  796.     SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;
  797.     SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;
  798.     SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;
  799.     SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;
  800.     SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=
  801.     SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=
  802.     SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=
  803.     SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;
  804. }
  806. /****************************************************************************
  807.  * Exported functions:
  808.  ****************************************************************************/
  809. void x264_predict_16x16_init( int cpu, x264_predict_t pf[7] )
  810. {
  811.     pf[I_PRED_16x16_V ]     = predict_16x16_v;
  812.     pf[I_PRED_16x16_H ]     = predict_16x16_h;
  813.     pf[I_PRED_16x16_DC]     = predict_16x16_dc;
  814.     pf[I_PRED_16x16_P ]     = predict_16x16_p;
  815.     pf[I_PRED_16x16_DC_LEFT]= predict_16x16_dc_left;
  816.     pf[I_PRED_16x16_DC_TOP ]= predict_16x16_dc_top;
  817.     pf[I_PRED_16x16_DC_128 ]= predict_16x16_dc_128;
  819. #ifdef HAVE_MMXEXT
  820.     if( cpu&X264_CPU_MMXEXT )
  821.     {
  822.         x264_predict_16x16_init_mmxext( pf );
  823.     }
  824. #endif
  825. }
  827. void x264_predict_8x8c_init( int cpu, x264_predict_t pf[7] )
  828. {
  829.     pf[I_PRED_CHROMA_V ]     = predict_8x8c_v;
  830.     pf[I_PRED_CHROMA_H ]     = predict_8x8c_h;
  831.     pf[I_PRED_CHROMA_DC]     = predict_8x8c_dc;
  832.     pf[I_PRED_CHROMA_P ]     = predict_8x8c_p;
  833.     pf[I_PRED_CHROMA_DC_LEFT]= predict_8x8c_dc_left;
  834.     pf[I_PRED_CHROMA_DC_TOP ]= predict_8x8c_dc_top;
  835.     pf[I_PRED_CHROMA_DC_128 ]= predict_8x8c_dc_128;
  837. #ifdef HAVE_MMXEXT
  838.     if( cpu&X264_CPU_MMXEXT )
  839.     {
  840.         x264_predict_8x8c_init_mmxext( pf );
  841.     }
  842. #endif
  843. }
  845. void x264_predict_8x8_init( int cpu, x264_predict8x8_t pf[12] )
  846. {
  847.     pf[I_PRED_8x8_V]      = predict_8x8_v;
  848.     pf[I_PRED_8x8_H]      = predict_8x8_h;
  849.     pf[I_PRED_8x8_DC]     = predict_8x8_dc;
  850.     pf[I_PRED_8x8_DDL]    = predict_8x8_ddl;
  851.     pf[I_PRED_8x8_DDR]    = predict_8x8_ddr;
  852.     pf[I_PRED_8x8_VR]     = predict_8x8_vr;
  853.     pf[I_PRED_8x8_HD]     = predict_8x8_hd;
  854.     pf[I_PRED_8x8_VL]     = predict_8x8_vl;
  855.     pf[I_PRED_8x8_HU]     = predict_8x8_hu;
  856.     pf[I_PRED_8x8_DC_LEFT]= predict_8x8_dc_left;
  857.     pf[I_PRED_8x8_DC_TOP] = predict_8x8_dc_top;
  858.     pf[I_PRED_8x8_DC_128] = predict_8x8_dc_128;
  860. #ifdef HAVE_MMXEXT
  861.     if( cpu&X264_CPU_MMXEXT )
  862.     {
  863.         x264_predict_8x8_init_mmxext( pf );
  864.     }
  865. #endif
  866. #ifdef HAVE_SSE2
  867.     if( cpu&X264_CPU_SSE2 )
  868.     {
  869.         x264_predict_8x8_init_sse2( pf );
  870.     }
  871. #endif
  872. }
  874. void x264_predict_4x4_init( int cpu, x264_predict_t pf[12] )
  875. {
  876.     pf[I_PRED_4x4_V]      = predict_4x4_v;
  877.     pf[I_PRED_4x4_H]      = predict_4x4_h;
  878.     pf[I_PRED_4x4_DC]     = predict_4x4_dc;
  879.     pf[I_PRED_4x4_DDL]    = predict_4x4_ddl;
  880.     pf[I_PRED_4x4_DDR]    = predict_4x4_ddr;
  881.     pf[I_PRED_4x4_VR]     = predict_4x4_vr;
  882.     pf[I_PRED_4x4_HD]     = predict_4x4_hd;
  883.     pf[I_PRED_4x4_VL]     = predict_4x4_vl;
  884.     pf[I_PRED_4x4_HU]     = predict_4x4_hu;
  885.     pf[I_PRED_4x4_DC_LEFT]= predict_4x4_dc_left;
  886.     pf[I_PRED_4x4_DC_TOP] = predict_4x4_dc_top;
  887.     pf[I_PRED_4x4_DC_128] = predict_4x4_dc_128;
  889. #ifdef HAVE_MMXEXT
  890.     if( cpu&X264_CPU_MMXEXT )
  891.     {
  892.         x264_predict_4x4_init_mmxext( pf );
  893.     }
  894. #endif
  895. }