falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
374 Commits
32 Branches
498MB
Tree: ae40484c1c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ae40484c1c'
${ noResults }
FFmpeg/libavcodec/dsputil.c

530 lines
21KB
Raw Blame History 

  1. /*

  2.  * DSP utils

  3.  * Copyright (c) 2000, 2001 Gerard Lantau.

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * (at your option) any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU General Public License

  16.  * along with this program; if not, write to the Free Software

  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18.  */

  19. #include <stdlib.h>

  20. #include <stdio.h>

  21. #include "avcodec.h"

  22. #include "dsputil.h"

  23. #include "simple_idct.h"

  24. 

  25. void (*ff_idct)(DCTELEM *block);

  26. void (*get_pixels)(DCTELEM *block, const UINT8 *pixels, int line_size);

  27. void (*put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);

  28. void (*add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);

  29. 

  30. op_pixels_abs_func pix_abs16x16;

  31. op_pixels_abs_func pix_abs16x16_x2;

  32. op_pixels_abs_func pix_abs16x16_y2;

  33. op_pixels_abs_func pix_abs16x16_xy2;

  34. 

  35. UINT8 cropTbl[256 + 2 * MAX_NEG_CROP];

  36. UINT32 squareTbl[512];

  37. 

  38. extern UINT16 default_intra_matrix[64];

  39. extern UINT16 default_non_intra_matrix[64];

  40. 

  41. UINT8 zigzag_direct[64] = {

  42.     0, 1, 8, 16, 9, 2, 3, 10,

  43.     17, 24, 32, 25, 18, 11, 4, 5,

  44.     12, 19, 26, 33, 40, 48, 41, 34,

  45.     27, 20, 13, 6, 7, 14, 21, 28,

  46.     35, 42, 49, 56, 57, 50, 43, 36,

  47.     29, 22, 15, 23, 30, 37, 44, 51,

  48.     58, 59, 52, 45, 38, 31, 39, 46,

  49.     53, 60, 61, 54, 47, 55, 62, 63

  50. };

  51. 

  52. UINT8 ff_alternate_horizontal_scan[64] = {

  53.     0,  1,  2,  3,  8,  9, 16, 17, 

  54.     10, 11,  4,  5,  6,  7, 15, 14,

  55.     13, 12, 19, 18, 24, 25, 32, 33, 

  56.     26, 27, 20, 21, 22, 23, 28, 29,

  57.     30, 31, 34, 35, 40, 41, 48, 49, 

  58.     42, 43, 36, 37, 38, 39, 44, 45,

  59.     46, 47, 50, 51, 56, 57, 58, 59, 

  60.     52, 53, 54, 55, 60, 61, 62, 63,

  61. };

  62. 

  63. UINT8 ff_alternate_vertical_scan[64] = {

  64.     0,  8, 16, 24,  1,  9,  2, 10, 

  65.     17, 25, 32, 40, 48, 56, 57, 49,

  66.     41, 33, 26, 18,  3, 11,  4, 12, 

  67.     19, 27, 34, 42, 50, 58, 35, 43,

  68.     51, 59, 20, 28,  5, 13,  6, 14, 

  69.     21, 29, 36, 44, 52, 60, 37, 45,

  70.     53, 61, 22, 30,  7, 15, 23, 31, 

  71.     38, 46, 54, 62, 39, 47, 55, 63,

  72. };

  73. 

  74. 

  75. static UINT8 simple_mmx_permutation[64]={

  76. 	0x00, 0x08, 0x01, 0x09, 0x04, 0x0C, 0x05, 0x0D,

  77. 	0x10, 0x18, 0x11, 0x19, 0x14, 0x1C, 0x15, 0x1D,

  78. 	0x02, 0x0A, 0x03, 0x0B, 0x06, 0x0E, 0x07, 0x0F,

  79. 	0x12, 0x1A, 0x13, 0x1B, 0x16, 0x1E, 0x17, 0x1F,

  80. 	0x20, 0x28, 0x21, 0x29, 0x24, 0x2C, 0x25, 0x2D,

  81. 	0x30, 0x38, 0x31, 0x39, 0x34, 0x3C, 0x35, 0x3D,

  82. 	0x22, 0x2A, 0x23, 0x2B, 0x26, 0x2E, 0x27, 0x2F,

  83. 	0x32, 0x3A, 0x33, 0x3B, 0x36, 0x3E, 0x37, 0x3F,

  84. };

  85. 

  86. /* used to skip zeros at the end */

  87. UINT8 zigzag_end[64];

  88. 

  89. UINT8 permutation[64];

  90. //UINT8 invPermutation[64];

  91. 

  92. static void build_zigzag_end()

  93. {

  94.     int lastIndex;

  95.     int lastIndexAfterPerm=0;

  96.     for(lastIndex=0; lastIndex<64; lastIndex++)

  97.     {

  98.         if(zigzag_direct[lastIndex] > lastIndexAfterPerm) 

  99.             lastIndexAfterPerm= zigzag_direct[lastIndex];

  100.         zigzag_end[lastIndex]= lastIndexAfterPerm + 1;

  101.     }

  102. }

  103. 

  104. void get_pixels_c(DCTELEM *block, const UINT8 *pixels, int line_size)

  105. {

  106.     DCTELEM *p;

  107.     const UINT8 *pix;

  108.     int i;

  109. 

  110.     /* read the pixels */

  111.     p = block;

  112.     pix = pixels;

  113.     for(i=0;i<8;i++) {

  114.         p[0] = pix[0];

  115.         p[1] = pix[1];

  116.         p[2] = pix[2];

  117.         p[3] = pix[3];

  118.         p[4] = pix[4];

  119.         p[5] = pix[5];

  120.         p[6] = pix[6];

  121.         p[7] = pix[7];

  122.         pix += line_size;

  123.         p += 8;

  124.     }

  125. }

  126. 

  127. void put_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size)

  128. {

  129.     const DCTELEM *p;

  130.     UINT8 *pix;

  131.     int i;

  132.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  133.     

  134.     /* read the pixels */

  135.     p = block;

  136.     pix = pixels;

  137.     for(i=0;i<8;i++) {

  138.         pix[0] = cm[p[0]];

  139.         pix[1] = cm[p[1]];

  140.         pix[2] = cm[p[2]];

  141.         pix[3] = cm[p[3]];

  142.         pix[4] = cm[p[4]];

  143.         pix[5] = cm[p[5]];

  144.         pix[6] = cm[p[6]];

  145.         pix[7] = cm[p[7]];

  146.         pix += line_size;

  147.         p += 8;

  148.     }

  149. }

  150. 

  151. void add_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size)

  152. {

  153.     const DCTELEM *p;

  154.     UINT8 *pix;

  155.     int i;

  156.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  157.     

  158.     /* read the pixels */

  159.     p = block;

  160.     pix = pixels;

  161.     for(i=0;i<8;i++) {

  162.         pix[0] = cm[pix[0] + p[0]];

  163.         pix[1] = cm[pix[1] + p[1]];

  164.         pix[2] = cm[pix[2] + p[2]];

  165.         pix[3] = cm[pix[3] + p[3]];

  166.         pix[4] = cm[pix[4] + p[4]];

  167.         pix[5] = cm[pix[5] + p[5]];

  168.         pix[6] = cm[pix[6] + p[6]];

  169.         pix[7] = cm[pix[7] + p[7]];

  170.         pix += line_size;

  171.         p += 8;

  172.     }

  173. }

  174. 

  175. #define PIXOP(BTYPE, OPNAME, OP, INCR)                                                   \

  176.                                                                                          \

  177. static void OPNAME ## _pixels(BTYPE *block, const UINT8 *pixels, int line_size, int h)    \

  178. {                                                                                        \

  179.     BTYPE *p;                                                                            \

  180.     const UINT8 *pix;                                                                    \

  181.                                                                                          \

  182.     p = block;                                                                           \

  183.     pix = pixels;                                                                        \

  184.     do {                                                                                 \

  185.         OP(p[0], pix[0]);                                                                  \

  186.         OP(p[1], pix[1]);                                                                  \

  187.         OP(p[2], pix[2]);                                                                  \

  188.         OP(p[3], pix[3]);                                                                  \

  189.         OP(p[4], pix[4]);                                                                  \

  190.         OP(p[5], pix[5]);                                                                  \

  191.         OP(p[6], pix[6]);                                                                  \

  192.         OP(p[7], pix[7]);                                                                  \

  193.         pix += line_size;                                                                \

  194.         p += INCR;                                                                       \

  195.     } while (--h);;                                                                       \

  196. }                                                                                        \

  197.                                                                                          \

  198. static void OPNAME ## _pixels_x2(BTYPE *block, const UINT8 *pixels, int line_size, int h)     \

  199. {                                                                                        \

  200.     BTYPE *p;                                                                          \

  201.     const UINT8 *pix;                                                                    \

  202.                                                                                          \

  203.     p = block;                                                                           \

  204.     pix = pixels;                                                                        \

  205.     do {                                                                   \

  206.         OP(p[0], avg2(pix[0], pix[1]));                                                    \

  207.         OP(p[1], avg2(pix[1], pix[2]));                                                    \

  208.         OP(p[2], avg2(pix[2], pix[3]));                                                    \

  209.         OP(p[3], avg2(pix[3], pix[4]));                                                    \

  210.         OP(p[4], avg2(pix[4], pix[5]));                                                    \

  211.         OP(p[5], avg2(pix[5], pix[6]));                                                    \

  212.         OP(p[6], avg2(pix[6], pix[7]));                                                    \

  213.         OP(p[7], avg2(pix[7], pix[8]));                                                    \

  214.         pix += line_size;                                                                \

  215.         p += INCR;                                                                       \

  216.     } while (--h);                                                                        \

  217. }                                                                                        \

  218.                                                                                          \

  219. static void OPNAME ## _pixels_y2(BTYPE *block, const UINT8 *pixels, int line_size, int h)     \

  220. {                                                                                        \

  221.     BTYPE *p;                                                                          \

  222.     const UINT8 *pix;                                                                    \

  223.     const UINT8 *pix1;                                                                   \

  224.                                                                                          \

  225.     p = block;                                                                           \

  226.     pix = pixels;                                                                        \

  227.     pix1 = pixels + line_size;                                                           \

  228.     do {                                                                                 \

  229.         OP(p[0], avg2(pix[0], pix1[0]));                                                   \

  230.         OP(p[1], avg2(pix[1], pix1[1]));                                                   \

  231.         OP(p[2], avg2(pix[2], pix1[2]));                                                   \

  232.         OP(p[3], avg2(pix[3], pix1[3]));                                                   \

  233.         OP(p[4], avg2(pix[4], pix1[4]));                                                   \

  234.         OP(p[5], avg2(pix[5], pix1[5]));                                                   \

  235.         OP(p[6], avg2(pix[6], pix1[6]));                                                   \

  236.         OP(p[7], avg2(pix[7], pix1[7]));                                                   \

  237.         pix += line_size;                                                                \

  238.         pix1 += line_size;                                                               \

  239.         p += INCR;                                                                       \

  240.     } while(--h);                                                                         \

  241. }                                                                                        \

  242.                                                                                          \

  243. static void OPNAME ## _pixels_xy2(BTYPE *block, const UINT8 *pixels, int line_size, int h)    \

  244. {                                                                                        \

  245.     BTYPE *p;                                                                          \

  246.     const UINT8 *pix;                                                                    \

  247.     const UINT8 *pix1;                                                                   \

  248.                                                                                          \

  249.     p = block;                                                                           \

  250.     pix = pixels;                                                                        \

  251.     pix1 = pixels + line_size;                                                           \

  252.     do {                                                                   \

  253.         OP(p[0], avg4(pix[0], pix[1], pix1[0], pix1[1]));                                  \

  254.         OP(p[1], avg4(pix[1], pix[2], pix1[1], pix1[2]));                                  \

  255.         OP(p[2], avg4(pix[2], pix[3], pix1[2], pix1[3]));                                  \

  256.         OP(p[3], avg4(pix[3], pix[4], pix1[3], pix1[4]));                                  \

  257.         OP(p[4], avg4(pix[4], pix[5], pix1[4], pix1[5]));                                  \

  258.         OP(p[5], avg4(pix[5], pix[6], pix1[5], pix1[6]));                                  \

  259.         OP(p[6], avg4(pix[6], pix[7], pix1[6], pix1[7]));                                  \

  260.         OP(p[7], avg4(pix[7], pix[8], pix1[7], pix1[8]));                                  \

  261.         pix += line_size;                                                                \

  262.         pix1 += line_size;                                                               \

  263.         p += INCR;                                                                       \

  264.     } while(--h);                                                                         \

  265. }                                                                                        \

  266.                                                                                          \

  267. void (*OPNAME ## _pixels_tab[4])(BTYPE *block, const UINT8 *pixels, int line_size, int h) = { \

  268.     OPNAME ## _pixels,                                                                   \

  269.     OPNAME ## _pixels_x2,                                                                \

  270.     OPNAME ## _pixels_y2,                                                                \

  271.     OPNAME ## _pixels_xy2,                                                               \

  272. };

  273. 

  274. 

  275. /* rounding primitives */

  276. #define avg2(a,b) ((a+b+1)>>1)

  277. #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)

  278. 

  279. #define op_put(a, b) a = b

  280. #define op_avg(a, b) a = avg2(a, b)

  281. #define op_sub(a, b) a -= b

  282. 

  283. PIXOP(UINT8, put, op_put, line_size)

  284. PIXOP(UINT8, avg, op_avg, line_size)

  285. 

  286. PIXOP(DCTELEM, sub, op_sub, 8)

  287. 

  288. /* not rounding primitives */

  289. #undef avg2

  290. #undef avg4

  291. #define avg2(a,b) ((a+b)>>1)

  292. #define avg4(a,b,c,d) ((a+b+c+d+1)>>2)

  293. 

  294. PIXOP(UINT8, put_no_rnd, op_put, line_size)

  295. PIXOP(UINT8, avg_no_rnd, op_avg, line_size)

  296. 

  297. /* motion estimation */

  298. 

  299. #undef avg2

  300. #undef avg4

  301. #define avg2(a,b) ((a+b+1)>>1)

  302. #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)

  303. 

  304. int pix_abs16x16_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)

  305. {

  306.     int s, i;

  307. 

  308.     s = 0;

  309.     for(i=0;i<h;i++) {

  310.         s += abs(pix1[0] - pix2[0]);

  311.         s += abs(pix1[1] - pix2[1]);

  312.         s += abs(pix1[2] - pix2[2]);

  313.         s += abs(pix1[3] - pix2[3]);

  314.         s += abs(pix1[4] - pix2[4]);

  315.         s += abs(pix1[5] - pix2[5]);

  316.         s += abs(pix1[6] - pix2[6]);

  317.         s += abs(pix1[7] - pix2[7]);

  318.         s += abs(pix1[8] - pix2[8]);

  319.         s += abs(pix1[9] - pix2[9]);

  320.         s += abs(pix1[10] - pix2[10]);

  321.         s += abs(pix1[11] - pix2[11]);

  322.         s += abs(pix1[12] - pix2[12]);

  323.         s += abs(pix1[13] - pix2[13]);

  324.         s += abs(pix1[14] - pix2[14]);

  325.         s += abs(pix1[15] - pix2[15]);

  326.         pix1 += line_size;

  327.         pix2 += line_size;

  328.     }

  329.     return s;

  330. }

  331. 

  332. int pix_abs16x16_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)

  333. {

  334.     int s, i;

  335. 

  336.     s = 0;

  337.     for(i=0;i<h;i++) {

  338.         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));

  339.         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));

  340.         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));

  341.         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));

  342.         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));

  343.         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));

  344.         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));

  345.         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));

  346.         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));

  347.         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));

  348.         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));

  349.         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));

  350.         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));

  351.         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));

  352.         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));

  353.         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));

  354.         pix1 += line_size;

  355.         pix2 += line_size;

  356.     }

  357.     return s;

  358. }

  359. 

  360. int pix_abs16x16_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)

  361. {

  362.     int s, i;

  363.     UINT8 *pix3 = pix2 + line_size;

  364. 

  365.     s = 0;

  366.     for(i=0;i<h;i++) {

  367.         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));

  368.         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));

  369.         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));

  370.         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));

  371.         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));

  372.         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));

  373.         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));

  374.         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));

  375.         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));

  376.         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));

  377.         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));

  378.         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));

  379.         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));

  380.         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));

  381.         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));

  382.         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));

  383.         pix1 += line_size;

  384.         pix2 += line_size;

  385.         pix3 += line_size;

  386.     }

  387.     return s;

  388. }

  389. 

  390. int pix_abs16x16_xy2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)

  391. {

  392.     int s, i;

  393.     UINT8 *pix3 = pix2 + line_size;

  394. 

  395.     s = 0;

  396.     for(i=0;i<h;i++) {

  397.         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));

  398.         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));

  399.         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));

  400.         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));

  401.         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));

  402.         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));

  403.         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));

  404.         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));

  405.         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));

  406.         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));

  407.         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));

  408.         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));

  409.         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));

  410.         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));

  411.         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));

  412.         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));

  413.         pix1 += line_size;

  414.         pix2 += line_size;

  415.         pix3 += line_size;

  416.     }

  417.     return s;

  418. }

  419. 

  420. /* permute block according so that it corresponds to the MMX idct

  421.    order */

  422. #ifdef SIMPLE_IDCT

  423.  /* general permutation, but perhaps slightly slower */

  424. void block_permute(INT16 *block)

  425. {

  426. 	int i;

  427. 	INT16 temp[64];

  428. 

  429. 	for(i=0; i<64; i++) temp[ block_permute_op(i) ] = block[i];

  430. 

  431. 	for(i=0; i<64; i++) block[i] = temp[i];

  432. }

  433. #else

  434. 

  435. void block_permute(INT16 *block)

  436. {

  437.     int tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;

  438.     int i;

  439. 

  440.     for(i=0;i<8;i++) {

  441.         tmp1 = block[1];

  442.         tmp2 = block[2];

  443.         tmp3 = block[3];

  444.         tmp4 = block[4];

  445.         tmp5 = block[5];

  446.         tmp6 = block[6];

  447.         block[1] = tmp2;

  448.         block[2] = tmp4;

  449.         block[3] = tmp6;

  450.         block[4] = tmp1;

  451.         block[5] = tmp3;

  452.         block[6] = tmp5;

  453.         block += 8;

  454.     }

  455. }

  456. #endif

  457. 

  458. void dsputil_init(void)

  459. {

  460.     int i, j;

  461.     int use_permuted_idct;

  462. 

  463.     for(i=0;i<256;i++) cropTbl[i + MAX_NEG_CROP] = i;

  464.     for(i=0;i<MAX_NEG_CROP;i++) {

  465.         cropTbl[i] = 0;

  466.         cropTbl[i + MAX_NEG_CROP + 256] = 255;

  467.     }

  468. 

  469.     for(i=0;i<512;i++) {

  470.         squareTbl[i] = (i - 256) * (i - 256);

  471.     }

  472. 

  473. #ifdef SIMPLE_IDCT

  474.     ff_idct = simple_idct;

  475. #else

  476.     ff_idct = j_rev_dct;

  477. #endif

  478.     get_pixels = get_pixels_c;

  479.     put_pixels_clamped = put_pixels_clamped_c;

  480.     add_pixels_clamped = add_pixels_clamped_c;

  481. 

  482.     pix_abs16x16 = pix_abs16x16_c;

  483.     pix_abs16x16_x2 = pix_abs16x16_x2_c;

  484.     pix_abs16x16_y2 = pix_abs16x16_y2_c;

  485.     pix_abs16x16_xy2 = pix_abs16x16_xy2_c;

  486.     av_fdct = jpeg_fdct_ifast;

  487. 

  488.     use_permuted_idct = 1;

  489. 

  490. #ifdef HAVE_MMX

  491.     dsputil_init_mmx();

  492. #endif

  493. #ifdef ARCH_ARMV4L

  494.     dsputil_init_armv4l();

  495. #endif

  496. #ifdef HAVE_MLIB

  497.     dsputil_init_mlib();

  498.     use_permuted_idct = 0;

  499. #endif

  500. 

  501. #ifdef SIMPLE_IDCT

  502.     if(ff_idct == simple_idct) use_permuted_idct=0;

  503. #endif

  504. 

  505.     if(use_permuted_idct)

  506. #ifdef SIMPLE_IDCT

  507.         for(i=0; i<64; i++) permutation[i]= simple_mmx_permutation[i];

  508. #else

  509.         for(i=0; i<64; i++) permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);

  510. #endif

  511.     else

  512.         for(i=0; i<64; i++) permutation[i]=i;

  513. 

  514.     if (use_permuted_idct) {

  515.         /* permute for IDCT */

  516.         for(i=0;i<64;i++) {

  517.             j = zigzag_direct[i];

  518.             zigzag_direct[i] = block_permute_op(j);

  519.             j = ff_alternate_horizontal_scan[i];

  520.             ff_alternate_horizontal_scan[i] = block_permute_op(j);

  521.             j = ff_alternate_vertical_scan[i];

  522.             ff_alternate_vertical_scan[i] = block_permute_op(j);

  523.         }

  524.         block_permute(default_intra_matrix);

  525.         block_permute(default_non_intra_matrix);

  526.     }

  527.     

  528.     build_zigzag_end();

  529. }