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.
29537 Commits
32 Branches
580MB
Tree: dbb5ee8ea7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dbb5ee8ea7'
${ noResults }
FFmpeg/libavcodec/simple_idct.c

556 lines
15KB
Raw Blame History 

  1. /*

  2.  * Simple IDCT

  3.  *

  4.  * Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>

  5.  *

  6.  * This file is part of Libav.

  7.  *

  8.  * Libav is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * Libav is distributed in the hope that it will be useful,

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

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with Libav; if not, write to the Free Software

  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  21.  */

  22. 

  23. /**

  24.  * @file

  25.  * simpleidct in C.

  26.  */

  27. 

  28. /*

  29.   based upon some outcommented c code from mpeg2dec (idct_mmx.c

  30.   written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)

  31.  */

  32. #include "avcodec.h"

  33. #include "dsputil.h"

  34. #include "mathops.h"

  35. #include "simple_idct.h"

  36. 

  37. #define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  38. #define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  39. #define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  40. #define W4  16383  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  41. #define W5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  42. #define W6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  43. #define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

  44. #define ROW_SHIFT 11

  45. #define COL_SHIFT 20 // 6

  46. 

  47. static inline void idctRowCondDC (DCTELEM * row)

  48. {

  49.         int a0, a1, a2, a3, b0, b1, b2, b3;

  50. #if HAVE_FAST_64BIT

  51.         uint64_t temp;

  52. #else

  53.         uint32_t temp;

  54. #endif

  55. 

  56. #if HAVE_FAST_64BIT

  57. #if HAVE_BIGENDIAN

  58. #define ROW0_MASK 0xffff000000000000LL

  59. #else

  60. #define ROW0_MASK 0xffffLL

  61. #endif

  62.         if (((((uint64_t *)row)[0] & ~ROW0_MASK) | ((uint64_t *)row)[1]) == 0) {

  63.             temp = (row[0] << 3) & 0xffff;

  64.             temp += temp << 16;

  65.             temp += temp << 32;

  66.             ((uint64_t *)row)[0] = temp;

  67.             ((uint64_t *)row)[1] = temp;

  68.             return;

  69.         }

  70. #else

  71.         if (!(((uint32_t*)row)[1] |

  72.               ((uint32_t*)row)[2] |

  73.               ((uint32_t*)row)[3] |

  74.               row[1])) {

  75.             temp = (row[0] << 3) & 0xffff;

  76.             temp += temp << 16;

  77.             ((uint32_t*)row)[0]=((uint32_t*)row)[1] =

  78.                 ((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;

  79.             return;

  80.         }

  81. #endif

  82. 

  83.         a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));

  84.         a1 = a0;

  85.         a2 = a0;

  86.         a3 = a0;

  87. 

  88.         /* no need to optimize : gcc does it */

  89.         a0 += W2 * row[2];

  90.         a1 += W6 * row[2];

  91.         a2 -= W6 * row[2];

  92.         a3 -= W2 * row[2];

  93. 

  94.         b0 = MUL16(W1, row[1]);

  95.         MAC16(b0, W3, row[3]);

  96.         b1 = MUL16(W3, row[1]);

  97.         MAC16(b1, -W7, row[3]);

  98.         b2 = MUL16(W5, row[1]);

  99.         MAC16(b2, -W1, row[3]);

  100.         b3 = MUL16(W7, row[1]);

  101.         MAC16(b3, -W5, row[3]);

  102. 

  103. #if HAVE_FAST_64BIT

  104.         temp = ((uint64_t*)row)[1];

  105. #else

  106.         temp = ((uint32_t*)row)[2] | ((uint32_t*)row)[3];

  107. #endif

  108.         if (temp != 0) {

  109.             a0 += W4*row[4] + W6*row[6];

  110.             a1 += - W4*row[4] - W2*row[6];

  111.             a2 += - W4*row[4] + W2*row[6];

  112.             a3 += W4*row[4] - W6*row[6];

  113. 

  114.             MAC16(b0, W5, row[5]);

  115.             MAC16(b0, W7, row[7]);

  116. 

  117.             MAC16(b1, -W1, row[5]);

  118.             MAC16(b1, -W5, row[7]);

  119. 

  120.             MAC16(b2, W7, row[5]);

  121.             MAC16(b2, W3, row[7]);

  122. 

  123.             MAC16(b3, W3, row[5]);

  124.             MAC16(b3, -W1, row[7]);

  125.         }

  126. 

  127.         row[0] = (a0 + b0) >> ROW_SHIFT;

  128.         row[7] = (a0 - b0) >> ROW_SHIFT;

  129.         row[1] = (a1 + b1) >> ROW_SHIFT;

  130.         row[6] = (a1 - b1) >> ROW_SHIFT;

  131.         row[2] = (a2 + b2) >> ROW_SHIFT;

  132.         row[5] = (a2 - b2) >> ROW_SHIFT;

  133.         row[3] = (a3 + b3) >> ROW_SHIFT;

  134.         row[4] = (a3 - b3) >> ROW_SHIFT;

  135. }

  136. 

  137. static inline void idctSparseColPut (uint8_t *dest, int line_size,

  138.                                      DCTELEM * col)

  139. {

  140.         int a0, a1, a2, a3, b0, b1, b2, b3;

  141.         uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  142. 

  143.         /* XXX: I did that only to give same values as previous code */

  144.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));

  145.         a1 = a0;

  146.         a2 = a0;

  147.         a3 = a0;

  148. 

  149.         a0 +=  + W2*col[8*2];

  150.         a1 +=  + W6*col[8*2];

  151.         a2 +=  - W6*col[8*2];

  152.         a3 +=  - W2*col[8*2];

  153. 

  154.         b0 = MUL16(W1, col[8*1]);

  155.         b1 = MUL16(W3, col[8*1]);

  156.         b2 = MUL16(W5, col[8*1]);

  157.         b3 = MUL16(W7, col[8*1]);

  158. 

  159.         MAC16(b0, + W3, col[8*3]);

  160.         MAC16(b1, - W7, col[8*3]);

  161.         MAC16(b2, - W1, col[8*3]);

  162.         MAC16(b3, - W5, col[8*3]);

  163. 

  164.         if(col[8*4]){

  165.             a0 += + W4*col[8*4];

  166.             a1 += - W4*col[8*4];

  167.             a2 += - W4*col[8*4];

  168.             a3 += + W4*col[8*4];

  169.         }

  170. 

  171.         if (col[8*5]) {

  172.             MAC16(b0, + W5, col[8*5]);

  173.             MAC16(b1, - W1, col[8*5]);

  174.             MAC16(b2, + W7, col[8*5]);

  175.             MAC16(b3, + W3, col[8*5]);

  176.         }

  177. 

  178.         if(col[8*6]){

  179.             a0 += + W6*col[8*6];

  180.             a1 += - W2*col[8*6];

  181.             a2 += + W2*col[8*6];

  182.             a3 += - W6*col[8*6];

  183.         }

  184. 

  185.         if (col[8*7]) {

  186.             MAC16(b0, + W7, col[8*7]);

  187.             MAC16(b1, - W5, col[8*7]);

  188.             MAC16(b2, + W3, col[8*7]);

  189.             MAC16(b3, - W1, col[8*7]);

  190.         }

  191. 

  192.         dest[0] = cm[(a0 + b0) >> COL_SHIFT];

  193.         dest += line_size;

  194.         dest[0] = cm[(a1 + b1) >> COL_SHIFT];

  195.         dest += line_size;

  196.         dest[0] = cm[(a2 + b2) >> COL_SHIFT];

  197.         dest += line_size;

  198.         dest[0] = cm[(a3 + b3) >> COL_SHIFT];

  199.         dest += line_size;

  200.         dest[0] = cm[(a3 - b3) >> COL_SHIFT];

  201.         dest += line_size;

  202.         dest[0] = cm[(a2 - b2) >> COL_SHIFT];

  203.         dest += line_size;

  204.         dest[0] = cm[(a1 - b1) >> COL_SHIFT];

  205.         dest += line_size;

  206.         dest[0] = cm[(a0 - b0) >> COL_SHIFT];

  207. }

  208. 

  209. static inline void idctSparseColAdd (uint8_t *dest, int line_size,

  210.                                      DCTELEM * col)

  211. {

  212.         int a0, a1, a2, a3, b0, b1, b2, b3;

  213.         uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  214. 

  215.         /* XXX: I did that only to give same values as previous code */

  216.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));

  217.         a1 = a0;

  218.         a2 = a0;

  219.         a3 = a0;

  220. 

  221.         a0 +=  + W2*col[8*2];

  222.         a1 +=  + W6*col[8*2];

  223.         a2 +=  - W6*col[8*2];

  224.         a3 +=  - W2*col[8*2];

  225. 

  226.         b0 = MUL16(W1, col[8*1]);

  227.         b1 = MUL16(W3, col[8*1]);

  228.         b2 = MUL16(W5, col[8*1]);

  229.         b3 = MUL16(W7, col[8*1]);

  230. 

  231.         MAC16(b0, + W3, col[8*3]);

  232.         MAC16(b1, - W7, col[8*3]);

  233.         MAC16(b2, - W1, col[8*3]);

  234.         MAC16(b3, - W5, col[8*3]);

  235. 

  236.         if(col[8*4]){

  237.             a0 += + W4*col[8*4];

  238.             a1 += - W4*col[8*4];

  239.             a2 += - W4*col[8*4];

  240.             a3 += + W4*col[8*4];

  241.         }

  242. 

  243.         if (col[8*5]) {

  244.             MAC16(b0, + W5, col[8*5]);

  245.             MAC16(b1, - W1, col[8*5]);

  246.             MAC16(b2, + W7, col[8*5]);

  247.             MAC16(b3, + W3, col[8*5]);

  248.         }

  249. 

  250.         if(col[8*6]){

  251.             a0 += + W6*col[8*6];

  252.             a1 += - W2*col[8*6];

  253.             a2 += + W2*col[8*6];

  254.             a3 += - W6*col[8*6];

  255.         }

  256. 

  257.         if (col[8*7]) {

  258.             MAC16(b0, + W7, col[8*7]);

  259.             MAC16(b1, - W5, col[8*7]);

  260.             MAC16(b2, + W3, col[8*7]);

  261.             MAC16(b3, - W1, col[8*7]);

  262.         }

  263. 

  264.         dest[0] = cm[dest[0] + ((a0 + b0) >> COL_SHIFT)];

  265.         dest += line_size;

  266.         dest[0] = cm[dest[0] + ((a1 + b1) >> COL_SHIFT)];

  267.         dest += line_size;

  268.         dest[0] = cm[dest[0] + ((a2 + b2) >> COL_SHIFT)];

  269.         dest += line_size;

  270.         dest[0] = cm[dest[0] + ((a3 + b3) >> COL_SHIFT)];

  271.         dest += line_size;

  272.         dest[0] = cm[dest[0] + ((a3 - b3) >> COL_SHIFT)];

  273.         dest += line_size;

  274.         dest[0] = cm[dest[0] + ((a2 - b2) >> COL_SHIFT)];

  275.         dest += line_size;

  276.         dest[0] = cm[dest[0] + ((a1 - b1) >> COL_SHIFT)];

  277.         dest += line_size;

  278.         dest[0] = cm[dest[0] + ((a0 - b0) >> COL_SHIFT)];

  279. }

  280. 

  281. static inline void idctSparseCol (DCTELEM * col)

  282. {

  283.         int a0, a1, a2, a3, b0, b1, b2, b3;

  284. 

  285.         /* XXX: I did that only to give same values as previous code */

  286.         a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));

  287.         a1 = a0;

  288.         a2 = a0;

  289.         a3 = a0;

  290. 

  291.         a0 +=  + W2*col[8*2];

  292.         a1 +=  + W6*col[8*2];

  293.         a2 +=  - W6*col[8*2];

  294.         a3 +=  - W2*col[8*2];

  295. 

  296.         b0 = MUL16(W1, col[8*1]);

  297.         b1 = MUL16(W3, col[8*1]);

  298.         b2 = MUL16(W5, col[8*1]);

  299.         b3 = MUL16(W7, col[8*1]);

  300. 

  301.         MAC16(b0, + W3, col[8*3]);

  302.         MAC16(b1, - W7, col[8*3]);

  303.         MAC16(b2, - W1, col[8*3]);

  304.         MAC16(b3, - W5, col[8*3]);

  305. 

  306.         if(col[8*4]){

  307.             a0 += + W4*col[8*4];

  308.             a1 += - W4*col[8*4];

  309.             a2 += - W4*col[8*4];

  310.             a3 += + W4*col[8*4];

  311.         }

  312. 

  313.         if (col[8*5]) {

  314.             MAC16(b0, + W5, col[8*5]);

  315.             MAC16(b1, - W1, col[8*5]);

  316.             MAC16(b2, + W7, col[8*5]);

  317.             MAC16(b3, + W3, col[8*5]);

  318.         }

  319. 

  320.         if(col[8*6]){

  321.             a0 += + W6*col[8*6];

  322.             a1 += - W2*col[8*6];

  323.             a2 += + W2*col[8*6];

  324.             a3 += - W6*col[8*6];

  325.         }

  326. 

  327.         if (col[8*7]) {

  328.             MAC16(b0, + W7, col[8*7]);

  329.             MAC16(b1, - W5, col[8*7]);

  330.             MAC16(b2, + W3, col[8*7]);

  331.             MAC16(b3, - W1, col[8*7]);

  332.         }

  333. 

  334.         col[0 ] = ((a0 + b0) >> COL_SHIFT);

  335.         col[8 ] = ((a1 + b1) >> COL_SHIFT);

  336.         col[16] = ((a2 + b2) >> COL_SHIFT);

  337.         col[24] = ((a3 + b3) >> COL_SHIFT);

  338.         col[32] = ((a3 - b3) >> COL_SHIFT);

  339.         col[40] = ((a2 - b2) >> COL_SHIFT);

  340.         col[48] = ((a1 - b1) >> COL_SHIFT);

  341.         col[56] = ((a0 - b0) >> COL_SHIFT);

  342. }

  343. 

  344. void ff_simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block)

  345. {

  346.     int i;

  347.     for(i=0; i<8; i++)

  348.         idctRowCondDC(block + i*8);

  349. 

  350.     for(i=0; i<8; i++)

  351.         idctSparseColPut(dest + i, line_size, block + i);

  352. }

  353. 

  354. void ff_simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block)

  355. {

  356.     int i;

  357.     for(i=0; i<8; i++)

  358.         idctRowCondDC(block + i*8);

  359. 

  360.     for(i=0; i<8; i++)

  361.         idctSparseColAdd(dest + i, line_size, block + i);

  362. }

  363. 

  364. void ff_simple_idct(DCTELEM *block)

  365. {

  366.     int i;

  367.     for(i=0; i<8; i++)

  368.         idctRowCondDC(block + i*8);

  369. 

  370.     for(i=0; i<8; i++)

  371.         idctSparseCol(block + i);

  372. }

  373. 

  374. /* 2x4x8 idct */

  375. 

  376. #define CN_SHIFT 12

  377. #define C_FIX(x) ((int)((x) * (1 << CN_SHIFT) + 0.5))

  378. #define C1 C_FIX(0.6532814824)

  379. #define C2 C_FIX(0.2705980501)

  380. 

  381. /* row idct is multiple by 16 * sqrt(2.0), col idct4 is normalized,

  382.    and the butterfly must be multiplied by 0.5 * sqrt(2.0) */

  383. #define C_SHIFT (4+1+12)

  384. 

  385. static inline void idct4col_put(uint8_t *dest, int line_size, const DCTELEM *col)

  386. {

  387.     int c0, c1, c2, c3, a0, a1, a2, a3;

  388.     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  389. 

  390.     a0 = col[8*0];

  391.     a1 = col[8*2];

  392.     a2 = col[8*4];

  393.     a3 = col[8*6];

  394.     c0 = ((a0 + a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));

  395.     c2 = ((a0 - a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));

  396.     c1 = a1 * C1 + a3 * C2;

  397.     c3 = a1 * C2 - a3 * C1;

  398.     dest[0] = cm[(c0 + c1) >> C_SHIFT];

  399.     dest += line_size;

  400.     dest[0] = cm[(c2 + c3) >> C_SHIFT];

  401.     dest += line_size;

  402.     dest[0] = cm[(c2 - c3) >> C_SHIFT];

  403.     dest += line_size;

  404.     dest[0] = cm[(c0 - c1) >> C_SHIFT];

  405. }

  406. 

  407. #define BF(k) \

  408. {\

  409.     int a0, a1;\

  410.     a0 = ptr[k];\

  411.     a1 = ptr[8 + k];\

  412.     ptr[k] = a0 + a1;\

  413.     ptr[8 + k] = a0 - a1;\

  414. }

  415. 

  416. /* only used by DV codec. The input must be interlaced. 128 is added

  417.    to the pixels before clamping to avoid systematic error

  418.    (1024*sqrt(2)) offset would be needed otherwise. */

  419. /* XXX: I think a 1.0/sqrt(2) normalization should be needed to

  420.    compensate the extra butterfly stage - I don't have the full DV

  421.    specification */

  422. void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)

  423. {

  424.     int i;

  425.     DCTELEM *ptr;

  426. 

  427.     /* butterfly */

  428.     ptr = block;

  429.     for(i=0;i<4;i++) {

  430.         BF(0);

  431.         BF(1);

  432.         BF(2);

  433.         BF(3);

  434.         BF(4);

  435.         BF(5);

  436.         BF(6);

  437.         BF(7);

  438.         ptr += 2 * 8;

  439.     }

  440. 

  441.     /* IDCT8 on each line */

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

  443.         idctRowCondDC(block + i*8);

  444.     }

  445. 

  446.     /* IDCT4 and store */

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

  448.         idct4col_put(dest + i, 2 * line_size, block + i);

  449.         idct4col_put(dest + line_size + i, 2 * line_size, block + 8 + i);

  450.     }

  451. }

  452. 

  453. /* 8x4 & 4x8 WMV2 IDCT */

  454. #undef CN_SHIFT

  455. #undef C_SHIFT

  456. #undef C_FIX

  457. #undef C1

  458. #undef C2

  459. #define CN_SHIFT 12

  460. #define C_FIX(x) ((int)((x) * 1.414213562 * (1 << CN_SHIFT) + 0.5))

  461. #define C1 C_FIX(0.6532814824)

  462. #define C2 C_FIX(0.2705980501)

  463. #define C3 C_FIX(0.5)

  464. #define C_SHIFT (4+1+12)

  465. static inline void idct4col_add(uint8_t *dest, int line_size, const DCTELEM *col)

  466. {

  467.     int c0, c1, c2, c3, a0, a1, a2, a3;

  468.     const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  469. 

  470.     a0 = col[8*0];

  471.     a1 = col[8*1];

  472.     a2 = col[8*2];

  473.     a3 = col[8*3];

  474.     c0 = (a0 + a2)*C3 + (1 << (C_SHIFT - 1));

  475.     c2 = (a0 - a2)*C3 + (1 << (C_SHIFT - 1));

  476.     c1 = a1 * C1 + a3 * C2;

  477.     c3 = a1 * C2 - a3 * C1;

  478.     dest[0] = cm[dest[0] + ((c0 + c1) >> C_SHIFT)];

  479.     dest += line_size;

  480.     dest[0] = cm[dest[0] + ((c2 + c3) >> C_SHIFT)];

  481.     dest += line_size;

  482.     dest[0] = cm[dest[0] + ((c2 - c3) >> C_SHIFT)];

  483.     dest += line_size;

  484.     dest[0] = cm[dest[0] + ((c0 - c1) >> C_SHIFT)];

  485. }

  486. 

  487. #define RN_SHIFT 15

  488. #define R_FIX(x) ((int)((x) * 1.414213562 * (1 << RN_SHIFT) + 0.5))

  489. #define R1 R_FIX(0.6532814824)

  490. #define R2 R_FIX(0.2705980501)

  491. #define R3 R_FIX(0.5)

  492. #define R_SHIFT 11

  493. static inline void idct4row(DCTELEM *row)

  494. {

  495.     int c0, c1, c2, c3, a0, a1, a2, a3;

  496.     //const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  497. 

  498.     a0 = row[0];

  499.     a1 = row[1];

  500.     a2 = row[2];

  501.     a3 = row[3];

  502.     c0 = (a0 + a2)*R3 + (1 << (R_SHIFT - 1));

  503.     c2 = (a0 - a2)*R3 + (1 << (R_SHIFT - 1));

  504.     c1 = a1 * R1 + a3 * R2;

  505.     c3 = a1 * R2 - a3 * R1;

  506.     row[0]= (c0 + c1) >> R_SHIFT;

  507.     row[1]= (c2 + c3) >> R_SHIFT;

  508.     row[2]= (c2 - c3) >> R_SHIFT;

  509.     row[3]= (c0 - c1) >> R_SHIFT;

  510. }

  511. 

  512. void ff_simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block)

  513. {

  514.     int i;

  515. 

  516.     /* IDCT8 on each line */

  517.     for(i=0; i<4; i++) {

  518.         idctRowCondDC(block + i*8);

  519.     }

  520. 

  521.     /* IDCT4 and store */

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

  523.         idct4col_add(dest + i, line_size, block + i);

  524.     }

  525. }

  526. 

  527. void ff_simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block)

  528. {

  529.     int i;

  530. 

  531.     /* IDCT4 on each line */

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

  533.         idct4row(block + i*8);

  534.     }

  535. 

  536.     /* IDCT8 and store */

  537.     for(i=0; i<4; i++){

  538.         idctSparseColAdd(dest + i, line_size, block + i);

  539.     }

  540. }

  541. 

  542. void ff_simple_idct44_add(uint8_t *dest, int line_size, DCTELEM *block)

  543. {

  544.     int i;

  545. 

  546.     /* IDCT4 on each line */

  547.     for(i=0; i<4; i++) {

  548.         idct4row(block + i*8);

  549.     }

  550. 

  551.     /* IDCT4 and store */

  552.     for(i=0; i<4; i++){

  553.         idct4col_add(dest + i, line_size, block + i);

  554.     }

  555. }