home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wvis0626.zip / warpvision_20020626.zip / libavcodec / simple_idct.c < prev    next >
C/C++ Source or Header  |  2002-06-25  |  15KB  |  584 lines
  1. /*
  2.  * Simple IDCT
  3.  *
  4.  * Copyright (c) 2001 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. /*
  21.   based upon some outcommented c code from mpeg2dec (idct_mmx.c
  22.   written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>) 
  23.  */
  24. #include "avcodec.h"
  25. #include "dsputil.h"
  26. #include "simple_idct.h"
  27.  
  28. #if 0
  29. #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
  30. #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
  31. #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
  32. #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
  33. #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
  34. #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
  35. #define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
  36. #define ROW_SHIFT 8
  37. #define COL_SHIFT 17
  38. #else
  39. #define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  40. #define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  41. #define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  42. #define W4  16383  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  43. #define W5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  44. #define W6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  45. #define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
  46. #define ROW_SHIFT 11
  47. #define COL_SHIFT 20 // 6
  48. #endif
  49.  
  50. #ifdef ARCH_ALPHA
  51. #define FAST_64BIT
  52. #endif
  53.  
  54. #if defined(ARCH_POWERPC_405)
  55.  
  56. /* signed 16x16 -> 32 multiply add accumulate */
  57. #define MAC16(rt, ra, rb) \
  58.     asm ("maclhw %0, %2, %3" : "=r" (rt) : "0" (rt), "r" (ra), "r" (rb));
  59.  
  60. /* signed 16x16 -> 32 multiply */
  61. #define MUL16(rt, ra, rb) \
  62.     asm ("mullhw %0, %1, %2" : "=r" (rt) : "r" (ra), "r" (rb));
  63.  
  64. #else
  65.  
  66. /* signed 16x16 -> 32 multiply add accumulate */
  67. #define MAC16(rt, ra, rb) rt += (ra) * (rb)
  68.  
  69. /* signed 16x16 -> 32 multiply */
  70. #define MUL16(rt, ra, rb) rt = (ra) * (rb)
  71.  
  72. #endif
  73.  
  74. #ifdef ARCH_ALPHA
  75. /* 0: all entries 0, 1: only first entry nonzero, 2: otherwise  */
  76. static inline int idctRowCondDC(int16_t *row)
  77. {
  78.     int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3;
  79.     uint64_t *lrow = (uint64_t *) row;
  80.  
  81.     if (lrow[1] == 0) {
  82.         if (lrow[0] == 0)
  83.             return 0;
  84.         if ((lrow[0] & ~0xffffULL) == 0) {
  85.             uint64_t v;
  86.  
  87.             a0 = W4 * row[0];
  88.             a0 += 1 << (ROW_SHIFT - 1);
  89.             a0 >>= ROW_SHIFT;
  90.             v = (uint16_t) a0;
  91.             v += v << 16;
  92.             v += v << 32;
  93.             lrow[0] = v;
  94.             lrow[1] = v;
  95.  
  96.             return 1;
  97.         }
  98.     }
  99.  
  100.         a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
  101.     a1 = a0;
  102.     a2 = a0;
  103.     a3 = a0;
  104.  
  105.     if (row[2]) {
  106.         a0 += W2 * row[2];
  107.         a1 += W6 * row[2];
  108.         a2 -= W6 * row[2];
  109.         a3 -= W2 * row[2];
  110.     }
  111.  
  112.     if (row[4]) {
  113.         a0 += W4 * row[4];
  114.         a1 -= W4 * row[4];
  115.         a2 -= W4 * row[4];
  116.         a3 += W4 * row[4];
  117.     }
  118.  
  119.     if (row[6]) {
  120.         a0 += W6 * row[6];
  121.         a1 -= W2 * row[6];
  122.         a2 += W2 * row[6];
  123.         a3 -= W6 * row[6];
  124.     }
  125.  
  126.     if (row[1]) {
  127.         b0 = W1 * row[1];
  128.         b1 = W3 * row[1];
  129.         b2 = W5 * row[1];
  130.         b3 = W7 * row[1];
  131.     } else {
  132.         b0 = 0;
  133.         b1 = 0;
  134.         b2 = 0;
  135.         b3 = 0;
  136.     }
  137.  
  138.     if (row[3]) {
  139.         b0 += W3 * row[3];
  140.         b1 -= W7 * row[3];
  141.         b2 -= W1 * row[3];
  142.         b3 -= W5 * row[3];
  143.     }
  144.  
  145.     if (row[5]) {
  146.         b0 += W5 * row[5];
  147.         b1 -= W1 * row[5];
  148.         b2 += W7 * row[5];
  149.         b3 += W3 * row[5];
  150.     }
  151.  
  152.     if (row[7]) {
  153.         b0 += W7 * row[7];
  154.         b1 -= W5 * row[7];
  155.         b2 += W3 * row[7];
  156.         b3 -= W1 * row[7];
  157.     }
  158.  
  159.     row[0] = (a0 + b0) >> ROW_SHIFT;
  160.     row[1] = (a1 + b1) >> ROW_SHIFT;
  161.     row[2] = (a2 + b2) >> ROW_SHIFT;
  162.     row[3] = (a3 + b3) >> ROW_SHIFT;
  163.     row[4] = (a3 - b3) >> ROW_SHIFT;
  164.     row[5] = (a2 - b2) >> ROW_SHIFT;
  165.     row[6] = (a1 - b1) >> ROW_SHIFT;
  166.     row[7] = (a0 - b0) >> ROW_SHIFT;
  167.  
  168.     return 2;
  169. }
  170.  
  171. inline static void idctSparseCol(int16_t *col)
  172. {
  173.         int a0, a1, a2, a3, b0, b1, b2, b3;
  174.  
  175.         col[0] += (1 << (COL_SHIFT - 1)) / W4;
  176.  
  177.         a0 = W4 * col[8 * 0];
  178.         a1 = W4 * col[8 * 0];
  179.         a2 = W4 * col[8 * 0];
  180.         a3 = W4 * col[8 * 0];
  181.  
  182.         if (col[8 * 2]) {
  183.                 a0 += W2 * col[8 * 2];
  184.                 a1 += W6 * col[8 * 2];
  185.                 a2 -= W6 * col[8 * 2];
  186.                 a3 -= W2 * col[8 * 2];
  187.         }
  188.  
  189.         if (col[8 * 4]) {
  190.                 a0 += W4 * col[8 * 4];
  191.                 a1 -= W4 * col[8 * 4];
  192.                 a2 -= W4 * col[8 * 4];
  193.                 a3 += W4 * col[8 * 4];
  194.         }
  195.  
  196.         if (col[8 * 6]) {
  197.                 a0 += W6 * col[8 * 6];
  198.                 a1 -= W2 * col[8 * 6];
  199.                 a2 += W2 * col[8 * 6];
  200.                 a3 -= W6 * col[8 * 6];
  201.         }
  202.  
  203.         if (col[8 * 1]) {
  204.                 b0 = W1 * col[8 * 1];
  205.                 b1 = W3 * col[8 * 1];
  206.                 b2 = W5 * col[8 * 1];
  207.                 b3 = W7 * col[8 * 1];
  208.         } else {
  209.                 b0 = b1 = b2 = b3 = 0;
  210.         }
  211.  
  212.         if (col[8 * 3]) {
  213.                 b0 += W3 * col[8 * 3];
  214.                 b1 -= W7 * col[8 * 3];
  215.                 b2 -= W1 * col[8 * 3];
  216.                 b3 -= W5 * col[8 * 3];
  217.         }
  218.  
  219.         if (col[8 * 5]) {
  220.                 b0 += W5 * col[8 * 5];
  221.                 b1 -= W1 * col[8 * 5];
  222.                 b2 += W7 * col[8 * 5];
  223.                 b3 += W3 * col[8 * 5];
  224.         }
  225.  
  226.         if (col[8 * 7]) {
  227.                 b0 += W7 * col[8 * 7];
  228.                 b1 -= W5 * col[8 * 7];
  229.                 b2 += W3 * col[8 * 7];
  230.                 b3 -= W1 * col[8 * 7];
  231.         }
  232.  
  233.         col[8 * 0] = (a0 + b0) >> COL_SHIFT;
  234.         col[8 * 7] = (a0 - b0) >> COL_SHIFT;
  235.         col[8 * 1] = (a1 + b1) >> COL_SHIFT;
  236.         col[8 * 6] = (a1 - b1) >> COL_SHIFT;
  237.         col[8 * 2] = (a2 + b2) >> COL_SHIFT;
  238.         col[8 * 5] = (a2 - b2) >> COL_SHIFT;
  239.         col[8 * 3] = (a3 + b3) >> COL_SHIFT;
  240.         col[8 * 4] = (a3 - b3) >> COL_SHIFT;
  241. }
  242.  
  243. #else  /* not ARCH_ALPHA */
  244.  
  245. static inline void idctRowCondDC (int16_t * row)
  246. {
  247.     int a0, a1, a2, a3, b0, b1, b2, b3;
  248. #ifdef FAST_64BIT
  249.         uint64_t temp;
  250. #else
  251.         uint32_t temp;
  252. #endif
  253.  
  254. #ifdef FAST_64BIT
  255. #ifdef WORDS_BIGENDIAN
  256. #define ROW0_MASK 0xffff000000000000LL
  257. #else
  258. #define ROW0_MASK 0xffffLL
  259. #endif
  260.     if ( ((((uint64_t *)row)[0] & ~ROW0_MASK) | 
  261.               ((uint64_t *)row)[1]) == 0) {
  262.             temp = (row[0] << 3) & 0xffff;
  263.             temp += temp << 16;
  264.             temp += temp << 32;
  265.             ((uint64_t *)row)[0] = temp;
  266.             ((uint64_t *)row)[1] = temp;
  267.             return;
  268.     }
  269. #else
  270.     if (!(((uint32_t*)row)[1] |
  271.               ((uint32_t*)row)[2] |
  272.               ((uint32_t*)row)[3] | 
  273.               row[1])) {
  274.             temp = (row[0] << 3) & 0xffff;
  275.             temp += temp << 16;
  276.             ((uint32_t*)row)[0]=((uint32_t*)row)[1] =
  277.         ((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;
  278.         return;
  279.     }
  280. #endif
  281.  
  282.         a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
  283.     a1 = a0;
  284.     a2 = a0;
  285.     a3 = a0;
  286.  
  287.         /* no need to optimize : gcc does it */
  288.         a0 += W2 * row[2];
  289.         a1 += W6 * row[2];
  290.         a2 -= W6 * row[2];
  291.         a3 -= W2 * row[2];
  292.  
  293.         MUL16(b0, W1, row[1]);
  294.         MAC16(b0, W3, row[3]);
  295.         MUL16(b1, W3, row[1]);
  296.         MAC16(b1, -W7, row[3]);
  297.         MUL16(b2, W5, row[1]);
  298.         MAC16(b2, -W1, row[3]);
  299.         MUL16(b3, W7, row[1]);
  300.         MAC16(b3, -W5, row[3]);
  301.  
  302. #ifdef FAST_64BIT
  303.         temp = ((uint64_t*)row)[1];
  304. #else
  305.         temp = ((uint32_t*)row)[2] | ((uint32_t*)row)[3];
  306. #endif
  307.     if (temp != 0) {
  308.             a0 += W4*row[4] + W6*row[6];
  309.             a1 += - W4*row[4] - W2*row[6];
  310.             a2 += - W4*row[4] + W2*row[6];
  311.             a3 += W4*row[4] - W6*row[6];
  312.  
  313.             MAC16(b0, W5, row[5]);
  314.             MAC16(b0, W7, row[7]);
  315.             
  316.             MAC16(b1, -W1, row[5]);
  317.             MAC16(b1, -W5, row[7]);
  318.             
  319.             MAC16(b2, W7, row[5]);
  320.             MAC16(b2, W3, row[7]);
  321.             
  322.             MAC16(b3, W3, row[5]);
  323.             MAC16(b3, -W1, row[7]);
  324.     }
  325.  
  326.     row[0] = (a0 + b0) >> ROW_SHIFT;
  327.     row[7] = (a0 - b0) >> ROW_SHIFT;
  328.     row[1] = (a1 + b1) >> ROW_SHIFT;
  329.     row[6] = (a1 - b1) >> ROW_SHIFT;
  330.     row[2] = (a2 + b2) >> ROW_SHIFT;
  331.     row[5] = (a2 - b2) >> ROW_SHIFT;
  332.     row[3] = (a3 + b3) >> ROW_SHIFT;
  333.     row[4] = (a3 - b3) >> ROW_SHIFT;
  334. }
  335. #endif /* not ARCH_ALPHA */
  336.  
  337. static inline void idctSparseColPut (UINT8 *dest, int line_size, 
  338.                                      int16_t * col)
  339. {
  340.     int a0, a1, a2, a3, b0, b1, b2, b3;
  341.         UINT8 *cm = cropTbl + MAX_NEG_CROP;
  342.  
  343.         /* XXX: I did that only to give same values as previous code */
  344.     a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
  345.     a1 = a0;
  346.     a2 = a0;
  347.     a3 = a0;
  348.  
  349.         a0 +=  + W2*col[8*2];
  350.         a1 +=  + W6*col[8*2];
  351.         a2 +=  - W6*col[8*2];
  352.         a3 +=  - W2*col[8*2];
  353.  
  354.         MUL16(b0, W1, col[8*1]);
  355.         MUL16(b1, W3, col[8*1]);
  356.         MUL16(b2, W5, col[8*1]);
  357.         MUL16(b3, W7, col[8*1]);
  358.  
  359.         MAC16(b0, + W3, col[8*3]);
  360.         MAC16(b1, - W7, col[8*3]);
  361.         MAC16(b2, - W1, col[8*3]);
  362.         MAC16(b3, - W5, col[8*3]);
  363.  
  364.     if(col[8*4]){
  365.             a0 += + W4*col[8*4];
  366.             a1 += - W4*col[8*4];
  367.             a2 += - W4*col[8*4];
  368.             a3 += + W4*col[8*4];
  369.     }
  370.  
  371.     if (col[8*5]) {
  372.             MAC16(b0, + W5, col[8*5]);
  373.             MAC16(b1, - W1, col[8*5]);
  374.             MAC16(b2, + W7, col[8*5]);
  375.             MAC16(b3, + W3, col[8*5]);
  376.     }
  377.  
  378.     if(col[8*6]){
  379.             a0 += + W6*col[8*6];
  380.             a1 += - W2*col[8*6];
  381.             a2 += + W2*col[8*6];
  382.             a3 += - W6*col[8*6];
  383.     }
  384.  
  385.     if (col[8*7]) {
  386.             MAC16(b0, + W7, col[8*7]);
  387.             MAC16(b1, - W5, col[8*7]);
  388.             MAC16(b2, + W3, col[8*7]);
  389.             MAC16(b3, - W1, col[8*7]);
  390.     }
  391.  
  392.         dest[0] = cm[(a0 + b0) >> COL_SHIFT];
  393.         dest += line_size;
  394.         dest[0] = cm[(a1 + b1) >> COL_SHIFT];
  395.         dest += line_size;
  396.         dest[0] = cm[(a2 + b2) >> COL_SHIFT];
  397.         dest += line_size;
  398.         dest[0] = cm[(a3 + b3) >> COL_SHIFT];
  399.         dest += line_size;
  400.         dest[0] = cm[(a3 - b3) >> COL_SHIFT];
  401.         dest += line_size;
  402.         dest[0] = cm[(a2 - b2) >> COL_SHIFT];
  403.         dest += line_size;
  404.         dest[0] = cm[(a1 - b1) >> COL_SHIFT];
  405.         dest += line_size;
  406.         dest[0] = cm[(a0 - b0) >> COL_SHIFT];
  407. }
  408.  
  409. static inline void idctSparseColAdd (UINT8 *dest, int line_size, 
  410.                                      int16_t * col)
  411. {
  412.     int a0, a1, a2, a3, b0, b1, b2, b3;
  413.         UINT8 *cm = cropTbl + MAX_NEG_CROP;
  414.  
  415.         /* XXX: I did that only to give same values as previous code */
  416.     a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
  417.     a1 = a0;
  418.     a2 = a0;
  419.     a3 = a0;
  420.  
  421.         a0 +=  + W2*col[8*2];
  422.         a1 +=  + W6*col[8*2];
  423.         a2 +=  - W6*col[8*2];
  424.         a3 +=  - W2*col[8*2];
  425.  
  426.         MUL16(b0, W1, col[8*1]);
  427.         MUL16(b1, W3, col[8*1]);
  428.         MUL16(b2, W5, col[8*1]);
  429.         MUL16(b3, W7, col[8*1]);
  430.  
  431.         MAC16(b0, + W3, col[8*3]);
  432.         MAC16(b1, - W7, col[8*3]);
  433.         MAC16(b2, - W1, col[8*3]);
  434.         MAC16(b3, - W5, col[8*3]);
  435.  
  436.     if(col[8*4]){
  437.             a0 += + W4*col[8*4];
  438.             a1 += - W4*col[8*4];
  439.             a2 += - W4*col[8*4];
  440.             a3 += + W4*col[8*4];
  441.     }
  442.  
  443.     if (col[8*5]) {
  444.             MAC16(b0, + W5, col[8*5]);
  445.             MAC16(b1, - W1, col[8*5]);
  446.             MAC16(b2, + W7, col[8*5]);
  447.             MAC16(b3, + W3, col[8*5]);
  448.     }
  449.  
  450.     if(col[8*6]){
  451.             a0 += + W6*col[8*6];
  452.             a1 += - W2*col[8*6];
  453.             a2 += + W2*col[8*6];
  454.             a3 += - W6*col[8*6];
  455.     }
  456.  
  457.     if (col[8*7]) {
  458.             MAC16(b0, + W7, col[8*7]);
  459.             MAC16(b1, - W5, col[8*7]);
  460.             MAC16(b2, + W3, col[8*7]);
  461.             MAC16(b3, - W1, col[8*7]);
  462.     }
  463.  
  464.         dest[0] = cm[dest[0] + ((a0 + b0) >> COL_SHIFT)];
  465.         dest += line_size;
  466.         dest[0] = cm[dest[0] + ((a1 + b1) >> COL_SHIFT)];
  467.         dest += line_size;
  468.         dest[0] = cm[dest[0] + ((a2 + b2) >> COL_SHIFT)];
  469.         dest += line_size;
  470.         dest[0] = cm[dest[0] + ((a3 + b3) >> COL_SHIFT)];
  471.         dest += line_size;
  472.         dest[0] = cm[dest[0] + ((a3 - b3) >> COL_SHIFT)];
  473.         dest += line_size;
  474.         dest[0] = cm[dest[0] + ((a2 - b2) >> COL_SHIFT)];
  475.         dest += line_size;
  476.         dest[0] = cm[dest[0] + ((a1 - b1) >> COL_SHIFT)];
  477.         dest += line_size;
  478.         dest[0] = cm[dest[0] + ((a0 - b0) >> COL_SHIFT)];
  479. }
  480.  
  481. #ifdef ARCH_ALPHA
  482. /* If all rows but the first one are zero after row transformation,
  483.    all rows will be identical after column transformation.  */
  484. static inline void idctCol2(int16_t *col)
  485. {
  486.     int i;
  487.     uint64_t l, r;
  488.     uint64_t *lcol = (uint64_t *) col;
  489.  
  490.     for (i = 0; i < 8; ++i) {
  491.         int a0 = col[0] + (1 << (COL_SHIFT - 1)) / W4;
  492.  
  493.         a0 *= W4;
  494.         col[0] = a0 >> COL_SHIFT;
  495.         ++col;
  496.     }
  497.  
  498.     l = lcol[0];
  499.     r = lcol[1];
  500.     lcol[ 2] = l; lcol[ 3] = r;
  501.     lcol[ 4] = l; lcol[ 5] = r;
  502.     lcol[ 6] = l; lcol[ 7] = r;
  503.     lcol[ 8] = l; lcol[ 9] = r;
  504.     lcol[10] = l; lcol[11] = r;
  505.     lcol[12] = l; lcol[13] = r;
  506.     lcol[14] = l; lcol[15] = r;
  507. }
  508.  
  509. void simple_idct (short *block)
  510. {
  511.  
  512.     int i;
  513.         int rowsZero = 1;       /* all rows except row 0 zero */
  514.         int rowsConstant = 1;    /* all rows consist of a constant value */
  515.  
  516.     for (i = 0; i < 8; i++) {
  517.         int sparseness = idctRowCondDC(block + 8 * i);
  518.  
  519.         if (i > 0 && sparseness > 0)
  520.                         rowsZero = 0;
  521.                 if (sparseness == 2)
  522.                         rowsConstant = 0;
  523.     }
  524.  
  525.         if (rowsZero) {
  526.                 idctCol2(block);
  527.         } else if (rowsConstant) {
  528.         uint64_t *lblock = (uint64_t *) block;
  529.  
  530.         idctSparseCol(block);
  531.         for (i = 0; i < 8; i++) {
  532.             uint64_t v = (uint16_t) block[i * 8];
  533.  
  534.             v += v << 16;
  535.             v += v << 32;
  536.             lblock[0] = v;
  537.             lblock[1] = v;
  538.             lblock += 2;
  539.         }
  540.     } else {
  541.         for (i = 0; i < 8; i++)
  542.             idctSparseCol(block + i);
  543.     }
  544. }
  545.  
  546. /* XXX: suppress this mess */
  547. void simple_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
  548. {
  549.     simple_idct(block);
  550.     put_pixels_clamped(block, dest, line_size);
  551. }
  552.  
  553. void simple_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
  554. {
  555.     simple_idct(block);
  556.     add_pixels_clamped(block, dest, line_size);
  557. }
  558.  
  559. #else
  560.  
  561. void simple_idct_put(UINT8 *dest, int line_size, INT16 *block)
  562. {
  563.     int i;
  564.     for(i=0; i<8; i++)
  565.         idctRowCondDC(block + i*8);
  566.     
  567.     for(i=0; i<8; i++)
  568.         idctSparseColPut(dest + i, line_size, block + i);
  569. }
  570.  
  571. void simple_idct_add(UINT8 *dest, int line_size, INT16 *block)
  572. {
  573.     int i;
  574.     for(i=0; i<8; i++)
  575.         idctRowCondDC(block + i*8);
  576.     
  577.     for(i=0; i<8; i++)
  578.         idctSparseColAdd(dest + i, line_size, block + i);
  579. }
  580.  
  581. #endif
  582.  
  583. #undef COL_SHIFT
  584.