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

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

Audio

开发平台：

Visual C++

dsputil.c：源码内容
  1. /*
  2.  * DSP utils
  3.  * Copyright (c) 2000, 2001 Fabrice Bellard.
  4.  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with this library; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  *
  20.  * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
  21.  */
  22.  
  23. /**
  24.  * @file dsputil.c
  25.  * DSP utils
  26.  */
  27.  
  28. #include "avcodec.h"
  29. #include "dsputil.h"
  30. #include "mpegvideo.h"
  31. #include "simple_idct.h"
  32. //#include "faandct.h"
  34. uint8_t cropTbl[256 + 2 * MAX_NEG_CROP];
  35. uint32_t squareTbl[512];
  37. //AS by ty
  38. const uint8_t ff_h263_loop_filter_strength[32]={
  39. //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  40.     0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9,10,10,10,11,11,11,12,12,12
  41. };
  42. //AE by ty
  44. const uint8_t ff_zigzag_direct[64] = {
  45.     0,   1,  8, 16,  9,  2,  3, 10,
  46.     17, 24, 32, 25, 18, 11,  4,  5,
  47.     12, 19, 26, 33, 40, 48, 41, 34,
  48.     27, 20, 13,  6,  7, 14, 21, 28,
  49.     35, 42, 49, 56, 57, 50, 43, 36,
  50.     29, 22, 15, 23, 30, 37, 44, 51,
  51.     58, 59, 52, 45, 38, 31, 39, 46,
  52.     53, 60, 61, 54, 47, 55, 62, 63
  53. };
  55. /* Specific zigzag scan for 248 idct. NOTE that unlike the
  56.    specification, we interleave the fields */
  57. const uint8_t ff_zigzag248_direct[64] = {
  58.      0,  8,  1,  9, 16, 24,  2, 10,
  59.     17, 25, 32, 40, 48, 56, 33, 41,
  60.     18, 26,  3, 11,  4, 12, 19, 27,
  61.     34, 42, 49, 57, 50, 58, 35, 43,
  62.     20, 28,  5, 13,  6, 14, 21, 29,
  63.     36, 44, 51, 59, 52, 60, 37, 45,
  64.     22, 30,  7, 15, 23, 31, 38, 46,
  65.     53, 61, 54, 62, 39, 47, 55, 63,
  66. };
  68. /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
  69. uint16_t __align8 inv_zigzag_direct16[64];
  71. const uint8_t ff_alternate_horizontal_scan[64] = {
  72.     0,  1,   2,  3,  8,  9, 16, 17, 
  73.     10, 11,  4,  5,  6,  7, 15, 14,
  74.     13, 12, 19, 18, 24, 25, 32, 33, 
  75.     26, 27, 20, 21, 22, 23, 28, 29,
  76.     30, 31, 34, 35, 40, 41, 48, 49, 
  77.     42, 43, 36, 37, 38, 39, 44, 45,
  78.     46, 47, 50, 51, 56, 57, 58, 59, 
  79.     52, 53, 54, 55, 60, 61, 62, 63,
  80. };
  82. const uint8_t ff_alternate_vertical_scan[64] = {
  83.     0,  8,  16, 24,  1,  9,  2, 10, 
  84.     17, 25, 32, 40, 48, 56, 57, 49,
  85.     41, 33, 26, 18,  3, 11,  4, 12, 
  86.     19, 27, 34, 42, 50, 58, 35, 43,
  87.     51, 59, 20, 28,  5, 13,  6, 14, 
  88.     21, 29, 36, 44, 52, 60, 37, 45,
  89.     53, 61, 22, 30,  7, 15, 23, 31, 
  90.     38, 46, 54, 62, 39, 47, 55, 63,
  91. };
  93. /* a*inverse[b]>>32 == a/b for all 0<=a<=65536 && 2<=b<=255 */
  94. const uint32_t inverse[256]={
  95.          0, 4294967295U,2147483648U,1431655766, 1073741824,  858993460,  715827883,  613566757, 
  96.  536870912,  477218589,  429496730,  390451573,  357913942,  330382100,  306783379,  286331154, 
  97.  268435456,  252645136,  238609295,  226050911,  214748365,  204522253,  195225787,  186737709, 
  98.  178956971,  171798692,  165191050,  159072863,  153391690,  148102321,  143165577,  138547333, 
  99.  134217728,  130150525,  126322568,  122713352,  119304648,  116080198,  113025456,  110127367, 
  100.  107374183,  104755300,  102261127,   99882961,   97612894,   95443718,   93368855,   91382283, 
  101.   89478486,   87652394,   85899346,   84215046,   82595525,   81037119,   79536432,   78090315, 
  102.   76695845,   75350304,   74051161,   72796056,   71582789,   70409300,   69273667,   68174085, 
  103.   67108864,   66076420,   65075263,   64103990,   63161284,   62245903,   61356676,   60492498, 
  104.   59652324,   58835169,   58040099,   57266231,   56512728,   55778797,   55063684,   54366675, 
  105.   53687092,   53024288,   52377650,   51746594,   51130564,   50529028,   49941481,   49367441, 
  106.   48806447,   48258060,   47721859,   47197443,   46684428,   46182445,   45691142,   45210183, 
  107.   44739243,   44278014,   43826197,   43383509,   42949673,   42524429,   42107523,   41698712, 
  108.   41297763,   40904451,   40518560,   40139882,   39768216,   39403370,   39045158,   38693400, 
  109.   38347923,   38008561,   37675152,   37347542,   37025581,   36709123,   36398028,   36092163, 
  110.   35791395,   35495598,   35204650,   34918434,   34636834,   34359739,   34087043,   33818641, 
  111.   33554432,   33294321,   33038210,   32786010,   32537632,   32292988,   32051995,   31814573, 
  112.   31580642,   31350127,   31122952,   30899046,   30678338,   30460761,   30246249,   30034737, 
  113.   29826162,   29620465,   29417585,   29217465,   29020050,   28825284,   28633116,   28443493, 
  114.   28256364,   28071682,   27889399,   27709467,   27531842,   27356480,   27183338,   27012373, 
  115.   26843546,   26676816,   26512144,   26349493,   26188825,   26030105,   25873297,   25718368, 
  116.   25565282,   25414008,   25264514,   25116768,   24970741,   24826401,   24683721,   24542671, 
  117.   24403224,   24265352,   24129030,   23994231,   23860930,   23729102,   23598722,   23469767, 
  118.   23342214,   23216040,   23091223,   22967740,   22845571,   22724695,   22605092,   22486740, 
  119.   22369622,   22253717,   22139007,   22025474,   21913099,   21801865,   21691755,   21582751, 
  120.   21474837,   21367997,   21262215,   21157475,   21053762,   20951060,   20849356,   20748635, 
  121.   20648882,   20550083,   20452226,   20355296,   20259280,   20164166,   20069941,   19976593, 
  122.   19884108,   19792477,   19701685,   19611723,   19522579,   19434242,   19346700,   19259944, 
  123.   19173962,   19088744,   19004281,   18920561,   18837576,   18755316,   18673771,   18592933, 
  124.   18512791,   18433337,   18354562,   18276457,   18199014,   18122225,   18046082,   17970575, 
  125.   17895698,   17821442,   17747799,   17674763,   17602325,   17530479,   17459217,   17388532, 
  126.   17318417,   17248865,   17179870,   17111424,   17043522,   16976156,   16909321,   16843010,
  127. };
  129. /* Input permutation for the simple_idct_mmx */
  130. static const uint8_t simple_mmx_permutation[64]={
  131. 0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D, 
  132. 0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D, 
  133. 0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D, 
  134. 0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F, 
  135. 0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F, 
  136. 0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D, 
  137. 0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F, 
  138. 0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
  139. };
  141. static int pix_sum_c(uint8_t * pix, int line_size)
  142. {
  143.     int s, i, j;
  145.     s = 0;
  146.     for (i = 0; i < 16; i++) {
  147. for (j = 0; j < 16; j += 8) {
  148.     s += pix[0];
  149.     s += pix[1];
  150.     s += pix[2];
  151.     s += pix[3];
  152.     s += pix[4];
  153.     s += pix[5];
  154.     s += pix[6];
  155.     s += pix[7];
  156.     pix += 8;
  157. }
  158. pix += line_size - 16;
  159.     }
  160.     return s;
  161. }
  163. static int pix_norm1_c(uint8_t * pix, int line_size)
  164. {
  165.     int s, i, j;
  166.     uint32_t *sq = squareTbl + 256;
  168.     s = 0;
  169.     for (i = 0; i < 16; i++) {
  170. for (j = 0; j < 16; j += 8) {
  171. #if 0
  172.     s += sq[pix[0]];
  173.     s += sq[pix[1]];
  174.     s += sq[pix[2]];
  175.     s += sq[pix[3]];
  176.     s += sq[pix[4]];
  177.     s += sq[pix[5]];
  178.     s += sq[pix[6]];
  179.     s += sq[pix[7]];
  180. #else
  181. #if LONG_MAX > 2147483647
  182.     register uint64_t x=*(uint64_t*)pix;
  183.     s += sq[x&0xff];
  184.     s += sq[(x>>8)&0xff];
  185.     s += sq[(x>>16)&0xff];
  186.     s += sq[(x>>24)&0xff];
  187.             s += sq[(x>>32)&0xff];
  188.             s += sq[(x>>40)&0xff];
  189.             s += sq[(x>>48)&0xff];
  190.             s += sq[(x>>56)&0xff];
  191. #else
  192.     register uint32_t x=*(uint32_t*)pix;
  193.     s += sq[x&0xff];
  194.     s += sq[(x>>8)&0xff];
  195.     s += sq[(x>>16)&0xff];
  196.     s += sq[(x>>24)&0xff];
  197.             x=*(uint32_t*)(pix+4);
  198.             s += sq[x&0xff];
  199.             s += sq[(x>>8)&0xff];
  200.             s += sq[(x>>16)&0xff];
  201.             s += sq[(x>>24)&0xff];
  202. #endif
  203. #endif
  204.     pix += 8;
  205. }
  206. pix += line_size - 16;
  207.     }
  208.     return s;
  209. }
  211. static void bswap_buf(uint32_t *dst, uint32_t *src, int w){
  212.     int i;
  213.     
  214.     for(i=0; i+8<=w; i+=8){
  215.         dst[i+0]= bswap_32(src[i+0]);
  216.         dst[i+1]= bswap_32(src[i+1]);
  217.         dst[i+2]= bswap_32(src[i+2]);
  218.         dst[i+3]= bswap_32(src[i+3]);
  219.         dst[i+4]= bswap_32(src[i+4]);
  220.         dst[i+5]= bswap_32(src[i+5]);
  221.         dst[i+6]= bswap_32(src[i+6]);
  222.         dst[i+7]= bswap_32(src[i+7]);
  223.     }
  224.     for(;i<w; i++){
  225.         dst[i+0]= bswap_32(src[i+0]);
  226.     }
  227. }
  229. static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
  230. {
  231.     int s, i;
  232.     uint32_t *sq = squareTbl + 256;
  234.     s = 0;
  235.     for (i = 0; i < h; i++) {
  236.         s += sq[pix1[0] - pix2[0]];
  237.         s += sq[pix1[1] - pix2[1]];
  238.         s += sq[pix1[2] - pix2[2]];
  239.         s += sq[pix1[3] - pix2[3]];
  240.         s += sq[pix1[4] - pix2[4]];
  241.         s += sq[pix1[5] - pix2[5]];
  242.         s += sq[pix1[6] - pix2[6]];
  243.         s += sq[pix1[7] - pix2[7]];
  244.         pix1 += line_size;
  245.         pix2 += line_size;
  246.     }
  247.     return s;
  248. }
  250. static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  251. {
  252.     int s, i;
  253.     uint32_t *sq = squareTbl + 256;
  255.     s = 0;
  256.     for (i = 0; i < h; i++) {
  257.         s += sq[pix1[ 0] - pix2[ 0]];
  258.         s += sq[pix1[ 1] - pix2[ 1]];
  259.         s += sq[pix1[ 2] - pix2[ 2]];
  260.         s += sq[pix1[ 3] - pix2[ 3]];
  261.         s += sq[pix1[ 4] - pix2[ 4]];
  262.         s += sq[pix1[ 5] - pix2[ 5]];
  263.         s += sq[pix1[ 6] - pix2[ 6]];
  264.         s += sq[pix1[ 7] - pix2[ 7]];
  265.         s += sq[pix1[ 8] - pix2[ 8]];
  266.         s += sq[pix1[ 9] - pix2[ 9]];
  267.         s += sq[pix1[10] - pix2[10]];
  268.         s += sq[pix1[11] - pix2[11]];
  269.         s += sq[pix1[12] - pix2[12]];
  270.         s += sq[pix1[13] - pix2[13]];
  271.         s += sq[pix1[14] - pix2[14]];
  272.         s += sq[pix1[15] - pix2[15]];
  274.         pix1 += line_size;
  275.         pix2 += line_size;
  276.     }
  277.     return s;
  278. }
  280. static void get_pixels_c(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
  281. {
  282.     int i;
  284.     /* read the pixels */
  285.     for(i=0;i<8;i++) {
  286.         block[0] = pixels[0];
  287.         block[1] = pixels[1];
  288.         block[2] = pixels[2];
  289.         block[3] = pixels[3];
  290.         block[4] = pixels[4];
  291.         block[5] = pixels[5];
  292.         block[6] = pixels[6];
  293.         block[7] = pixels[7];
  294.         pixels += line_size;
  295.         block += 8;
  296.     }
  297. }
  299. static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,
  300.   const uint8_t *s2, int stride){
  301.     int i;
  303.     /* read the pixels */
  304.     for(i=0;i<8;i++) {
  305.         block[0] = s1[0] - s2[0];
  306.         block[1] = s1[1] - s2[1];
  307.         block[2] = s1[2] - s2[2];
  308.         block[3] = s1[3] - s2[3];
  309.         block[4] = s1[4] - s2[4];
  310.         block[5] = s1[5] - s2[5];
  311.         block[6] = s1[6] - s2[6];
  312.         block[7] = s1[7] - s2[7];
  313.         s1 += stride;
  314.         s2 += stride;
  315.         block += 8;
  316.     }
  317. }
  320. static void put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
  321.  int line_size)
  322. {
  323.     int i;
  324.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  325.     
  326.     /* read the pixels */
  327.     for(i=0;i<8;i++) {
  328.         pixels[0] = cm[block[0]];
  329.         pixels[1] = cm[block[1]];
  330.         pixels[2] = cm[block[2]];
  331.         pixels[3] = cm[block[3]];
  332.         pixels[4] = cm[block[4]];
  333.         pixels[5] = cm[block[5]];
  334.         pixels[6] = cm[block[6]];
  335.         pixels[7] = cm[block[7]];
  337.         pixels += line_size;
  338.         block += 8;
  339.     }
  340. }
  342. static void put_signed_pixels_clamped_c(const DCTELEM *block, 
  343.                                         uint8_t *restrict pixels,
  344.                                         int line_size)
  345. {
  346.     int i, j;
  348.     for (i = 0; i < 8; i++) {
  349.         for (j = 0; j < 8; j++) {
  350.             if (*block < -128)
  351.                 *pixels = 0;
  352.             else if (*block > 127)
  353.                 *pixels = 255;
  354.             else
  355.                 *pixels = (uint8_t)(*block + 128);
  356.             block++;
  357.             pixels++;
  358.         }
  359.         pixels += (line_size - 8);
  360.     }
  361. }
  363. static void add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
  364.                           int line_size)
  365. {
  366.     int i;
  367.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  368.     
  369.     /* read the pixels */
  370.     for(i=0;i<8;i++) {
  371.         pixels[0] = cm[pixels[0] + block[0]];
  372.         pixels[1] = cm[pixels[1] + block[1]];
  373.         pixels[2] = cm[pixels[2] + block[2]];
  374.         pixels[3] = cm[pixels[3] + block[3]];
  375.         pixels[4] = cm[pixels[4] + block[4]];
  376.         pixels[5] = cm[pixels[5] + block[5]];
  377.         pixels[6] = cm[pixels[6] + block[6]];
  378.         pixels[7] = cm[pixels[7] + block[7]];
  379.         pixels += line_size;
  380.         block += 8;
  381.     }
  382. }
  383. #if 0
  384. #define PIXOP2(OPNAME, OP) 
  385. static void OPNAME ## _pixels(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  386. {
  387.     int i;
  388.     for(i=0; i<h; i++){
  389.         OP(*((uint64_t*)block), LD64(pixels));
  390.         pixels+=line_size;
  391.         block +=line_size;
  392.     }
  393. }
  395. static void OPNAME ## _no_rnd_pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  396. {
  397.     int i;
  398.     for(i=0; i<h; i++){
  399.         const uint64_t a= LD64(pixels  );
  400.         const uint64_t b= LD64(pixels+1);
  401.         OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));
  402.         pixels+=line_size;
  403.         block +=line_size;
  404.     }
  405. }
  407. static void OPNAME ## _pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  408. {
  409.     int i;
  410.     for(i=0; i<h; i++){
  411.         const uint64_t a= LD64(pixels  );
  412.         const uint64_t b= LD64(pixels+1);
  413.         OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));
  414.         pixels+=line_size;
  415.         block +=line_size;
  416.     }
  417. }
  419. static void OPNAME ## _no_rnd_pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  420. {
  421.     int i;
  422.     for(i=0; i<h; i++){
  423.         const uint64_t a= LD64(pixels          );
  424.         const uint64_t b= LD64(pixels+line_size);
  425.         OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));
  426.         pixels+=line_size;
  427.         block +=line_size;
  428.     }
  429. }
  431. static void OPNAME ## _pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  432. {
  433.     int i;
  434.     for(i=0; i<h; i++){
  435.         const uint64_t a= LD64(pixels          );
  436.         const uint64_t b= LD64(pixels+line_size);
  437.         OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));
  438.         pixels+=line_size;
  439.         block +=line_size;
  440.     }
  441. }
  443. static void OPNAME ## _pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  444. {
  445.         int i;
  446.         const uint64_t a= LD64(pixels  );
  447.         const uint64_t b= LD64(pixels+1);
  448.         uint64_t l0=  (a&0x0303030303030303ULL)
  449.                     + (b&0x0303030303030303ULL)
  450.                     + 0x0202020202020202ULL;
  451.         uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)
  452.                    + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);
  453.         uint64_t l1,h1;
  455.         pixels+=line_size;
  456.         for(i=0; i<h; i+=2){
  457.             uint64_t a= LD64(pixels  );
  458.             uint64_t b= LD64(pixels+1);
  459.             l1=  (a&0x0303030303030303ULL)
  460.                + (b&0x0303030303030303ULL);
  461.             h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)
  462.               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);
  463.             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));
  464.             pixels+=line_size;
  465.             block +=line_size;
  466.             a= LD64(pixels  );
  467.             b= LD64(pixels+1);
  468.             l0=  (a&0x0303030303030303ULL)
  469.                + (b&0x0303030303030303ULL)
  470.                + 0x0202020202020202ULL;
  471.             h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)
  472.               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);
  473.             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));
  474.             pixels+=line_size;
  475.             block +=line_size;
  476.         }
  477. }
  479. static void OPNAME ## _no_rnd_pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  480. {
  481.         int i;
  482.         const uint64_t a= LD64(pixels  );
  483.         const uint64_t b= LD64(pixels+1);
  484.         uint64_t l0=  (a&0x0303030303030303ULL)
  485.                     + (b&0x0303030303030303ULL)
  486.                     + 0x0101010101010101ULL;
  487.         uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)
  488.                    + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);
  489.         uint64_t l1,h1;
  491.         pixels+=line_size;
  492.         for(i=0; i<h; i+=2){
  493.             uint64_t a= LD64(pixels  );
  494.             uint64_t b= LD64(pixels+1);
  495.             l1=  (a&0x0303030303030303ULL)
  496.                + (b&0x0303030303030303ULL);
  497.             h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)
  498.               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);
  499.             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));
  500.             pixels+=line_size;
  501.             block +=line_size;
  502.             a= LD64(pixels  );
  503.             b= LD64(pixels+1);
  504.             l0=  (a&0x0303030303030303ULL)
  505.                + (b&0x0303030303030303ULL)
  506.                + 0x0101010101010101ULL;
  507.             h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)
  508.               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);
  509.             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));
  510.             pixels+=line_size;
  511.             block +=line_size;
  512.         }
  513. }
  515. CALL_2X_PIXELS(OPNAME ## _pixels16_c    , OPNAME ## _pixels_c    , 8)
  516. CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels_x2_c , 8)
  517. CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels_y2_c , 8)
  518. CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels_xy2_c, 8)
  519. CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels_x2_c , 8)
  520. CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels_y2_c , 8)
  521. CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels_xy2_c, 8)
  522. #define op_avg(a, b) a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEFEFEFEFEULL)>>1) )
  523. #else // 64 bit variant
  524. #define PIXOP2(OPNAME, OP) 
  525. static void OPNAME ## _pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  526.     int i;
  527.     for(i=0; i<h; i++){
  528.         OP(*((uint16_t*)(block  )), LD16(pixels  ));
  529.         pixels+=line_size;
  530.         block +=line_size;
  531.     }
  532. }
  533. static void OPNAME ## _pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  534.     int i;
  535.     for(i=0; i<h; i++){
  536.         OP(*((uint32_t*)(block  )), LD32(pixels  ));
  537.         pixels+=line_size;
  538.         block +=line_size;
  539.     }
  540. }
  541. static void OPNAME ## _pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  542.     int i;
  543.     for(i=0; i<h; i++){
  544.         OP(*((uint32_t*)(block  )), LD32(pixels  ));
  545.         OP(*((uint32_t*)(block+4)), LD32(pixels+4));
  546.         pixels+=line_size;
  547.         block +=line_size;
  548.     }
  549. }
  550. static inline void OPNAME ## _no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  551.     OPNAME ## _pixels8_c(block, pixels, line_size, h);
  552. }
  554. static inline void OPNAME ## _no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, 
  555.                                                 int src_stride1, int src_stride2, int h){
  556.     int i;
  557.     for(i=0; i<h; i++){
  558.         uint32_t a,b;
  559.         a= LD32(&src1[i*src_stride1  ]);
  560.         b= LD32(&src2[i*src_stride2  ]);
  561.         OP(*((uint32_t*)&dst[i*dst_stride  ]), no_rnd_avg32(a, b));
  562.         a= LD32(&src1[i*src_stride1+4]);
  563.         b= LD32(&src2[i*src_stride2+4]);
  564.         OP(*((uint32_t*)&dst[i*dst_stride+4]), no_rnd_avg32(a, b));
  565.     }
  566. }
  568. static inline void OPNAME ## _pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, 
  569.                                                 int src_stride1, int src_stride2, int h){
  570.     int i;
  571.     for(i=0; i<h; i++){
  572.         uint32_t a,b;
  573.         a= LD32(&src1[i*src_stride1  ]);
  574.         b= LD32(&src2[i*src_stride2  ]);
  575.         OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));
  576.         a= LD32(&src1[i*src_stride1+4]);
  577.         b= LD32(&src2[i*src_stride2+4]);
  578.         OP(*((uint32_t*)&dst[i*dst_stride+4]), rnd_avg32(a, b));
  579.     }
  580. }
  582. static inline void OPNAME ## _pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, 
  583.                                                 int src_stride1, int src_stride2, int h){
  584.     int i;
  585.     for(i=0; i<h; i++){
  586.         uint32_t a,b;
  587.         a= LD32(&src1[i*src_stride1  ]);
  588.         b= LD32(&src2[i*src_stride2  ]);
  589.         OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));
  590.     }
  591. }
  593. static inline void OPNAME ## _pixels2_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, 
  594.                                                 int src_stride1, int src_stride2, int h){
  595.     int i;
  596.     for(i=0; i<h; i++){
  597.         uint32_t a,b;
  598.         a= LD16(&src1[i*src_stride1  ]);
  599.         b= LD16(&src2[i*src_stride2  ]);
  600.         OP(*((uint16_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));
  601.     }
  602. }
  604. static inline void OPNAME ## _pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, 
  605.                                                 int src_stride1, int src_stride2, int h){
  606.     OPNAME ## _pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);
  607.     OPNAME ## _pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);
  608. }
  610. static inline void OPNAME ## _no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, 
  611.                                                 int src_stride1, int src_stride2, int h){
  612.     OPNAME ## _no_rnd_pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);
  613.     OPNAME ## _no_rnd_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);
  614. }
  616. static inline void OPNAME ## _no_rnd_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  617.     OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);
  618. }
  620. static inline void OPNAME ## _pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  621.     OPNAME ## _pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);
  622. }
  624. static inline void OPNAME ## _no_rnd_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  625.     OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);
  626. }
  628. static inline void OPNAME ## _pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  629.     OPNAME ## _pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);
  630. }
  632. static inline void OPNAME ## _pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,
  633.                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){
  634.     int i;
  635.     for(i=0; i<h; i++){
  636.         uint32_t a, b, c, d, l0, l1, h0, h1;
  637.         a= LD32(&src1[i*src_stride1]);
  638.         b= LD32(&src2[i*src_stride2]);
  639.         c= LD32(&src3[i*src_stride3]);
  640.         d= LD32(&src4[i*src_stride4]);
  641.         l0=  (a&0x03030303UL)
  642.            + (b&0x03030303UL)
  643.            + 0x02020202UL;
  644.         h0= ((a&0xFCFCFCFCUL)>>2)
  645.           + ((b&0xFCFCFCFCUL)>>2);
  646.         l1=  (c&0x03030303UL)
  647.            + (d&0x03030303UL);
  648.         h1= ((c&0xFCFCFCFCUL)>>2)
  649.           + ((d&0xFCFCFCFCUL)>>2);
  650.         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  651.         a= LD32(&src1[i*src_stride1+4]);
  652.         b= LD32(&src2[i*src_stride2+4]);
  653.         c= LD32(&src3[i*src_stride3+4]);
  654.         d= LD32(&src4[i*src_stride4+4]);
  655.         l0=  (a&0x03030303UL)
  656.            + (b&0x03030303UL)
  657.            + 0x02020202UL;
  658.         h0= ((a&0xFCFCFCFCUL)>>2)
  659.           + ((b&0xFCFCFCFCUL)>>2);
  660.         l1=  (c&0x03030303UL)
  661.            + (d&0x03030303UL);
  662.         h1= ((c&0xFCFCFCFCUL)>>2)
  663.           + ((d&0xFCFCFCFCUL)>>2);
  664.         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  665.     }
  666. }
  668. static inline void OPNAME ## _pixels4_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  669.     OPNAME ## _pixels4_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);
  670. }
  672. static inline void OPNAME ## _pixels4_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  673.     OPNAME ## _pixels4_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);
  674. }
  676. static inline void OPNAME ## _pixels2_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  677.     OPNAME ## _pixels2_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);
  678. }
  680. static inline void OPNAME ## _pixels2_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){
  681.     OPNAME ## _pixels2_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);
  682. }
  684. static inline void OPNAME ## _no_rnd_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,
  685.                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){
  686.     int i;
  687.     for(i=0; i<h; i++){
  688.         uint32_t a, b, c, d, l0, l1, h0, h1;
  689.         a= LD32(&src1[i*src_stride1]);
  690.         b= LD32(&src2[i*src_stride2]);
  691.         c= LD32(&src3[i*src_stride3]);
  692.         d= LD32(&src4[i*src_stride4]);
  693.         l0=  (a&0x03030303UL)
  694.            + (b&0x03030303UL)
  695.            + 0x01010101UL;
  696.         h0= ((a&0xFCFCFCFCUL)>>2)
  697.           + ((b&0xFCFCFCFCUL)>>2);
  698.         l1=  (c&0x03030303UL)
  699.            + (d&0x03030303UL);
  700.         h1= ((c&0xFCFCFCFCUL)>>2)
  701.           + ((d&0xFCFCFCFCUL)>>2);
  702.         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  703.         a= LD32(&src1[i*src_stride1+4]);
  704.         b= LD32(&src2[i*src_stride2+4]);
  705.         c= LD32(&src3[i*src_stride3+4]);
  706.         d= LD32(&src4[i*src_stride4+4]);
  707.         l0=  (a&0x03030303UL)
  708.            + (b&0x03030303UL)
  709.            + 0x01010101UL;
  710.         h0= ((a&0xFCFCFCFCUL)>>2)
  711.           + ((b&0xFCFCFCFCUL)>>2);
  712.         l1=  (c&0x03030303UL)
  713.            + (d&0x03030303UL);
  714.         h1= ((c&0xFCFCFCFCUL)>>2)
  715.           + ((d&0xFCFCFCFCUL)>>2);
  716.         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  717.     }
  718. }
  719. static inline void OPNAME ## _pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,
  720.                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){
  721.     OPNAME ## _pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);
  722.     OPNAME ## _pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);
  723. }
  724. static inline void OPNAME ## _no_rnd_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,
  725.                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){
  726.     OPNAME ## _no_rnd_pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);
  727.     OPNAME ## _no_rnd_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);
  728. }
  730. static inline void OPNAME ## _pixels2_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  731. {
  732.         int i, a0, b0, a1, b1;
  733.         a0= pixels[0];
  734.         b0= pixels[1] + 2;
  735.         a0 += b0;
  736.         b0 += pixels[2];
  738.         pixels+=line_size;
  739.         for(i=0; i<h; i+=2){
  740.             a1= pixels[0];
  741.             b1= pixels[1];
  742.             a1 += b1;
  743.             b1 += pixels[2];
  745.             block[0]= (a1+a0)>>2; /* FIXME non put */
  746.             block[1]= (b1+b0)>>2;
  748.             pixels+=line_size;
  749.             block +=line_size;
  751.             a0= pixels[0];
  752.             b0= pixels[1] + 2;
  753.             a0 += b0;
  754.             b0 += pixels[2];
  756.             block[0]= (a1+a0)>>2;
  757.             block[1]= (b1+b0)>>2;
  758.             pixels+=line_size;
  759.             block +=line_size;
  760.         }
  761. }
  763. static inline void OPNAME ## _pixels4_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  764. {
  765.         int i;
  766.         const uint32_t a= LD32(pixels  );
  767.         const uint32_t b= LD32(pixels+1);
  768.         uint32_t l0=  (a&0x03030303UL)
  769.                     + (b&0x03030303UL)
  770.                     + 0x02020202UL;
  771.         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)
  772.                    + ((b&0xFCFCFCFCUL)>>2);
  773.         uint32_t l1,h1;
  775.         pixels+=line_size;
  776.         for(i=0; i<h; i+=2){
  777.             uint32_t a= LD32(pixels  );
  778.             uint32_t b= LD32(pixels+1);
  779.             l1=  (a&0x03030303UL)
  780.                + (b&0x03030303UL);
  781.             h1= ((a&0xFCFCFCFCUL)>>2)
  782.               + ((b&0xFCFCFCFCUL)>>2);
  783.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  784.             pixels+=line_size;
  785.             block +=line_size;
  786.             a= LD32(pixels  );
  787.             b= LD32(pixels+1);
  788.             l0=  (a&0x03030303UL)
  789.                + (b&0x03030303UL)
  790.                + 0x02020202UL;
  791.             h0= ((a&0xFCFCFCFCUL)>>2)
  792.               + ((b&0xFCFCFCFCUL)>>2);
  793.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  794.             pixels+=line_size;
  795.             block +=line_size;
  796.         }
  797. }
  799. static inline void OPNAME ## _pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  800. {
  801.     int j;
  802.     for(j=0; j<2; j++){
  803.         int i;
  804.         const uint32_t a= LD32(pixels  );
  805.         const uint32_t b= LD32(pixels+1);
  806.         uint32_t l0=  (a&0x03030303UL)
  807.                     + (b&0x03030303UL)
  808.                     + 0x02020202UL;
  809.         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)
  810.                    + ((b&0xFCFCFCFCUL)>>2);
  811.         uint32_t l1,h1;
  813.         pixels+=line_size;
  814.         for(i=0; i<h; i+=2){
  815.             uint32_t a= LD32(pixels  );
  816.             uint32_t b= LD32(pixels+1);
  817.             l1=  (a&0x03030303UL)
  818.                + (b&0x03030303UL);
  819.             h1= ((a&0xFCFCFCFCUL)>>2)
  820.               + ((b&0xFCFCFCFCUL)>>2);
  821.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  822.             pixels+=line_size;
  823.             block +=line_size;
  824.             a= LD32(pixels  );
  825.             b= LD32(pixels+1);
  826.             l0=  (a&0x03030303UL)
  827.                + (b&0x03030303UL)
  828.                + 0x02020202UL;
  829.             h0= ((a&0xFCFCFCFCUL)>>2)
  830.               + ((b&0xFCFCFCFCUL)>>2);
  831.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  832.             pixels+=line_size;
  833.             block +=line_size;
  834.         }
  835.         pixels+=4-line_size*(h+1);
  836.         block +=4-line_size*h;
  837.     }
  838. }
  840. static inline void OPNAME ## _no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)
  841. {
  842.     int j;
  843.     for(j=0; j<2; j++){
  844.         int i;
  845.         const uint32_t a= LD32(pixels  );
  846.         const uint32_t b= LD32(pixels+1);
  847.         uint32_t l0=  (a&0x03030303UL)
  848.                     + (b&0x03030303UL)
  849.                     + 0x01010101UL;
  850.         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)
  851.                    + ((b&0xFCFCFCFCUL)>>2);
  852.         uint32_t l1,h1;
  854.         pixels+=line_size;
  855.         for(i=0; i<h; i+=2){
  856.             uint32_t a= LD32(pixels  );
  857.             uint32_t b= LD32(pixels+1);
  858.             l1=  (a&0x03030303UL)
  859.                + (b&0x03030303UL);
  860.             h1= ((a&0xFCFCFCFCUL)>>2)
  861.               + ((b&0xFCFCFCFCUL)>>2);
  862.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  863.             pixels+=line_size;
  864.             block +=line_size;
  865.             a= LD32(pixels  );
  866.             b= LD32(pixels+1);
  867.             l0=  (a&0x03030303UL)
  868.                + (b&0x03030303UL)
  869.                + 0x01010101UL;
  870.             h0= ((a&0xFCFCFCFCUL)>>2)
  871.               + ((b&0xFCFCFCFCUL)>>2);
  872.             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));
  873.             pixels+=line_size;
  874.             block +=line_size;
  875.         }
  876.         pixels+=4-line_size*(h+1);
  877.         block +=4-line_size*h;
  878.     }
  879. }
  881. CALL_2X_PIXELS(OPNAME ## _pixels16_c  , OPNAME ## _pixels8_c  , 8)
  882. CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels8_x2_c , 8)
  883. CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels8_y2_c , 8)
  884. CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels8_xy2_c, 8)
  885. CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_c  , OPNAME ## _pixels8_c         , 8)
  886. CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels8_x2_c , 8)
  887. CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels8_y2_c , 8)
  888. CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels8_xy2_c, 8)
  890. #define op_avg(a, b) a = rnd_avg32(a, b)
  891. #endif
  892. #define op_put(a, b) a = b
  893. PIXOP2(avg, op_avg)
  894. PIXOP2(put, op_put)
  895. #undef op_avg
  896. #undef op_put
  897. #define avg2(a,b) ((a+b+1)>>1)
  898. #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
  899. static void put_no_rnd_pixels16_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
  900.     put_no_rnd_pixels16_l2(dst, a, b, stride, stride, stride, h);
  901. }
  902. static void put_no_rnd_pixels8_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
  903.     put_no_rnd_pixels8_l2(dst, a, b, stride, stride, stride, h);
  904. }
  905. static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
  906. {
  907.     const int A=(16-x16)*(16-y16);
  908.     const int B=(   x16)*(16-y16);
  909.     const int C=(16-x16)*(   y16);
  910.     const int D=(   x16)*(   y16);
  911.     int i;
  912.     for(i=0; i<h; i++)
  913.     {
  914.         dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
  915.         dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
  916.         dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
  917.         dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
  918.         dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
  919.         dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
  920.         dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
  921.         dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
  922.         dst+= stride;
  923.         src+= stride;
  924.     }
  925. }
  926. static void gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy, 
  927.                   int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
  928. {
  929.     int y, vx, vy;
  930.     const int s= 1<<shift;
  931.     
  932.     width--;
  933.     height--;
  934.     for(y=0; y<h; y++){
  935.         int x;
  936.         vx= ox;
  937.         vy= oy;
  938.         for(x=0; x<8; x++){ //XXX FIXME optimize
  939.             int src_x, src_y, frac_x, frac_y, index;
  940.             src_x= vx>>16;
  941.             src_y= vy>>16;
  942.             frac_x= src_x&(s-1);
  943.             frac_y= src_y&(s-1);
  944.             src_x>>=shift;
  945.             src_y>>=shift;
  946.   
  947.             if((unsigned)src_x < width){
  948.                 if((unsigned)src_y < height){
  949.                     index= src_x + src_y*stride;
  950.                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_x)
  951.                                            + src[index       +1]*   frac_x )*(s-frac_y)
  952.                                         + (  src[index+stride  ]*(s-frac_x)
  953.                                            + src[index+stride+1]*   frac_x )*   frac_y
  954.                                         + r)>>(shift*2);
  955.                 }else{
  956.                     index= src_x + clip(src_y, 0, height)*stride;                    
  957.                     dst[y*stride + x]= ( (  src[index         ]*(s-frac_x) 
  958.                                           + src[index       +1]*   frac_x )*s
  959.                                         + r)>>(shift*2);
  960.                 }
  961.             }else{
  962.                 if((unsigned)src_y < height){
  963.                     index= clip(src_x, 0, width) + src_y*stride;                    
  964.                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_y) 
  965.                                            + src[index+stride  ]*   frac_y )*s
  966.                                         + r)>>(shift*2);
  967.                 }else{
  968.                     index= clip(src_x, 0, width) + clip(src_y, 0, height)*stride;                    
  969.                     dst[y*stride + x]=    src[index         ];
  970.                 }
  971.             }
  972.             
  973.             vx+= dxx;
  974.             vy+= dyx;
  975.         }
  976.         ox += dxy;
  977.         oy += dyy;
  978.     }
  979. }
  980. static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  981.     switch(width){
  982.     case 2: put_pixels2_c (dst, src, stride, height); break;
  983.     case 4: put_pixels4_c (dst, src, stride, height); break;
  984.     case 8: put_pixels8_c (dst, src, stride, height); break;
  985.     case 16:put_pixels16_c(dst, src, stride, height); break;
  986.     }
  987. }
  988. static inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  989.     int i,j;
  990.     for (i=0; i < height; i++) {
  991.       for (j=0; j < width; j++) {
  992. dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
  993.       }
  994.       src += stride;
  995.       dst += stride;
  996.     }
  997. }
  998. static inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  999.     int i,j;
  1000.     for (i=0; i < height; i++) {
  1001.       for (j=0; j < width; j++) {
  1002. dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
  1003.       }
  1004.       src += stride;
  1005.       dst += stride;
  1006.     }
  1007. }
  1008.     
  1009. static inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1010.     int i,j;
  1011.     for (i=0; i < height; i++) {
  1012.       for (j=0; j < width; j++) {
  1013. dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
  1014.       }
  1015.       src += stride;
  1016.       dst += stride;
  1017.     }
  1018. }
  1019.     
  1020. static inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1021.     int i,j;
  1022.     for (i=0; i < height; i++) {
  1023.       for (j=0; j < width; j++) {
  1024. dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
  1025.       }
  1026.       src += stride;
  1027.       dst += stride;
  1028.     }
  1029. }
  1030. static inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1031.     int i,j;
  1032.     for (i=0; i < height; i++) {
  1033.       for (j=0; j < width; j++) {
  1034. dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
  1035.       }
  1036.       src += stride;
  1037.       dst += stride;
  1038.     }
  1039. }
  1040. static inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1041.     int i,j;
  1042.     for (i=0; i < height; i++) {
  1043.       for (j=0; j < width; j++) {
  1044. dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
  1045.       }
  1046.       src += stride;
  1047.       dst += stride;
  1048.     }
  1049. }
  1050. static inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1051.     int i,j;
  1052.     for (i=0; i < height; i++) {
  1053.       for (j=0; j < width; j++) {
  1054. dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
  1055.       }
  1056.       src += stride;
  1057.       dst += stride;
  1058.     }
  1059. }
  1060. static inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1061.     int i,j;
  1062.     for (i=0; i < height; i++) {
  1063.       for (j=0; j < width; j++) {
  1064. dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
  1065.       }
  1066.       src += stride;
  1067.       dst += stride;
  1068.     }
  1069. }
  1070. static inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1071.     switch(width){
  1072.     case 2: avg_pixels2_c (dst, src, stride, height); break;
  1073.     case 4: avg_pixels4_c (dst, src, stride, height); break;
  1074.     case 8: avg_pixels8_c (dst, src, stride, height); break;
  1075.     case 16:avg_pixels16_c(dst, src, stride, height); break;
  1076.     }
  1077. }
  1078. static inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1079.     int i,j;
  1080.     for (i=0; i < height; i++) {
  1081.       for (j=0; j < width; j++) {
  1082. dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
  1083.       }
  1084.       src += stride;
  1085.       dst += stride;
  1086.     }
  1087. }
  1088. static inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1089.     int i,j;
  1090.     for (i=0; i < height; i++) {
  1091.       for (j=0; j < width; j++) {
  1092. dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
  1093.       }
  1094.       src += stride;
  1095.       dst += stride;
  1096.     }
  1097. }
  1098.     
  1099. static inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1100.     int i,j;
  1101.     for (i=0; i < height; i++) {
  1102.       for (j=0; j < width; j++) {
  1103. dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11) + 1) >> 1;
  1104.       }
  1105.       src += stride;
  1106.       dst += stride;
  1107.     }
  1108. }
  1109.     
  1110. static inline void avg_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1111.     int i,j;
  1112.     for (i=0; i < height; i++) {
  1113.       for (j=0; j < width; j++) {
  1114. dst[j] = (dst[j] + ((2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
  1115.       }
  1116.       src += stride;
  1117.       dst += stride;
  1118.     }
  1119. }
  1120. static inline void avg_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1121.     int i,j;
  1122.     for (i=0; i < height; i++) {
  1123.       for (j=0; j < width; j++) {
  1124. dst[j] = (dst[j] + ((2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
  1125.       }
  1126.       src += stride;
  1127.       dst += stride;
  1128.     }
  1129. }
  1130. static inline void avg_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1131.     int i,j;
  1132.     for (i=0; i < height; i++) {
  1133.       for (j=0; j < width; j++) {
  1134. dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+stride] + 1)) >> 11) + 1) >> 1;
  1135.       }
  1136.       src += stride;
  1137.       dst += stride;
  1138.     }
  1139. }
  1140. static inline void avg_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1141.     int i,j;
  1142.     for (i=0; i < height; i++) {
  1143.       for (j=0; j < width; j++) {
  1144. dst[j] = (dst[j] + ((2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
  1145.       }
  1146.       src += stride;
  1147.       dst += stride;
  1148.     }
  1149. }
  1150. static inline void avg_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
  1151.     int i,j;
  1152.     for (i=0; i < height; i++) {
  1153.       for (j=0; j < width; j++) {
  1154. dst[j] = (dst[j] + ((2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
  1155.       }
  1156.       src += stride;
  1157.       dst += stride;
  1158.     }
  1159. }
  1160. #if 0
  1161. #define TPEL_WIDTH(width)
  1162. static void put_tpel_pixels ## width ## _mc00_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1163.     void put_tpel_pixels_mc00_c(dst, src, stride, width, height);}
  1164. static void put_tpel_pixels ## width ## _mc10_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1165.     void put_tpel_pixels_mc10_c(dst, src, stride, width, height);}
  1166. static void put_tpel_pixels ## width ## _mc20_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1167.     void put_tpel_pixels_mc20_c(dst, src, stride, width, height);}
  1168. static void put_tpel_pixels ## width ## _mc01_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1169.     void put_tpel_pixels_mc01_c(dst, src, stride, width, height);}
  1170. static void put_tpel_pixels ## width ## _mc11_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1171.     void put_tpel_pixels_mc11_c(dst, src, stride, width, height);}
  1172. static void put_tpel_pixels ## width ## _mc21_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1173.     void put_tpel_pixels_mc21_c(dst, src, stride, width, height);}
  1174. static void put_tpel_pixels ## width ## _mc02_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1175.     void put_tpel_pixels_mc02_c(dst, src, stride, width, height);}
  1176. static void put_tpel_pixels ## width ## _mc12_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1177.     void put_tpel_pixels_mc12_c(dst, src, stride, width, height);}
  1178. static void put_tpel_pixels ## width ## _mc22_c(uint8_t *dst, const uint8_t *src, int stride, int height){
  1179.     void put_tpel_pixels_mc22_c(dst, src, stride, width, height);}
  1180. #endif
  1181. #define H264_CHROMA_MC(OPNAME, OP)
  1182. static void OPNAME ## h264_chroma_mc2_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
  1183.     const int A=(8-x)*(8-y);
  1184.     const int B=(  x)*(8-y);
  1185.     const int C=(8-x)*(  y);
  1186.     const int D=(  x)*(  y);
  1187.     int i;
  1188.     
  1189.     assert(x<8 && y<8 && x>=0 && y>=0);
  1191.     for(i=0; i<h; i++)
  1192.     {
  1193.         OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));
  1194.         OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));
  1195.         dst+= stride;
  1196.         src+= stride;
  1197.     }
  1198. }
  1200. static void OPNAME ## h264_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
  1201.     const int A=(8-x)*(8-y);
  1202.     const int B=(  x)*(8-y);
  1203.     const int C=(8-x)*(  y);
  1204.     const int D=(  x)*(  y);
  1205.     int i;
  1206.     
  1207.     assert(x<8 && y<8 && x>=0 && y>=0);
  1209.     for(i=0; i<h; i++)
  1210.     {
  1211.         OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));
  1212.         OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));
  1213.         OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));
  1214.         OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));
  1215.         dst+= stride;
  1216.         src+= stride;
  1217.     }
  1218. }
  1220. static void OPNAME ## h264_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
  1221.     const int A=(8-x)*(8-y);
  1222.     const int B=(  x)*(8-y);
  1223.     const int C=(8-x)*(  y);
  1224.     const int D=(  x)*(  y);
  1225.     int i;
  1226.     
  1227.     assert(x<8 && y<8 && x>=0 && y>=0);
  1229.     for(i=0; i<h; i++)
  1230.     {
  1231.         OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));
  1232.         OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));
  1233.         OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));
  1234.         OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));
  1235.         OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));
  1236.         OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));
  1237.         OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));
  1238.         OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));
  1239.         dst+= stride;
  1240.         src+= stride;
  1241.     }
  1242. }
  1243. #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
  1244. #define op_put(a, b) a = (((b) + 32)>>6)
  1245. H264_CHROMA_MC(put_       , op_put)
  1246. H264_CHROMA_MC(avg_       , op_avg)
  1247. #undef op_avg
  1248. #undef op_put
  1249. static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
  1250. {
  1251.     int i;
  1252.     for(i=0; i<h; i++)
  1253.     {
  1254.         ST32(dst   , LD32(src   ));
  1255.         dst+=dstStride;
  1256.         src+=srcStride;
  1257.     }
  1258. }
  1259. static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
  1260. {
  1261.     int i;
  1262.     for(i=0; i<h; i++)
  1263.     {
  1264.         ST32(dst   , LD32(src   ));
  1265.         ST32(dst+4 , LD32(src+4 ));
  1266.         dst+=dstStride;
  1267.         src+=srcStride;
  1268.     }
  1269. }
  1270. static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
  1271. {
  1272.     int i;
  1273.     for(i=0; i<h; i++)
  1274.     {
  1275.         ST32(dst   , LD32(src   ));
  1276.         ST32(dst+4 , LD32(src+4 ));
  1277.         ST32(dst+8 , LD32(src+8 ));
  1278.         ST32(dst+12, LD32(src+12));
  1279.         dst+=dstStride;
  1280.         src+=srcStride;
  1281.     }
  1282. }
  1283. static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
  1284. {
  1285.     int i;
  1286.     for(i=0; i<h; i++)
  1287.     {
  1288.         ST32(dst   , LD32(src   ));
  1289.         ST32(dst+4 , LD32(src+4 ));
  1290.         ST32(dst+8 , LD32(src+8 ));
  1291.         ST32(dst+12, LD32(src+12));
  1292.         dst[16]= src[16];
  1293.         dst+=dstStride;
  1294.         src+=srcStride;
  1295.     }
  1296. }
  1297. static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
  1298. {
  1299.     int i;
  1300.     for(i=0; i<h; i++)
  1301.     {
  1302.         ST32(dst   , LD32(src   ));
  1303.         ST32(dst+4 , LD32(src+4 ));
  1304.         dst[8]= src[8];
  1305.         dst+=dstStride;
  1306.         src+=srcStride;
  1307.     }
  1308. }
  1309. #define QPEL_MC(r, OPNAME, RND, OP) 
  1310. static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
  1311.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1312.     int i;
  1313.     for(i=0; i<h; i++)
  1314.     {
  1315.         OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));
  1316.         OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));
  1317.         OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));
  1318.         OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));
  1319.         OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));
  1320.         OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));
  1321.         OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));
  1322.         OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));
  1323.         dst+=dstStride;
  1324.         src+=srcStride;
  1325.     }
  1326. }
  1328. static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1329.     const int w=8;
  1330.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1331.     int i;
  1332.     for(i=0; i<w; i++)
  1333.     {
  1334.         const int src0= src[0*srcStride];
  1335.         const int src1= src[1*srcStride];
  1336.         const int src2= src[2*srcStride];
  1337.         const int src3= src[3*srcStride];
  1338.         const int src4= src[4*srcStride];
  1339.         const int src5= src[5*srcStride];
  1340.         const int src6= src[6*srcStride];
  1341.         const int src7= src[7*srcStride];
  1342.         const int src8= src[8*srcStride];
  1343.         OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));
  1344.         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));
  1345.         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));
  1346.         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));
  1347.         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));
  1348.         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));
  1349.         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));
  1350.         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));
  1351.         dst++;
  1352.         src++;
  1353.     }
  1354. }
  1356. static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
  1357.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1358.     int i;
  1359.     
  1360.     for(i=0; i<h; i++)
  1361.     {
  1362.         OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));
  1363.         OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));
  1364.         OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));
  1365.         OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));
  1366.         OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));
  1367.         OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));
  1368.         OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));
  1369.         OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));
  1370.         OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));
  1371.         OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));
  1372.         OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));
  1373.         OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));
  1374.         OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));
  1375.         OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));
  1376.         OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));
  1377.         OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));
  1378.         dst+=dstStride;
  1379.         src+=srcStride;
  1380.     }
  1381. }
  1383. static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1384.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1385.     int i;
  1386.     const int w=16;
  1387.     for(i=0; i<w; i++)
  1388.     {
  1389.         const int src0= src[0*srcStride];
  1390.         const int src1= src[1*srcStride];
  1391.         const int src2= src[2*srcStride];
  1392.         const int src3= src[3*srcStride];
  1393.         const int src4= src[4*srcStride];
  1394.         const int src5= src[5*srcStride];
  1395.         const int src6= src[6*srcStride];
  1396.         const int src7= src[7*srcStride];
  1397.         const int src8= src[8*srcStride];
  1398.         const int src9= src[9*srcStride];
  1399.         const int src10= src[10*srcStride];
  1400.         const int src11= src[11*srcStride];
  1401.         const int src12= src[12*srcStride];
  1402.         const int src13= src[13*srcStride];
  1403.         const int src14= src[14*srcStride];
  1404.         const int src15= src[15*srcStride];
  1405.         const int src16= src[16*srcStride];
  1406.         OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));
  1407.         OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));
  1408.         OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));
  1409.         OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));
  1410.         OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));
  1411.         OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));
  1412.         OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));
  1413.         OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));
  1414.         OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));
  1415.         OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));
  1416.         OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));
  1417.         OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));
  1418.         OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));
  1419.         OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));
  1420.         OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));
  1421.         OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));
  1422.         dst++;
  1423.         src++;
  1424.     }
  1425. }
  1427. static void OPNAME ## qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){
  1428.     OPNAME ## pixels8_c(dst, src, stride, 8);
  1429. }
  1431. static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
  1432.     uint8_t half[64];
  1433.     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);
  1434.     OPNAME ## pixels8_l2(dst, src, half, stride, stride, 8, 8);
  1435. }
  1437. static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
  1438.     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);
  1439. }
  1441. static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
  1442.     uint8_t half[64];
  1443.     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);
  1444.     OPNAME ## pixels8_l2(dst, src+1, half, stride, stride, 8, 8);
  1445. }
  1447. static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){
  1448.     uint8_t full[16*9];
  1449.     uint8_t half[64];
  1450.     copy_block9(full, src, 16, stride, 9);
  1451.     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);
  1452.     OPNAME ## pixels8_l2(dst, full, half, stride, 16, 8, 8);
  1453. }
  1455. static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
  1456.     uint8_t full[16*9];
  1457.     copy_block9(full, src, 16, stride, 9);
  1458.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);
  1459. }
  1461. static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){
  1462.     uint8_t full[16*9];
  1463.     uint8_t half[64];
  1464.     copy_block9(full, src, 16, stride, 9);
  1465.     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);
  1466.     OPNAME ## pixels8_l2(dst, full+16, half, stride, 16, 8, 8);
  1467. }
  1468. void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){
  1469.     uint8_t full[16*9];
  1470.     uint8_t halfH[72];
  1471.     uint8_t halfV[64];
  1472.     uint8_t halfHV[64];
  1473.     copy_block9(full, src, 16, stride, 9);
  1474.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1475.     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);
  1476.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1477.     OPNAME ## pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);
  1478. }
  1479. static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){
  1480.     uint8_t full[16*9];
  1481.     uint8_t halfH[72];
  1482.     uint8_t halfHV[64];
  1483.     copy_block9(full, src, 16, stride, 9);
  1484.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1485.     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);
  1486.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1487.     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);
  1488. }
  1489. void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){
  1490.     uint8_t full[16*9];
  1491.     uint8_t halfH[72];
  1492.     uint8_t halfV[64];
  1493.     uint8_t halfHV[64];
  1494.     copy_block9(full, src, 16, stride, 9);
  1495.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1496.     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);
  1497.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1498.     OPNAME ## pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);
  1499. }
  1500. static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){
  1501.     uint8_t full[16*9];
  1502.     uint8_t halfH[72];
  1503.     uint8_t halfHV[64];
  1504.     copy_block9(full, src, 16, stride, 9);
  1505.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1506.     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);
  1507.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1508.     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);
  1509. }
  1510. void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){
  1511.     uint8_t full[16*9];
  1512.     uint8_t halfH[72];
  1513.     uint8_t halfV[64];
  1514.     uint8_t halfHV[64];
  1515.     copy_block9(full, src, 16, stride, 9);
  1516.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1517.     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);
  1518.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1519.     OPNAME ## pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);
  1520. }
  1521. static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){
  1522.     uint8_t full[16*9];
  1523.     uint8_t halfH[72];
  1524.     uint8_t halfHV[64];
  1525.     copy_block9(full, src, 16, stride, 9);
  1526.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1527.     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);
  1528.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1529.     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);
  1530. }
  1531. void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){
  1532.     uint8_t full[16*9];
  1533.     uint8_t halfH[72];
  1534.     uint8_t halfV[64];
  1535.     uint8_t halfHV[64];
  1536.     copy_block9(full, src, 16, stride, 9);
  1537.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full  , 8, 16, 9);
  1538.     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);
  1539.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1540.     OPNAME ## pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);
  1541. }
  1542. static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){
  1543.     uint8_t full[16*9];
  1544.     uint8_t halfH[72];
  1545.     uint8_t halfHV[64];
  1546.     copy_block9(full, src, 16, stride, 9);
  1547.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1548.     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);
  1549.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1550.     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);
  1551. }
  1552. static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){
  1553.     uint8_t halfH[72];
  1554.     uint8_t halfHV[64];
  1555.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);
  1556.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1557.     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);
  1558. }
  1559. static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){
  1560.     uint8_t halfH[72];
  1561.     uint8_t halfHV[64];
  1562.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);
  1563.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1564.     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);
  1565. }
  1566. void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){
  1567.     uint8_t full[16*9];
  1568.     uint8_t halfH[72];
  1569.     uint8_t halfV[64];
  1570.     uint8_t halfHV[64];
  1571.     copy_block9(full, src, 16, stride, 9);
  1572.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1573.     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);
  1574.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1575.     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
  1576. }
  1577. static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
  1578.     uint8_t full[16*9];
  1579.     uint8_t halfH[72];
  1580.     copy_block9(full, src, 16, stride, 9);
  1581.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1582.     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);
  1583.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);
  1584. }
  1585. void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){
  1586.     uint8_t full[16*9];
  1587.     uint8_t halfH[72];
  1588.     uint8_t halfV[64];
  1589.     uint8_t halfHV[64];
  1590.     copy_block9(full, src, 16, stride, 9);
  1591.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1592.     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);
  1593.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);
  1594.     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
  1595. }
  1596. static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
  1597.     uint8_t full[16*9];
  1598.     uint8_t halfH[72];
  1599.     copy_block9(full, src, 16, stride, 9);
  1600.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);
  1601.     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);
  1602.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);
  1603. }
  1604. static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
  1605.     uint8_t halfH[72];
  1606.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);
  1607.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);
  1608. }
  1609. static void OPNAME ## qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){
  1610.     OPNAME ## pixels16_c(dst, src, stride, 16);
  1611. }
  1613. static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){
  1614.     uint8_t half[256];
  1615.     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);
  1616.     OPNAME ## pixels16_l2(dst, src, half, stride, stride, 16, 16);
  1617. }
  1619. static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){
  1620.     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);
  1621. }
  1623. static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){
  1624.     uint8_t half[256];
  1625.     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);
  1626.     OPNAME ## pixels16_l2(dst, src+1, half, stride, stride, 16, 16);
  1627. }
  1629. static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){
  1630.     uint8_t full[24*17];
  1631.     uint8_t half[256];
  1632.     copy_block17(full, src, 24, stride, 17);
  1633.     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);
  1634.     OPNAME ## pixels16_l2(dst, full, half, stride, 24, 16, 16);
  1635. }
  1637. static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){
  1638.     uint8_t full[24*17];
  1639.     copy_block17(full, src, 24, stride, 17);
  1640.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);
  1641. }
  1643. static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){
  1644.     uint8_t full[24*17];
  1645.     uint8_t half[256];
  1646.     copy_block17(full, src, 24, stride, 17);
  1647.     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);
  1648.     OPNAME ## pixels16_l2(dst, full+24, half, stride, 24, 16, 16);
  1649. }
  1650. void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){
  1651.     uint8_t full[24*17];
  1652.     uint8_t halfH[272];
  1653.     uint8_t halfV[256];
  1654.     uint8_t halfHV[256];
  1655.     copy_block17(full, src, 24, stride, 17);
  1656.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1657.     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);
  1658.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1659.     OPNAME ## pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);
  1660. }
  1661. static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){
  1662.     uint8_t full[24*17];
  1663.     uint8_t halfH[272];
  1664.     uint8_t halfHV[256];
  1665.     copy_block17(full, src, 24, stride, 17);
  1666.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1667.     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);
  1668.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1669.     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);
  1670. }
  1671. void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){
  1672.     uint8_t full[24*17];
  1673.     uint8_t halfH[272];
  1674.     uint8_t halfV[256];
  1675.     uint8_t halfHV[256];
  1676.     copy_block17(full, src, 24, stride, 17);
  1677.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1678.     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);
  1679.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1680.     OPNAME ## pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);
  1681. }
  1682. static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){
  1683.     uint8_t full[24*17];
  1684.     uint8_t halfH[272];
  1685.     uint8_t halfHV[256];
  1686.     copy_block17(full, src, 24, stride, 17);
  1687.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1688.     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);
  1689.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1690.     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);
  1691. }
  1692. void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){
  1693.     uint8_t full[24*17];
  1694.     uint8_t halfH[272];
  1695.     uint8_t halfV[256];
  1696.     uint8_t halfHV[256];
  1697.     copy_block17(full, src, 24, stride, 17);
  1698.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1699.     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);
  1700.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1701.     OPNAME ## pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);
  1702. }
  1703. static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){
  1704.     uint8_t full[24*17];
  1705.     uint8_t halfH[272];
  1706.     uint8_t halfHV[256];
  1707.     copy_block17(full, src, 24, stride, 17);
  1708.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1709.     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);
  1710.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1711.     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);
  1712. }
  1713. void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){
  1714.     uint8_t full[24*17];
  1715.     uint8_t halfH[272];
  1716.     uint8_t halfV[256];
  1717.     uint8_t halfHV[256];
  1718.     copy_block17(full, src, 24, stride, 17);
  1719.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full  , 16, 24, 17);
  1720.     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);
  1721.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1722.     OPNAME ## pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);
  1723. }
  1724. static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){
  1725.     uint8_t full[24*17];
  1726.     uint8_t halfH[272];
  1727.     uint8_t halfHV[256];
  1728.     copy_block17(full, src, 24, stride, 17);
  1729.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1730.     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);
  1731.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1732.     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);
  1733. }
  1734. static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){
  1735.     uint8_t halfH[272];
  1736.     uint8_t halfHV[256];
  1737.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);
  1738.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1739.     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);
  1740. }
  1741. static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){
  1742.     uint8_t halfH[272];
  1743.     uint8_t halfHV[256];
  1744.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);
  1745.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1746.     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);
  1747. }
  1748. void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){
  1749.     uint8_t full[24*17];
  1750.     uint8_t halfH[272];
  1751.     uint8_t halfV[256];
  1752.     uint8_t halfHV[256];
  1753.     copy_block17(full, src, 24, stride, 17);
  1754.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1755.     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);
  1756.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1757.     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);
  1758. }
  1759. static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){
  1760.     uint8_t full[24*17];
  1761.     uint8_t halfH[272];
  1762.     copy_block17(full, src, 24, stride, 17);
  1763.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1764.     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);
  1765.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);
  1766. }
  1767. void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){
  1768.     uint8_t full[24*17];
  1769.     uint8_t halfH[272];
  1770.     uint8_t halfV[256];
  1771.     uint8_t halfHV[256];
  1772.     copy_block17(full, src, 24, stride, 17);
  1773.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1774.     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);
  1775.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);
  1776.     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);
  1777. }
  1778. static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){
  1779.     uint8_t full[24*17];
  1780.     uint8_t halfH[272];
  1781.     copy_block17(full, src, 24, stride, 17);
  1782.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);
  1783.     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);
  1784.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);
  1785. }
  1786. static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){
  1787.     uint8_t halfH[272];
  1788.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);
  1789.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);
  1790. }
  1791. #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
  1792. #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
  1793. #define op_put(a, b) a = cm[((b) + 16)>>5]
  1794. #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
  1795. QPEL_MC(0, put_       , _       , op_put)
  1796. QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
  1797. QPEL_MC(0, avg_       , _       , op_avg)
  1798. //QPEL_MC(1, avg_no_rnd , _       , op_avg)
  1799. #undef op_avg
  1800. #undef op_avg_no_rnd
  1801. #undef op_put
  1802. #undef op_put_no_rnd
  1803. #if 1
  1804. #define H264_LOWPASS(OPNAME, OP, OP2) 
  1805. static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1806.     const int h=4;
  1807.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1808.     int i;
  1809.     for(i=0; i<h; i++)
  1810.     {
  1811.         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));
  1812.         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));
  1813.         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]));
  1814.         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]));
  1815.         dst+=dstStride;
  1816.         src+=srcStride;
  1817.     }
  1818. }
  1820. static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1821.     const int w=4;
  1822.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1823.     int i;
  1824.     for(i=0; i<w; i++)
  1825.     {
  1826.         const int srcB= src[-2*srcStride];
  1827.         const int srcA= src[-1*srcStride];
  1828.         const int src0= src[0 *srcStride];
  1829.         const int src1= src[1 *srcStride];
  1830.         const int src2= src[2 *srcStride];
  1831.         const int src3= src[3 *srcStride];
  1832.         const int src4= src[4 *srcStride];
  1833.         const int src5= src[5 *srcStride];
  1834.         const int src6= src[6 *srcStride];
  1835.         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));
  1836.         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));
  1837.         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));
  1838.         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));
  1839.         dst++;
  1840.         src++;
  1841.     }
  1842. }
  1844. static void OPNAME ## h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){
  1845.     const int h=4;
  1846.     const int w=4;
  1847.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1848.     int i;
  1849.     src -= 2*srcStride;
  1850.     for(i=0; i<h+5; i++)
  1851.     {
  1852.         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);
  1853.         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);
  1854.         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]);
  1855.         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]);
  1856.         tmp+=tmpStride;
  1857.         src+=srcStride;
  1858.     }
  1859.     tmp -= tmpStride*(h+5-2);
  1860.     for(i=0; i<w; i++)
  1861.     {
  1862.         const int tmpB= tmp[-2*tmpStride];
  1863.         const int tmpA= tmp[-1*tmpStride];
  1864.         const int tmp0= tmp[0 *tmpStride];
  1865.         const int tmp1= tmp[1 *tmpStride];
  1866.         const int tmp2= tmp[2 *tmpStride];
  1867.         const int tmp3= tmp[3 *tmpStride];
  1868.         const int tmp4= tmp[4 *tmpStride];
  1869.         const int tmp5= tmp[5 *tmpStride];
  1870.         const int tmp6= tmp[6 *tmpStride];
  1871.         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));
  1872.         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));
  1873.         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));
  1874.         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));
  1875.         dst++;
  1876.         tmp++;
  1877.     }
  1878. }
  1880. static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1881.     const int h=8;
  1882.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1883.     int i;
  1884.     for(i=0; i<h; i++)
  1885.     {
  1886.         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]));
  1887.         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]));
  1888.         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]));
  1889.         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]));
  1890.         OP(dst[4], (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]));
  1891.         OP(dst[5], (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]));
  1892.         OP(dst[6], (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]));
  1893.         OP(dst[7], (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]));
  1894.         dst+=dstStride;
  1895.         src+=srcStride;
  1896.     }
  1897. }
  1899. static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1900.     const int w=8;
  1901.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1902.     int i;
  1903.     for(i=0; i<w; i++)
  1904.     {
  1905.         const int srcB= src[-2*srcStride];
  1906.         const int srcA= src[-1*srcStride];
  1907.         const int src0= src[0 *srcStride];
  1908.         const int src1= src[1 *srcStride];
  1909.         const int src2= src[2 *srcStride];
  1910.         const int src3= src[3 *srcStride];
  1911.         const int src4= src[4 *srcStride];
  1912.         const int src5= src[5 *srcStride];
  1913.         const int src6= src[6 *srcStride];
  1914.         const int src7= src[7 *srcStride];
  1915.         const int src8= src[8 *srcStride];
  1916.         const int src9= src[9 *srcStride];
  1917.         const int src10=src[10*srcStride];
  1918.         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));
  1919.         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));
  1920.         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));
  1921.         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));
  1922.         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));
  1923.         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));
  1924.         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));
  1925.         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));
  1926.         dst++;
  1927.         src++;
  1928.     }
  1929. }
  1931. static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){
  1932.     const int h=8;
  1933.     const int w=8;
  1934.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  1935.     int i;
  1936.     src -= 2*srcStride;
  1937.     for(i=0; i<h+5; i++)
  1938.     {
  1939.         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]);
  1940.         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]);
  1941.         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]);
  1942.         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]);
  1943.         tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]);
  1944.         tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]);
  1945.         tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]);
  1946.         tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]);
  1947.         tmp+=tmpStride;
  1948.         src+=srcStride;
  1949.     }
  1950.     tmp -= tmpStride*(h+5-2);
  1951.     for(i=0; i<w; i++)
  1952.     {
  1953.         const int tmpB= tmp[-2*tmpStride];
  1954.         const int tmpA= tmp[-1*tmpStride];
  1955.         const int tmp0= tmp[0 *tmpStride];
  1956.         const int tmp1= tmp[1 *tmpStride];
  1957.         const int tmp2= tmp[2 *tmpStride];
  1958.         const int tmp3= tmp[3 *tmpStride];
  1959.         const int tmp4= tmp[4 *tmpStride];
  1960.         const int tmp5= tmp[5 *tmpStride];
  1961.         const int tmp6= tmp[6 *tmpStride];
  1962.         const int tmp7= tmp[7 *tmpStride];
  1963.         const int tmp8= tmp[8 *tmpStride];
  1964.         const int tmp9= tmp[9 *tmpStride];
  1965.         const int tmp10=tmp[10*tmpStride];
  1966.         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));
  1967.         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));
  1968.         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));
  1969.         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));
  1970.         OP2(dst[4*dstStride], (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));
  1971.         OP2(dst[5*dstStride], (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));
  1972.         OP2(dst[6*dstStride], (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));
  1973.         OP2(dst[7*dstStride], (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));
  1974.         dst++;
  1975.         tmp++;
  1976.     }
  1977. }
  1979. static void OPNAME ## h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1980.     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);
  1981.     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);
  1982.     src += 8*srcStride;
  1983.     dst += 8*dstStride;
  1984.     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);
  1985.     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);
  1986. }
  1988. static void OPNAME ## h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){
  1989.     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);
  1990.     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);
  1991.     src += 8*srcStride;
  1992.     dst += 8*dstStride;
  1993.     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);
  1994.     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);
  1995. }
  1997. static void OPNAME ## h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){
  1998.     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);
  1999.     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);
  2000.     src += 8*srcStride;
  2001.     tmp += 8*tmpStride;
  2002.     dst += 8*dstStride;
  2003.     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);
  2004.     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);
  2005. }
  2007. #define H264_MC(OPNAME, SIZE) 
  2008. static void OPNAME ## h264_qpel ## SIZE ## _mc00_c (uint8_t *dst, uint8_t *src, int stride){
  2009.     OPNAME ## pixels ## SIZE ## _c(dst, src, stride, SIZE);
  2010. }
  2012. static void OPNAME ## h264_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){
  2013.     uint8_t half[SIZE*SIZE];
  2014.     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);
  2015.     OPNAME ## pixels ## SIZE ## _l2(dst, src, half, stride, stride, SIZE, SIZE);
  2016. }
  2018. static void OPNAME ## h264_qpel ## SIZE ## _mc20_c(uint8_t *dst, uint8_t *src, int stride){
  2019.     OPNAME ## h264_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride);
  2020. }
  2022. static void OPNAME ## h264_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){
  2023.     uint8_t half[SIZE*SIZE];
  2024.     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);
  2025.     OPNAME ## pixels ## SIZE ## _l2(dst, src+1, half, stride, stride, SIZE, SIZE);
  2026. }
  2028. static void OPNAME ## h264_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){
  2029.     uint8_t full[SIZE*(SIZE+5)];
  2030.     uint8_t * const full_mid= full + SIZE*2;
  2031.     uint8_t half[SIZE*SIZE];
  2032.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  2033.     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);
  2034.     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid, half, stride, SIZE, SIZE, SIZE);
  2035. }
  2037. static void OPNAME ## h264_qpel ## SIZE ## _mc02_c(uint8_t *dst, uint8_t *src, int stride){
  2038.     uint8_t full[SIZE*(SIZE+5)];
  2039.     uint8_t * const full_mid= full + SIZE*2;
  2040.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  2041.     OPNAME ## h264_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE);
  2042. }
  2044. static void OPNAME ## h264_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){
  2045.     uint8_t full[SIZE*(SIZE+5)];
  2046.     uint8_t * const full_mid= full + SIZE*2;
  2047.     uint8_t half[SIZE*SIZE];
  2048.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  2049.     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);
  2050.     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid+SIZE, half, stride, SIZE, SIZE, SIZE);
  2051. }
  2053. static void OPNAME ## h264_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){
  2054.     uint8_t full[SIZE*(SIZE+5)];
  2055.     uint8_t * const full_mid= full + SIZE*2;
  2056.     uint8_t halfH[SIZE*SIZE];
  2057.     uint8_t halfV[SIZE*SIZE];
  2058.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);
  2059.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  2060.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  2061.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  2062. }
  2064. static void OPNAME ## h264_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){
  2065.     uint8_t full[SIZE*(SIZE+5)];
  2066.     uint8_t * const full_mid= full + SIZE*2;
  2067.     uint8_t halfH[SIZE*SIZE];
  2068.     uint8_t halfV[SIZE*SIZE];
  2069.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);
  2070.     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);
  2071.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  2072.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  2073. }
  2075. static void OPNAME ## h264_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){
  2076.     uint8_t full[SIZE*(SIZE+5)];
  2077.     uint8_t * const full_mid= full + SIZE*2;
  2078.     uint8_t halfH[SIZE*SIZE];
  2079.     uint8_t halfV[SIZE*SIZE];
  2080.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);
  2081.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  2082.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  2083.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  2084. }
  2086. static void OPNAME ## h264_qpel ## SIZE ## _mc33_c(uint8_t *dst, uint8_t *src, int stride){
  2087.     uint8_t full[SIZE*(SIZE+5)];
  2088.     uint8_t * const full_mid= full + SIZE*2;
  2089.     uint8_t halfH[SIZE*SIZE];
  2090.     uint8_t halfV[SIZE*SIZE];
  2091.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);
  2092.     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);
  2093.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  2094.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);
  2095. }
  2097. static void OPNAME ## h264_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){
  2098.     int16_t tmp[SIZE*(SIZE+5)];
  2099.     OPNAME ## h264_qpel ## SIZE ## _hv_lowpass(dst, tmp, src, stride, SIZE, stride);
  2100. }
  2102. static void OPNAME ## h264_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){
  2103.     int16_t tmp[SIZE*(SIZE+5)];
  2104.     uint8_t halfH[SIZE*SIZE];
  2105.     uint8_t halfHV[SIZE*SIZE];
  2106.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);
  2107.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  2108.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);
  2109. }
  2111. static void OPNAME ## h264_qpel ## SIZE ## _mc23_c(uint8_t *dst, uint8_t *src, int stride){
  2112.     int16_t tmp[SIZE*(SIZE+5)];
  2113.     uint8_t halfH[SIZE*SIZE];
  2114.     uint8_t halfHV[SIZE*SIZE];
  2115.     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);
  2116.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  2117.     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);
  2118. }
  2120. static void OPNAME ## h264_qpel ## SIZE ## _mc12_c(uint8_t *dst, uint8_t *src, int stride){
  2121.     uint8_t full[SIZE*(SIZE+5)];
  2122.     uint8_t * const full_mid= full + SIZE*2;
  2123.     int16_t tmp[SIZE*(SIZE+5)];
  2124.     uint8_t halfV[SIZE*SIZE];
  2125.     uint8_t halfHV[SIZE*SIZE];
  2126.     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);
  2127.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  2128.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  2129.     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);
  2130. }
  2132. static void OPNAME ## h264_qpel ## SIZE ## _mc32_c(uint8_t *dst, uint8_t *src, int stride){
  2133.     uint8_t full[SIZE*(SIZE+5)];
  2134.     uint8_t * const full_mid= full + SIZE*2;
  2135.     int16_t tmp[SIZE*(SIZE+5)];
  2136.     uint8_t halfV[SIZE*SIZE];
  2137.     uint8_t halfHV[SIZE*SIZE];
  2138.     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);
  2139.     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);
  2140.     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);
  2141.     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);
  2142. }
  2144. #define op_avg(a, b)  a = (((a)+cm[((b) + 16)>>5]+1)>>1)
  2145. //#define op_avg2(a, b) a = (((a)*w1+cm[((b) + 16)>>5]*w2 + o + 64)>>7)
  2146. #define op_put(a, b)  a = cm[((b) + 16)>>5]
  2147. #define op2_avg(a, b)  a = (((a)+cm[((b) + 512)>>10]+1)>>1)
  2148. #define op2_put(a, b)  a = cm[((b) + 512)>>10]
  2149. H264_LOWPASS(put_       , op_put, op2_put)
  2150. H264_LOWPASS(avg_       , op_avg, op2_avg)
  2151. H264_MC(put_, 4)
  2152. H264_MC(put_, 8)
  2153. H264_MC(put_, 16)
  2154. H264_MC(avg_, 4)
  2155. H264_MC(avg_, 8)
  2156. H264_MC(avg_, 16)
  2157. #undef op_avg
  2158. #undef op_put
  2159. #undef op2_avg
  2160. #undef op2_put
  2161. #endif
  2162. static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
  2163.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  2164.     int i;
  2165.     for(i=0; i<h; i++){
  2166.         dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
  2167.         dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
  2168.         dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
  2169.         dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
  2170.         dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
  2171.         dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
  2172.         dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
  2173.         dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
  2174.         dst+=dstStride;
  2175.         src+=srcStride;        
  2176.     }
  2177. }
  2178. static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
  2179.     uint8_t *cm = cropTbl + MAX_NEG_CROP;
  2180.     int i;
  2181.     for(i=0; i<w; i++){
  2182.         const int src_1= src[ -srcStride];
  2183.         const int src0 = src[0          ];
  2184.         const int src1 = src[  srcStride];
  2185.         const int src2 = src[2*srcStride];
  2186.         const int src3 = src[3*srcStride];
  2187.         const int src4 = src[4*srcStride];
  2188.         const int src5 = src[5*srcStride];
  2189.         const int src6 = src[6*srcStride];
  2190.         const int src7 = src[7*srcStride];
  2191.         const int src8 = src[8*srcStride];
  2192.         const int src9 = src[9*srcStride];
  2193.         dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
  2194.         dst[1*dstStride]= cm[(9*(src1 + src2) - (src0  + src3) + 8)>>4];
  2195.         dst[2*dstStride]= cm[(9*(src2 + src3) - (src1  + src4) + 8)>>4];
  2196.         dst[3*dstStride]= cm[(9*(src3 + src4) - (src2  + src5) + 8)>>4];
  2197.         dst[4*dstStride]= cm[(9*(src4 + src5) - (src3  + src6) + 8)>>4];
  2198.         dst[5*dstStride]= cm[(9*(src5 + src6) - (src4  + src7) + 8)>>4];
  2199.         dst[6*dstStride]= cm[(9*(src6 + src7) - (src5  + src8) + 8)>>4];
  2200.         dst[7*dstStride]= cm[(9*(src7 + src8) - (src6  + src9) + 8)>>4];
  2201.         src++;
  2202.         dst++;
  2203.     }
  2204. }
  2205. static void put_mspel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){
  2206.     put_pixels8_c(dst, src, stride, 8);
  2207. }
  2208. static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
  2209.     uint8_t half[64];
  2210.     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
  2211.     put_pixels8_l2(dst, src, half, stride, stride, 8, 8);
  2212. }
  2213. static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
  2214.     wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
  2215. }
  2216. static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
  2217.     uint8_t half[64];
  2218.     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
  2219.     put_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);
  2220. }
  2221. static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
  2222.     wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
  2223. }
  2224. static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
  2225.     uint8_t halfH[88];
  2226.     uint8_t halfV[64];
  2227.     uint8_t halfHV[64];
  2228.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
  2229.     wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
  2230.     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
  2231.     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
  2232. }
  2233. static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
  2234.     uint8_t halfH[88];
  2235.     uint8_t halfV[64];
  2236.     uint8_t halfHV[64];
  2237.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
  2238.     wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
  2239.     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
  2240.     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
  2241. }
  2242. static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
  2243.     uint8_t halfH[88];
  2244.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
  2245.     wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
  2246. }
  2247. static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
  2248.     int x;
  2249.     const int strength= ff_h263_loop_filter_strength[qscale];
  2250.     
  2251.     for(x=0; x<8; x++){
  2252.         int d1, d2, ad1;
  2253.         int p0= src[x-2*stride];
  2254.         int p1= src[x-1*stride];
  2255.         int p2= src[x+0*stride];
  2256.         int p3= src[x+1*stride];
  2257.         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
  2258.         if     (d<-2*strength) d1= 0;
  2259.         else if(d<-  strength) d1=-2*strength - d;
  2260.         else if(d<   strength) d1= d;
  2261.         else if(d< 2*strength) d1= 2*strength - d;
  2262.         else                   d1= 0;
  2263.         
  2264.         p1 += d1;
  2265.         p2 -= d1;
  2266.         if(p1&256) p1= ~(p1>>31);
  2267.         if(p2&256) p2= ~(p2>>31);
  2268.         
  2269.         src[x-1*stride] = p1;
  2270.         src[x+0*stride] = p2;
  2271.         ad1= ABS(d1)>>1;
  2272.         
  2273.         d2= clip((p0-p3)/4, -ad1, ad1);
  2274.         
  2275.         src[x-2*stride] = p0 - d2;
  2276.         src[x+  stride] = p3 + d2;
  2277.     }
  2278. }
  2279. static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
  2280.     int y;
  2281.     const int strength= ff_h263_loop_filter_strength[qscale];
  2282.     
  2283.     for(y=0; y<8; y++){
  2284.         int d1, d2, ad1;
  2285.         int p0= src[y*stride-2];
  2286.         int p1= src[y*stride-1];
  2287.         int p2= src[y*stride+0];
  2288.         int p3= src[y*stride+1];
  2289.         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
  2290.         if     (d<-2*strength) d1= 0;
  2291.         else if(d<-  strength) d1=-2*strength - d;
  2292.         else if(d<   strength) d1= d;
  2293.         else if(d< 2*strength) d1= 2*strength - d;
  2294.         else                   d1= 0;
  2295.         
  2296.         p1 += d1;
  2297.         p2 -= d1;
  2298.         if(p1&256) p1= ~(p1>>31);
  2299.         if(p2&256) p2= ~(p2>>31);
  2300.         
  2301.         src[y*stride-1] = p1;
  2302.         src[y*stride+0] = p2;
  2303.         ad1= ABS(d1)>>1;
  2304.         
  2305.         d2= clip((p0-p3)/4, -ad1, ad1);
  2306.         
  2307.         src[y*stride-2] = p0 - d2;
  2308.         src[y*stride+1] = p3 + d2;
  2309.     }
  2310. }
  2311. static void h261_loop_filter_c(uint8_t *src, int stride){
  2312.     int x,y,xy,yz;
  2313.     int temp[64];
  2314.     for(x=0; x<8; x++){
  2315.         temp[x      ] = 4*src[x           ];
  2316.         temp[x + 7*8] = 4*src[x + 7*stride];
  2317.     }
  2318.     for(y=1; y<7; y++){
  2319.         for(x=0; x<8; x++){
  2320.             xy = y * stride + x;
  2321.             yz = y * 8 + x;
  2322.             temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
  2323.         }
  2324.     }
  2325.         
  2326.     for(y=0; y<8; y++){
  2327.         src[  y*stride] = (temp[  y*8] + 2)>>2;
  2328.         src[7+y*stride] = (temp[7+y*8] + 2)>>2;
  2329.         for(x=1; x<7; x++){
  2330.             xy = y * stride + x;
  2331.             yz = y * 8 + x;
  2332.             src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
  2333.         }
  2334.     }
  2335. }
  2336. static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2337. {
  2338.     int s, i;
  2339.     s = 0;
  2340.     for(i=0;i<h;i++) {
  2341.         s += abs(pix1[0] - pix2[0]);
  2342.         s += abs(pix1[1] - pix2[1]);
  2343.         s += abs(pix1[2] - pix2[2]);
  2344.         s += abs(pix1[3] - pix2[3]);
  2345.         s += abs(pix1[4] - pix2[4]);
  2346.         s += abs(pix1[5] - pix2[5]);
  2347.         s += abs(pix1[6] - pix2[6]);
  2348.         s += abs(pix1[7] - pix2[7]);
  2349.         s += abs(pix1[8] - pix2[8]);
  2350.         s += abs(pix1[9] - pix2[9]);
  2351.         s += abs(pix1[10] - pix2[10]);
  2352.         s += abs(pix1[11] - pix2[11]);
  2353.         s += abs(pix1[12] - pix2[12]);
  2354.         s += abs(pix1[13] - pix2[13]);
  2355.         s += abs(pix1[14] - pix2[14]);
  2356.         s += abs(pix1[15] - pix2[15]);
  2357.         pix1 += line_size;
  2358.         pix2 += line_size;
  2359.     }
  2360.     return s;
  2361. }
  2362. static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2363. {
  2364.     int s, i;
  2365.     s = 0;
  2366.     for(i=0;i<h;i++) {
  2367.         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
  2368.         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
  2369.         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
  2370.         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
  2371.         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
  2372.         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
  2373.         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
  2374.         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
  2375.         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
  2376.         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
  2377.         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
  2378.         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
  2379.         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
  2380.         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
  2381.         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
  2382.         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
  2383.         pix1 += line_size;
  2384.         pix2 += line_size;
  2385.     }
  2386.     return s;
  2387. }
  2388. static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2389. {
  2390.     int s, i;
  2391.     uint8_t *pix3 = pix2 + line_size;
  2392.     s = 0;
  2393.     for(i=0;i<h;i++) {
  2394.         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
  2395.         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
  2396.         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
  2397.         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
  2398.         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
  2399.         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
  2400.         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
  2401.         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
  2402.         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
  2403.         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
  2404.         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
  2405.         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
  2406.         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
  2407.         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
  2408.         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
  2409.         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
  2410.         pix1 += line_size;
  2411.         pix2 += line_size;
  2412.         pix3 += line_size;
  2413.     }
  2414.     return s;
  2415. }
  2416. static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2417. {
  2418.     int s, i;
  2419.     uint8_t *pix3 = pix2 + line_size;
  2420.     s = 0;
  2421.     for(i=0;i<h;i++) {
  2422.         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
  2423.         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
  2424.         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
  2425.         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
  2426.         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
  2427.         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
  2428.         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
  2429.         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
  2430.         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
  2431.         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
  2432.         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
  2433.         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
  2434.         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
  2435.         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
  2436.         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
  2437.         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
  2438.         pix1 += line_size;
  2439.         pix2 += line_size;
  2440.         pix3 += line_size;
  2441.     }
  2442.     return s;
  2443. }
  2444. static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2445. {
  2446.     int s, i;
  2447.     s = 0;
  2448.     for(i=0;i<h;i++) {
  2449.         s += abs(pix1[0] - pix2[0]);
  2450.         s += abs(pix1[1] - pix2[1]);
  2451.         s += abs(pix1[2] - pix2[2]);
  2452.         s += abs(pix1[3] - pix2[3]);
  2453.         s += abs(pix1[4] - pix2[4]);
  2454.         s += abs(pix1[5] - pix2[5]);
  2455.         s += abs(pix1[6] - pix2[6]);
  2456.         s += abs(pix1[7] - pix2[7]);
  2457.         pix1 += line_size;
  2458.         pix2 += line_size;
  2459.     }
  2460.     return s;
  2461. }
  2462. static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2463. {
  2464.     int s, i;
  2465.     s = 0;
  2466.     for(i=0;i<h;i++) {
  2467.         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
  2468.         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
  2469.         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
  2470.         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
  2471.         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
  2472.         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
  2473.         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
  2474.         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
  2475.         pix1 += line_size;
  2476.         pix2 += line_size;
  2477.     }
  2478.     return s;
  2479. }
  2480. static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2481. {
  2482.     int s, i;
  2483.     uint8_t *pix3 = pix2 + line_size;
  2484.     s = 0;
  2485.     for(i=0;i<h;i++) {
  2486.         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
  2487.         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
  2488.         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
  2489.         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
  2490.         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
  2491.         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
  2492.         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
  2493.         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
  2494.         pix1 += line_size;
  2495.         pix2 += line_size;
  2496.         pix3 += line_size;
  2497.     }
  2498.     return s;
  2499. }
  2500. static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
  2501. {
  2502.     int s, i;
  2503.     uint8_t *pix3 = pix2 + line_size;
  2504.     s = 0;
  2505.     for(i=0;i<h;i++) {
  2506.         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
  2507.         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
  2508.         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
  2509.         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
  2510.         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
  2511.         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
  2512.         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
  2513.         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
  2514.         pix1 += line_size;
  2515.         pix2 += line_size;
  2516.         pix3 += line_size;
  2517.     }
  2518.     return s;
  2519. }
  2520. static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h){
  2521.     int score1=0;
  2522.     int score2=0;
  2523.     int x,y;
  2524.     for(y=0; y<h; y++){
  2525.         for(x=0; x<16; x++){
  2526.             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
  2527.         }
  2528.         if(y+1<h){
  2529.             for(x=0; x<15; x++){
  2530.                 score2+= ABS(  s1[x  ] - s1[x  +stride]
  2531.                              - s1[x+1] + s1[x+1+stride])
  2532.                         -ABS(  s2[x  ] - s2[x  +stride]
  2533.                              - s2[x+1] + s2[x+1+stride]);
  2534.             }
  2535.         }
  2536.         s1+= stride;
  2537.         s2+= stride;
  2538.     }
  2539.     if(c) return score1 + ABS(score2)*c->avctx->nsse_weight;
  2540.     else  return score1 + ABS(score2)*8;
  2541. }
  2542. static int nsse8_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h){
  2543.     int score1=0;
  2544.     int score2=0;
  2545.     int x,y;
  2546.     
  2547.     for(y=0; y<h; y++){
  2548.         for(x=0; x<8; x++){
  2549.             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
  2550.         }
  2551.         if(y+1<h){
  2552.             for(x=0; x<7; x++){
  2553.                 score2+= ABS(  s1[x  ] - s1[x  +stride]
  2554.                              - s1[x+1] + s1[x+1+stride])
  2555.                         -ABS(  s2[x  ] - s2[x  +stride]
  2556.                              - s2[x+1] + s2[x+1+stride]);
  2557.             }
  2558.         }
  2559.         s1+= stride;
  2560.         s2+= stride;
  2561.     }
  2562.     
  2563.     if(c) return score1 + ABS(score2)*c->avctx->nsse_weight;
  2564.     else  return score1 + ABS(score2)*8;
  2565. }
  2566. static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
  2567.     int i;
  2568.     unsigned int sum=0;
  2569.     for(i=0; i<8*8; i++){
  2570.         int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
  2571.         int w= weight[i];
  2572.         b>>= RECON_SHIFT;
  2573.         assert(-512<b && b<512);
  2574.         sum += (w*b)*(w*b)>>4;
  2575.     }
  2576.     return sum>>2;
  2577. }
  2578. static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
  2579.     int i;
  2580.     for(i=0; i<8*8; i++){
  2581.         rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
  2582.     }    
  2583. }
  2584. /**
  2585.  * permutes an 8x8 block.
  2586.  * @param block the block which will be permuted according to the given permutation vector
  2587.  * @param permutation the permutation vector
  2588.  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
  2589.  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not 
  2590.  *                  (inverse) permutated to scantable order!
  2591.  */
  2592. void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
  2593. {
  2594.     int i;
  2595.     DCTELEM temp[64];
  2596.     
  2597.     if(last<=0) return;
  2598.     //if(permutation[1]==1) return; //FIXME its ok but not clean and might fail for some perms
  2599.     for(i=0; i<=last; i++){
  2600.         const int j= scantable[i];
  2601.         temp[j]= block[j];
  2602.         block[j]=0;
  2603.     }
  2604.     
  2605.     for(i=0; i<=last; i++){
  2606.         const int j= scantable[i];
  2607.         const int perm_j= permutation[j];
  2608.         block[perm_j]= temp[j];
  2609.     }
  2610. }
  2611. static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
  2612.     return 0;
  2613. }
  2614. void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
  2615.     int i;
  2616.     
  2617.     memset(cmp, 0, sizeof(void*)*5);
  2618.         
  2619.     for(i=0; i<5; i++){
  2620.         switch(type&0xFF){
  2621.         case FF_CMP_SAD:
  2622.             cmp[i]= c->sad[i];
  2623.             break;
  2624.         case FF_CMP_SATD:
  2625.             cmp[i]= c->hadamard8_diff[i];
  2626.             break;
  2627.         case FF_CMP_SSE:
  2628.             cmp[i]= c->sse[i];
  2629.             break;
  2630.         case FF_CMP_DCT:
  2631.             cmp[i]= c->dct_sad[i];
  2632.             break;
  2633.         case FF_CMP_PSNR:
  2634.             cmp[i]= c->quant_psnr[i];
  2635.             break;
  2636.         case FF_CMP_BIT:
  2637.             cmp[i]= c->bit[i];
  2638.             break;
  2639.         case FF_CMP_RD:
  2640.             cmp[i]= c->rd[i];
  2641.             break;
  2642.         case FF_CMP_VSAD:
  2643.             cmp[i]= c->vsad[i];
  2644.             break;
  2645.         case FF_CMP_VSSE:
  2646.             cmp[i]= c->vsse[i];
  2647.             break;
  2648.         case FF_CMP_ZERO:
  2649.             cmp[i]= zero_cmp;
  2650.             break;
  2651.         case FF_CMP_NSSE:
  2652.             cmp[i]= c->nsse[i];
  2653.             break;
  2654.         default:
  2655.             av_log(NULL, AV_LOG_ERROR,"internal error in cmp function selectionn");
  2656.         }
  2657.     }
  2658. }
  2659. /**
  2660.  * memset(blocks, 0, sizeof(DCTELEM)*6*64)
  2661.  */
  2662. static void clear_blocks_c(DCTELEM *blocks)
  2663. {
  2664.     memset(blocks, 0, sizeof(DCTELEM)*6*64);
  2665. }
  2666. static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
  2667.     int i;
  2668.     for(i=0; i+7<w; i+=8){
  2669.         dst[i+0] += src[i+0];
  2670.         dst[i+1] += src[i+1];
  2671.         dst[i+2] += src[i+2];
  2672.         dst[i+3] += src[i+3];
  2673.         dst[i+4] += src[i+4];
  2674.         dst[i+5] += src[i+5];
  2675.         dst[i+6] += src[i+6];
  2676.         dst[i+7] += src[i+7];
  2677.     }
  2678.     for(; i<w; i++)
  2679.         dst[i+0] += src[i+0];
  2680. }
  2681. static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
  2682.     int i;
  2683.     for(i=0; i+7<w; i+=8){
  2684.         dst[i+0] = src1[i+0]-src2[i+0];
  2685.         dst[i+1] = src1[i+1]-src2[i+1];
  2686.         dst[i+2] = src1[i+2]-src2[i+2];
  2687.         dst[i+3] = src1[i+3]-src2[i+3];
  2688.         dst[i+4] = src1[i+4]-src2[i+4];
  2689.         dst[i+5] = src1[i+5]-src2[i+5];
  2690.         dst[i+6] = src1[i+6]-src2[i+6];
  2691.         dst[i+7] = src1[i+7]-src2[i+7];
  2692.     }
  2693.     for(; i<w; i++)
  2694.         dst[i+0] = src1[i+0]-src2[i+0];
  2695. }
  2696. static void sub_hfyu_median_prediction_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top){
  2697.     int i;
  2698.     uint8_t l, lt;
  2699.     l= *left;
  2700.     lt= *left_top;
  2701.     for(i=0; i<w; i++){
  2702.         const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
  2703.         lt= src1[i];
  2704.         l= src2[i];
  2705.         dst[i]= l - pred;
  2706.     }    
  2707.     *left= l;
  2708.     *left_top= lt;
  2709. }
  2710. #define BUTTERFLY2(o1,o2,i1,i2) 
  2711. o1= (i1)+(i2);
  2712. o2= (i1)-(i2);
  2713. #define BUTTERFLY1(x,y) 
  2714. {
  2715.     int a,b;
  2716.     a= x;
  2717.     b= y;
  2718.     x= a+b;
  2719.     y= a-b;
  2720. }
  2721. #define BUTTERFLYA(x,y) (ABS((x)+(y)) + ABS((x)-(y)))
  2722. static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
  2723.     int i;
  2724.     int temp[64];
  2725.     int sum=0;
  2726.     
  2727.     assert(h==8);
  2728.     for(i=0; i<8; i++){
  2729.         //FIXME try pointer walks
  2730.         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0]-dst[stride*i+0],src[stride*i+1]-dst[stride*i+1]);
  2731.         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2]-dst[stride*i+2],src[stride*i+3]-dst[stride*i+3]);
  2732.         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4]-dst[stride*i+4],src[stride*i+5]-dst[stride*i+5]);
  2733.         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6]-dst[stride*i+6],src[stride*i+7]-dst[stride*i+7]);
  2734.         
  2735.         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
  2736.         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
  2737.         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
  2738.         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
  2739.         
  2740.         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
  2741.         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
  2742.         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
  2743.         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
  2744.     }
  2745.     for(i=0; i<8; i++){
  2746.         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
  2747.         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
  2748.         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
  2749.         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
  2750.         
  2751.         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
  2752.         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
  2753.         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
  2754.         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
  2755.         sum += 
  2756.              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
  2757.             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
  2758.             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
  2759.             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
  2760.     }
  2761. #if 0
  2762. static int maxi=0;
  2763. if(sum>maxi){
  2764.     maxi=sum;
  2765.     printf("MAX:%dn", maxi);
  2766. }
  2767. #endif
  2768.     return sum;
  2769. }
  2770. static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
  2771.     int i;
  2772.     int temp[64];
  2773.     int sum=0;
  2774.     
  2775.     assert(h==8);
  2776.     
  2777.     for(i=0; i<8; i++){
  2778.         //FIXME try pointer walks
  2779.         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
  2780.         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
  2781.         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
  2782.         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
  2783.         
  2784.         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
  2785.         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
  2786.         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
  2787.         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
  2788.         
  2789.         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
  2790.         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
  2791.         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
  2792.         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
  2793.     }
  2794.     for(i=0; i<8; i++){
  2795.         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
  2796.         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
  2797.         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
  2798.         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
  2799.         
  2800.         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
  2801.         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
  2802.         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
  2803.         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
  2804.     
  2805.         sum += 
  2806.              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
  2807.             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
  2808.             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
  2809.             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
  2810.     }
  2811.     
  2812.     sum -= ABS(temp[8*0] + temp[8*4]); // -mean
  2813.     
  2814.     return sum;
  2815. }
  2816. static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  2817.     MpegEncContext * const s= (MpegEncContext *)c;
  2818.     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];
  2819.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  2820.     int sum=0, i;
  2821.     
  2822.     assert(h==8);
  2823.     s->dsp.diff_pixels(temp, src1, src2, stride);
  2824.     s->dsp.fdct(temp);
  2825.     for(i=0; i<64; i++)
  2826.         sum+= ABS(temp[i]);
  2827.         
  2828.     return sum;
  2829. }
  2830. void simple_idct(DCTELEM *block); //FIXME
  2831. static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  2832.     MpegEncContext * const s= (MpegEncContext *)c;
  2833.     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64*2/8];
  2834.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  2835.     DCTELEM * const bak = ((DCTELEM*)aligned_temp)+64;
  2836.     int sum=0, i;
  2837.     assert(h==8);
  2838.     s->mb_intra=0;
  2839.     
  2840.     s->dsp.diff_pixels(temp, src1, src2, stride);
  2841.     
  2842.     memcpy(bak, temp, 64*sizeof(DCTELEM));
  2843.     
  2844.     s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
  2845.     s->dct_unquantize_inter(s, temp, 0, s->qscale);
  2846.     simple_idct(temp); //FIXME 
  2847.     
  2848.     for(i=0; i<64; i++)
  2849.         sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
  2850.         
  2851.     return sum;
  2852. }
  2853. static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  2854.     MpegEncContext * const s= (MpegEncContext *)c;
  2855.     const uint8_t *scantable= s->intra_scantable.permutated;
  2856.     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];
  2857. //    uint64_t __align8 aligned_bak[stride];
  2858.     uint64_t __align8 aligned_bak[128];
  2859.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  2860.     uint8_t * const bak= (uint8_t*)aligned_bak;
  2861.     int i, last, run, bits, level, distoration, start_i;
  2862.     const int esc_length= s->ac_esc_length;
  2863.     uint8_t * length;
  2864.     uint8_t * last_length;
  2865.     
  2866.     assert(h==8);
  2867.     for(i=0; i<8; i++){
  2868.         ((uint32_t*)(bak + i*stride))[0]= ((uint32_t*)(src2 + i*stride))[0];
  2869.         ((uint32_t*)(bak + i*stride))[1]= ((uint32_t*)(src2 + i*stride))[1];
  2870.     }
  2871.     s->dsp.diff_pixels(temp, src1, src2, stride);
  2872.     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
  2873.     bits=0;
  2874.     
  2875.     if (s->mb_intra) {
  2876.         start_i = 1; 
  2877.         length     = s->intra_ac_vlc_length;
  2878.         last_length= s->intra_ac_vlc_last_length;
  2879.         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
  2880.     } else {
  2881.         start_i = 0;
  2882.         length     = s->inter_ac_vlc_length;
  2883.         last_length= s->inter_ac_vlc_last_length;
  2884.     }
  2885.     
  2886.     if(last>=start_i){
  2887.         run=0;
  2888.         for(i=start_i; i<last; i++){
  2889.             int j= scantable[i];
  2890.             level= temp[j];
  2891.         
  2892.             if(level){
  2893.                 level+=64;
  2894.                 if((level&(~127)) == 0){
  2895.                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
  2896.                 }else
  2897.                     bits+= esc_length;
  2898.                 run=0;
  2899.             }else
  2900.                 run++;
  2901.         }
  2902.         i= scantable[last];
  2903.        
  2904.         level= temp[i] + 64;
  2905.         assert(level - 64);
  2906.         
  2907.         if((level&(~127)) == 0){
  2908.             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
  2909.         }else
  2910.             bits+= esc_length;
  2911.     
  2912.     }
  2913.     if(last>=0){
  2914.         if(s->mb_intra)
  2915.             s->dct_unquantize_intra(s, temp, 0, s->qscale);
  2916.         else
  2917.             s->dct_unquantize_inter(s, temp, 0, s->qscale);
  2918.     }
  2919.     
  2920.     s->dsp.idct_add(bak, stride, temp);
  2921.     
  2922.     distoration= s->dsp.sse[1](NULL, bak, src1, stride, 8);
  2923.     return distoration + ((bits*s->qscale*s->qscale*109 + 64)>>7);
  2924. }
  2925. static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
  2926.     MpegEncContext * const s= (MpegEncContext *)c;
  2927.     const uint8_t *scantable= s->intra_scantable.permutated;
  2928.     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];
  2929.     DCTELEM * const temp= (DCTELEM*)aligned_temp;
  2930.     int i, last, run, bits, level, start_i;
  2931.     const int esc_length= s->ac_esc_length;
  2932.     uint8_t * length;
  2933.     uint8_t * last_length;
  2934.     assert(h==8);
  2935.     
  2936.     s->dsp.diff_pixels(temp, src1, src2, stride);
  2937.     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
  2938.     bits=0;
  2939.     
  2940.     if (s->mb_intra) {
  2941.         start_i = 1; 
  2942.         length     = s->intra_ac_vlc_length;
  2943.         last_length= s->intra_ac_vlc_last_length;
  2944.         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
  2945.     } else {
  2946.         start_i = 0;
  2947.         length     = s->inter_ac_vlc_length;
  2948.         last_length= s->inter_ac_vlc_last_length;
  2949.     }
  2950.     
  2951.     if(last>=start_i){
  2952.         run=0;
  2953.         for(i=start_i; i<last; i++){
  2954.             int j= scantable[i];
  2955.             level= temp[j];
  2956.         
  2957.             if(level){
  2958.                 level+=64;
  2959.                 if((level&(~127)) == 0){
  2960.                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
  2961.                 }else
  2962.                     bits+= esc_length;
  2963.                 run=0;
  2964.             }else
  2965.                 run++;
  2966.         }
  2967.         i= scantable[last];
  2968.                 
  2969.         level= temp[i] + 64;
  2970.         
  2971.         assert(level - 64);
  2972.         
  2973.         if((level&(~127)) == 0){
  2974.             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
  2975.         }else
  2976.             bits+= esc_length;
  2977.     }
  2978.     return bits;
  2979. }
  2980. static int vsad_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
  2981.     int score=0;
  2982.     int x,y;
  2983.     
  2984.     for(y=1; y<h; y++){
  2985.         for(x=0; x<16; x+=4){
  2986.             score+= ABS(s[x  ] - s[x  +stride]) + ABS(s[x+1] - s[x+1+stride]) 
  2987.                    +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
  2988.         }
  2989.         s+= stride;
  2990.     }
  2991.     
  2992.     return score;
  2993. }
  2994. static int vsad16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
  2995.     int score=0;
  2996.     int x,y;
  2997.     
  2998.     for(y=1; y<h; y++){
  2999.         for(x=0; x<16; x++){
  3000.             score+= ABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
  3001.         }
  3002.         s1+= stride;
  3003.         s2+= stride;
  3004.     }
  3005.     
  3006.     return score;
  3007. }
  3008. #define SQ(a) ((a)*(a))
  3009. static int vsse_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
  3010.     int score=0;
  3011.     int x,y;
  3012.     
  3013.     for(y=1; y<h; y++){
  3014.         for(x=0; x<16; x+=4){
  3015.             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride]) 
  3016.                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
  3017.         }
  3018.         s+= stride;
  3019.     }
  3020.     
  3021.     return score;
  3022. }
  3023. static int vsse16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
  3024.     int score=0;
  3025.     int x,y;
  3026.     
  3027.     for(y=1; y<h; y++){
  3028.         for(x=0; x<16; x++){
  3029.             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
  3030.         }
  3031.         s1+= stride;
  3032.         s2+= stride;
  3033.     }
  3034.     
  3035.     return score;
  3036. }
  3037. WARPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
  3038. WARPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
  3039. WARPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
  3040. WARPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
  3041. WARPER8_16_SQ(rd8x8_c, rd16_c)
  3042. WARPER8_16_SQ(bit8x8_c, bit16_c)
  3043. /* XXX: those functions should be suppressed ASAP when all IDCTs are
  3044.  converted */
  3045. static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
  3046. {
  3047.     j_rev_dct (block);
  3048.     put_pixels_clamped_c(block, dest, line_size);
  3049. }
  3050. static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
  3051. {
  3052.     j_rev_dct (block);
  3053.     add_pixels_clamped_c(block, dest, line_size);
  3054. }
  3055. /* init static data */
  3056. void dsputil_static_init(void)
  3057. {
  3058.     int i;
  3059.     for(i=0;i<256;i++) cropTbl[i + MAX_NEG_CROP] = i;
  3060.     for(i=0;i<MAX_NEG_CROP;i++) {
  3061.         cropTbl[i] = 0;
  3062.         cropTbl[i + MAX_NEG_CROP + 256] = 255;
  3063.     }
  3064.     
  3065.     for(i=0;i<512;i++) {
  3066.         squareTbl[i] = (i - 256) * (i - 256);
  3067.     }
  3068.     
  3069.     for(i=0; i<64; i++) inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
  3070. }
  3071. void dsputil_init(DSPContext* c, AVCodecContext *avctx)
  3072. {
  3073.     int i;
  3074. #ifdef CONFIG_ENCODERS
  3075.     if(avctx->dct_algo==FF_DCT_FASTINT) {
  3076.         c->fdct = fdct_ifast;
  3077. c->fdct248 = fdct_ifast248;
  3078.     } 
  3079.     else if(avctx->dct_algo==FF_DCT_FAAN) {
  3080.         c->fdct = ff_faandct;
  3081. c->fdct248 = ff_faandct248; 
  3082.     } 
  3083.     else {
  3084.         c->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
  3085. c->fdct248 = ff_fdct248_islow;
  3086.     }
  3087. #endif //CONFIG_ENCODERS
  3088.     if(avctx->idct_algo==FF_IDCT_INT){
  3089.         c->idct_put= ff_jref_idct_put;
  3090.         c->idct_add= ff_jref_idct_add;
  3091.         c->idct    = j_rev_dct;
  3092.         c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
  3093.     }else{ //accurate/default
  3094.         c->idct_put= simple_idct_put;
  3095.         c->idct_add= simple_idct_add;
  3096.         c->idct    = simple_idct;
  3097.         c->idct_permutation_type= FF_NO_IDCT_PERM;
  3098.     }
  3099.     // VP3 DSP support 
  3100.     c->vp3_dsp_init = vp3_dsp_init_c;
  3101.     c->vp3_idct = vp3_idct_c;
  3102.     c->get_pixels = get_pixels_c;
  3103.     c->diff_pixels = diff_pixels_c;
  3104.     c->put_pixels_clamped = put_pixels_clamped_c;
  3105.     c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
  3106.     c->add_pixels_clamped = add_pixels_clamped_c;
  3107.     c->gmc1 = gmc1_c;
  3108.     c->gmc = gmc_c;
  3109.     c->clear_blocks = clear_blocks_c;
  3110.     c->pix_sum = pix_sum_c;
  3111.     c->pix_norm1 = pix_norm1_c;
  3112.     // TODO [0] 16  [1] 8 
  3113.     c->pix_abs[0][0] = pix_abs16_c;
  3114.     c->pix_abs[0][1] = pix_abs16_x2_c;
  3115.     c->pix_abs[0][2] = pix_abs16_y2_c;
  3116.     c->pix_abs[0][3] = pix_abs16_xy2_c;
  3117.     c->pix_abs[1][0] = pix_abs8_c;
  3118.     c->pix_abs[1][1] = pix_abs8_x2_c;
  3119.     c->pix_abs[1][2] = pix_abs8_y2_c;
  3120.     c->pix_abs[1][3] = pix_abs8_xy2_c;
  3121. #define dspfunc(PFX, IDX, NUM) 
  3122.     c->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## NUM ## _c;     
  3123.     c->PFX ## _pixels_tab[IDX][1] = PFX ## _pixels ## NUM ## _x2_c;  
  3124.     c->PFX ## _pixels_tab[IDX][2] = PFX ## _pixels ## NUM ## _y2_c;  
  3125.     c->PFX ## _pixels_tab[IDX][3] = PFX ## _pixels ## NUM ## _xy2_c
  3126.     dspfunc(put, 0, 16);
  3127.     dspfunc(put_no_rnd, 0, 16);
  3128.     dspfunc(put, 1, 8);
  3129.     dspfunc(put_no_rnd, 1, 8);
  3130.     dspfunc(put, 2, 4);
  3131.     dspfunc(put, 3, 2);
  3132.     dspfunc(avg, 0, 16);
  3133.     dspfunc(avg_no_rnd, 0, 16);
  3134.     dspfunc(avg, 1, 8);
  3135.     dspfunc(avg_no_rnd, 1, 8);
  3136.     dspfunc(avg, 2, 4);
  3137.     dspfunc(avg, 3, 2);/**/
  3138. #undef dspfunc
  3139.     c->put_no_rnd_pixels_l2[0]= put_no_rnd_pixels16_l2_c;
  3140.     c->put_no_rnd_pixels_l2[1]= put_no_rnd_pixels8_l2_c;
  3141.     c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
  3142.     c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
  3143.     c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
  3144.     c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
  3145.     c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
  3146.     c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
  3147.     c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
  3148.     c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
  3149.     c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
  3150.     c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
  3151.     c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
  3152.     c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
  3153.     c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
  3154.     c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
  3155.     c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
  3156.     c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
  3157.     c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
  3158.     c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
  3159. #define dspfunc(PFX, IDX, NUM) 
  3160.     c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; 
  3161.     c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; 
  3162.     c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; 
  3163.     c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; 
  3164.     c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; 
  3165.     c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; 
  3166.     c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; 
  3167.     c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; 
  3168.     c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; 
  3169.     c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; 
  3170.     c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; 
  3171.     c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; 
  3172.     c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; 
  3173.     c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; 
  3174.     c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; 
  3175.     c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
  3176.     dspfunc(put_qpel, 0, 16);
  3177.     dspfunc(put_no_rnd_qpel, 0, 16);
  3178.     dspfunc(avg_qpel, 0, 16);
  3179.     // dspfunc(avg_no_rnd_qpel, 0, 16); 
  3180.     dspfunc(put_qpel, 1, 8);
  3181.     dspfunc(put_no_rnd_qpel, 1, 8);
  3182.     dspfunc(avg_qpel, 1, 8);
  3183.     // dspfunc(avg_no_rnd_qpel, 1, 8); 
  3184.     dspfunc(put_h264_qpel, 0, 16);
  3185.     dspfunc(put_h264_qpel, 1, 8);
  3186.     dspfunc(put_h264_qpel, 2, 4);
  3187.     dspfunc(avg_h264_qpel, 0, 16);
  3188.     dspfunc(avg_h264_qpel, 1, 8);
  3189.     dspfunc(avg_h264_qpel, 2, 4);
  3190. #undef dspfunc
  3191.     c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_c;
  3192.     c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_c;
  3193.     c->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_c;
  3194.     c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_c;
  3195.     c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_c;
  3196.     c->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_c;
  3197.     c->put_mspel_pixels_tab[0]= put_mspel8_mc00_c;
  3198.     c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
  3199.     c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
  3200.     c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
  3201.     c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
  3202.     c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
  3203.     c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
  3204.     c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
  3205. /**/        
  3206. #define SET_CMP_FUNC(name) 
  3207.     c->name[0]= name ## 16_c;
  3208.     c->name[1]= name ## 8x8_c;
  3209.     
  3210.     SET_CMP_FUNC(hadamard8_diff)
  3211.     c->hadamard8_diff[4]= hadamard8_intra16_c;
  3212.     SET_CMP_FUNC(dct_sad)
  3213.     c->sad[0]= pix_abs16_c;
  3214.     c->sad[1]= pix_abs8_c;
  3215.     c->sse[0]= sse16_c;
  3216.     c->sse[1]= sse8_c;
  3217.     SET_CMP_FUNC(quant_psnr)
  3218.     SET_CMP_FUNC(rd)
  3219.     SET_CMP_FUNC(bit)
  3220.     c->vsad[0]= vsad16_c;
  3221.     c->vsad[4]= vsad_intra16_c;
  3222.     c->vsse[0]= vsse16_c;
  3223.     c->vsse[4]= vsse_intra16_c;
  3224.     c->nsse[0]= nsse16_c;
  3225.     c->nsse[1]= nsse8_c;
  3226.         
  3227.     c->add_bytes= add_bytes_c;
  3228.     c->diff_bytes= diff_bytes_c;
  3229.     c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;
  3230.     c->bswap_buf= bswap_buf;
  3231.     
  3232.     c->h263_h_loop_filter= h263_h_loop_filter_c;
  3233.     c->h263_v_loop_filter= h263_v_loop_filter_c;
  3234.     
  3235.     c->h261_loop_filter= h261_loop_filter_c;
  3236.     
  3237.     c->try_8x8basis= try_8x8basis_c;
  3238.     c->add_8x8basis= add_8x8basis_c;
  3239. #ifdef HAVE_MMX
  3240.     dsputil_init_mmx(c, avctx);
  3241. #endif
  3242. #ifdef ARCH_ARMV4L
  3243.     dsputil_init_armv4l(c, avctx);
  3244. #endif
  3245. #ifdef HAVE_MLIB
  3246.     dsputil_init_mlib(c, avctx);
  3247. #endif
  3248. #ifdef ARCH_SPARC
  3249.    dsputil_init_vis(c,avctx);
  3250. #endif
  3251. #ifdef ARCH_ALPHA
  3252.     dsputil_init_alpha(c, avctx);
  3253. #endif
  3254. #ifdef ARCH_POWERPC
  3255.     dsputil_init_ppc(c, avctx);
  3256. #endif
  3257. #ifdef HAVE_MMI
  3258.     dsputil_init_mmi(c, avctx);
  3259. #endif
  3260. #ifdef ARCH_SH4
  3261.     dsputil_init_sh4(c,avctx);
  3262. #endif
  3263.     switch(c->idct_permutation_type){
  3264.     case FF_NO_IDCT_PERM:
  3265.         for(i=0; i<64; i++)
  3266.             c->idct_permutation[i]= i;
  3267.         break;
  3268.     case FF_LIBMPEG2_IDCT_PERM:
  3269.         for(i=0; i<64; i++)
  3270.             c->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
  3271.         break;
  3272.     case FF_SIMPLE_IDCT_PERM:
  3273.         for(i=0; i<64; i++)
  3274.             c->idct_permutation[i]= simple_mmx_permutation[i];
  3275.         break;
  3276.     case FF_TRANSPOSE_IDCT_PERM:
  3277.         for(i=0; i<64; i++)
  3278.             c->idct_permutation[i]= ((i&7)<<3) | (i>>3);
  3279.         break;
  3280.     default:
  3281.         av_log(avctx, AV_LOG_ERROR, "Internal error, IDCT permutation not setn");
  3282.     }
  3283. }