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

584 lines
14KB
Raw Blame History 

  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