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

664 lines
16KB
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. //#define ARCH_ALPHA

  29. 

  30. #if 0

  31. #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */

  32. #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */

  33. #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */

  34. #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */

  35. #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */

  36. #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */

  37. #define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */

  38. #define ROW_SHIFT 8

  39. #define COL_SHIFT 17

  40. #else

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

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

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

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

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

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

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

  48. #define ROW_SHIFT 11

  49. #define COL_SHIFT 20 // 6

  50. #endif

  51. 

  52. #ifdef ARCH_ALPHA

  53. #define FAST_64BIT

  54. #endif

  55. 

  56. #if defined(ARCH_POWERPC_405)

  57. 

  58. /* signed 16x16 -> 32 multiply add accumulate */

  59. #define MAC16(rt, ra, rb) \

  60.     asm ("maclhw %0, %2, %3" : "=r" (rt) : "0" (rt), "r" (ra), "r" (rb));

  61. 

  62. /* signed 16x16 -> 32 multiply */

  63. #define MUL16(rt, ra, rb) \

  64.     asm ("mullhw %0, %1, %2" : "=r" (rt) : "r" (ra), "r" (rb));

  65. 

  66. #else

  67. 

  68. /* signed 16x16 -> 32 multiply add accumulate */

  69. #define MAC16(rt, ra, rb) rt += (ra) * (rb)

  70. 

  71. /* signed 16x16 -> 32 multiply */

  72. #define MUL16(rt, ra, rb) rt = (ra) * (rb)

  73. 

  74. #endif

  75. 

  76. #ifdef ARCH_ALPHA

  77. /* 0: all entries 0, 1: only first entry nonzero, 2: otherwise  */

  78. static inline int idctRowCondDC(int16_t *row)

  79. {

  80. 	int_fast32_t a0, a1, a2, a3, b0, b1, b2, b3;

  81. 	uint64_t *lrow = (uint64_t *) row;

  82. 

  83. 	if (lrow[1] == 0) {

  84. 		if (lrow[0] == 0)

  85. 			return 0;

  86. 		if ((lrow[0] & ~0xffffULL) == 0) {

  87. 			uint64_t v;

  88. #if 1			//is ok if |a0| < 1024 than theres an +-1 error (for the *W4 case for W4=16383 !!!)

  89. 			a0 = row[0]<<3;

  90. #else

  91. 			a0 = W4 * row[0];

  92. 			a0 += 1 << (ROW_SHIFT - 1);

  93. 			a0 >>= ROW_SHIFT;

  94. #endif

  95. 			v = (uint16_t) a0;

  96. 			v += v << 16;

  97. 			v += v << 32;

  98. 			lrow[0] = v;

  99. 			lrow[1] = v;

  100. 

  101. 			return 1;

  102. 		}

  103. 	}

  104. 

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

  106. 	a1 = a0;

  107. 	a2 = a0;

  108. 	a3 = a0;

  109. 

  110. 	if (row[2]) {

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

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

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

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

  115. 	}

  116. 

  117. 	if (row[4]) {

  118. 		a0 += W4 * row[4];

  119. 		a1 -= W4 * row[4];

  120. 		a2 -= W4 * row[4];

  121. 		a3 += W4 * row[4];

  122. 	}

  123. 

  124. 	if (row[6]) {

  125. 		a0 += W6 * row[6];

  126. 		a1 -= W2 * row[6];

  127. 		a2 += W2 * row[6];

  128. 		a3 -= W6 * row[6];

  129. 	}

  130. 

  131. 	if (row[1]) {

  132. 		b0 = W1 * row[1];

  133. 		b1 = W3 * row[1];

  134. 		b2 = W5 * row[1];

  135. 		b3 = W7 * row[1];

  136. 	} else {

  137. 		b0 = 0;

  138. 		b1 = 0;

  139. 		b2 = 0;

  140. 		b3 = 0;

  141. 	}

  142. 

  143. 	if (row[3]) {

  144. 		b0 += W3 * row[3];

  145. 		b1 -= W7 * row[3];

  146. 		b2 -= W1 * row[3];

  147. 		b3 -= W5 * row[3];

  148. 	}

  149. 

  150. 	if (row[5]) {

  151. 		b0 += W5 * row[5];

  152. 		b1 -= W1 * row[5];

  153. 		b2 += W7 * row[5];

  154. 		b3 += W3 * row[5];

  155. 	}

  156. 

  157. 	if (row[7]) {

  158. 		b0 += W7 * row[7];

  159. 		b1 -= W5 * row[7];

  160. 		b2 += W3 * row[7];

  161. 		b3 -= W1 * row[7];

  162. 	}

  163. 

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

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

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

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

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

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

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

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

  172. 

  173. 	return 2;

  174. }

  175. 

  176. inline static void idctSparseCol(int16_t *col)

  177. {

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

  179. 

  180.         col[0] += (1 << (COL_SHIFT - 1)) / W4;

  181. 

  182.         a0 = W4 * col[8 * 0];

  183.         a1 = W4 * col[8 * 0];

  184.         a2 = W4 * col[8 * 0];

  185.         a3 = W4 * col[8 * 0];

  186. 

  187.         if (col[8 * 2]) {

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

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

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

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

  192.         }

  193. 

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

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

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

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

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

  199.         }

  200. 

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

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

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

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

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

  206.         }

  207. 

  208.         if (col[8 * 1]) {

  209.                 b0 = W1 * col[8 * 1];

  210.                 b1 = W3 * col[8 * 1];

  211.                 b2 = W5 * col[8 * 1];

  212.                 b3 = W7 * col[8 * 1];

  213.         } else {

  214.                 b0 = b1 = b2 = b3 = 0;

  215.         }

  216. 

  217.         if (col[8 * 3]) {

  218.                 b0 += W3 * col[8 * 3];

  219.                 b1 -= W7 * col[8 * 3];

  220.                 b2 -= W1 * col[8 * 3];

  221.                 b3 -= W5 * col[8 * 3];

  222.         }

  223. 

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

  225.                 b0 += W5 * col[8 * 5];

  226.                 b1 -= W1 * col[8 * 5];

  227.                 b2 += W7 * col[8 * 5];

  228.                 b3 += W3 * col[8 * 5];

  229.         }

  230. 

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

  232.                 b0 += W7 * col[8 * 7];

  233.                 b1 -= W5 * col[8 * 7];

  234.                 b2 += W3 * col[8 * 7];

  235.                 b3 -= W1 * col[8 * 7];

  236.         }

  237. 

  238.         col[8 * 0] = (a0 + b0) >> COL_SHIFT;

  239.         col[8 * 7] = (a0 - b0) >> COL_SHIFT;

  240.         col[8 * 1] = (a1 + b1) >> COL_SHIFT;

  241.         col[8 * 6] = (a1 - b1) >> COL_SHIFT;

  242.         col[8 * 2] = (a2 + b2) >> COL_SHIFT;

  243.         col[8 * 5] = (a2 - b2) >> COL_SHIFT;

  244.         col[8 * 3] = (a3 + b3) >> COL_SHIFT;

  245.         col[8 * 4] = (a3 - b3) >> COL_SHIFT;

  246. }

  247. 

  248. #else  /* not ARCH_ALPHA */

  249. 

  250. static inline void idctRowCondDC (int16_t * row)

  251. {

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

  253. #ifdef FAST_64BIT

  254.         uint64_t temp;

  255. #else

  256.         uint32_t temp;

  257. #endif

  258. 

  259. #ifdef FAST_64BIT

  260. #ifdef WORDS_BIGENDIAN

  261. #define ROW0_MASK 0xffff000000000000LL

  262. #else

  263. #define ROW0_MASK 0xffffLL

  264. #endif

  265. 	if ( ((((uint64_t *)row)[0] & ~ROW0_MASK) | 

  266.               ((uint64_t *)row)[1]) == 0) {

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

  268.             temp += temp << 16;

  269.             temp += temp << 32;

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

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

  272.             return;

  273. 	}

  274. #else

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

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

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

  278.               row[1])) {

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

  280.             temp += temp << 16;

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

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

  283. 		return;

  284. 	}

  285. #endif

  286. 

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

  288. 	a1 = a0;

  289. 	a2 = a0;

  290. 	a3 = a0;

  291. 

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

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

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

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

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

  297. 

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

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

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

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

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

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

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

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

  306. 

  307. #ifdef FAST_64BIT

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

  309. #else

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

  311. #endif

  312. 	if (temp != 0) {

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

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

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

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

  317. 

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

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

  320.             

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

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

  323.             

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

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

  326.             

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

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

  329. 	}

  330. 

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

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

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

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

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

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

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

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

  339. }

  340. #endif /* not ARCH_ALPHA */

  341. 

  342. static inline void idctSparseColPut (UINT8 *dest, int line_size, 

  343.                                      int16_t * col)

  344. {

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

  346.         UINT8 *cm = cropTbl + MAX_NEG_CROP;

  347. 

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

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

  350. 	a1 = a0;

  351. 	a2 = a0;

  352. 	a3 = a0;

  353. 

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

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

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

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

  358. 

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

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

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

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

  363. 

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

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

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

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

  368. 

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

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

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

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

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

  374. 	}

  375. 

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

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

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

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

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

  381. 	}

  382. 

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

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

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

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

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

  388. 	}

  389. 

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

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

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

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

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

  395. 	}

  396. 

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

  398.         dest += line_size;

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

  400.         dest += line_size;

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

  402.         dest += line_size;

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

  404.         dest += line_size;

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

  406.         dest += line_size;

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

  408.         dest += line_size;

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

  410.         dest += line_size;

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

  412. }

  413. 

  414. static inline void idctSparseColAdd (UINT8 *dest, int line_size, 

  415.                                      int16_t * col)

  416. {

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

  418.         UINT8 *cm = cropTbl + MAX_NEG_CROP;

  419. 

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

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

  422. 	a1 = a0;

  423. 	a2 = a0;

  424. 	a3 = a0;

  425. 

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

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

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

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

  430. 

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

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

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

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

  435. 

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

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

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

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

  440. 

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

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

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

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

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

  446. 	}

  447. 

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

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

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

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

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

  453. 	}

  454. 

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

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

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

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

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

  460. 	}

  461. 

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

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

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

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

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

  467. 	}

  468. 

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

  470.         dest += line_size;

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

  472.         dest += line_size;

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

  474.         dest += line_size;

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

  476.         dest += line_size;

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

  478.         dest += line_size;

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

  480.         dest += line_size;

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

  482.         dest += line_size;

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

  484. }

  485. 

  486. static inline void idctSparseCol (int16_t * col)

  487. {

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

  489.         UINT8 *cm = cropTbl + MAX_NEG_CROP;

  490. 

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

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

  493. 	a1 = a0;

  494. 	a2 = a0;

  495. 	a3 = a0;

  496. 

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

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

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

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

  501. 

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

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

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

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

  506. 

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

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

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

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

  511. 

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

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

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

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

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

  517. 	}

  518. 

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

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

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

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

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

  524. 	}

  525. 

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

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

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

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

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

  531. 	}

  532. 

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

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

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

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

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

  538. 	}

  539. 

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

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

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

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

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

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

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

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

  548. }

  549. 

  550. 

  551. #ifdef ARCH_ALPHA

  552. /* If all rows but the first one are zero after row transformation,

  553.    all rows will be identical after column transformation.  */

  554. static inline void idctCol2(int16_t *col)

  555. {

  556. 	int i;

  557. 	uint64_t l, r;

  558. 	uint64_t *lcol = (uint64_t *) col;

  559. 

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

  561. 		int a0 = col[0] + (1 << (COL_SHIFT - 1)) / W4;

  562. 

  563. 		a0 *= W4;

  564. 		col[0] = a0 >> COL_SHIFT;

  565. 		++col;

  566. 	}

  567. 

  568. 	l = lcol[0];

  569. 	r = lcol[1];

  570. 	lcol[ 2] = l; lcol[ 3] = r;

  571. 	lcol[ 4] = l; lcol[ 5] = r;

  572. 	lcol[ 6] = l; lcol[ 7] = r;

  573. 	lcol[ 8] = l; lcol[ 9] = r;

  574. 	lcol[10] = l; lcol[11] = r;

  575. 	lcol[12] = l; lcol[13] = r;

  576. 	lcol[14] = l; lcol[15] = r;

  577. }

  578. 

  579. void simple_idct (short *block)

  580. {

  581. 

  582. 	int i;

  583.         int rowsZero = 1;       /* all rows except row 0 zero */

  584.         int rowsConstant = 1;	/* all rows consist of a constant value */

  585. 

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

  587. 		int sparseness = idctRowCondDC(block + 8 * i);

  588. 

  589. 		if (i > 0 && sparseness > 0)

  590.                         rowsZero = 0;

  591.                 if (sparseness == 2)

  592.                         rowsConstant = 0;

  593. 	}

  594. 

  595.         if (rowsZero) {

  596.                 idctCol2(block);

  597.         } else if (rowsConstant) {

  598. 		uint64_t *lblock = (uint64_t *) block;

  599. 

  600. 		idctSparseCol(block);

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

  602. 			uint64_t v = (uint16_t) block[i * 8];

  603. 

  604. 			v += v << 16;

  605. 			v += v << 32;

  606. 			lblock[0] = v;

  607. 			lblock[1] = v;

  608. 			lblock += 2;

  609. 		}

  610. 	} else {

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

  612. 			idctSparseCol(block + i);

  613. 	}

  614. }

  615. 

  616. /* XXX: suppress this mess */

  617. void simple_idct_put(UINT8 *dest, int line_size, DCTELEM *block)

  618. {

  619.     simple_idct(block);

  620.     put_pixels_clamped(block, dest, line_size);

  621. }

  622. 

  623. void simple_idct_add(UINT8 *dest, int line_size, DCTELEM *block)

  624. {

  625.     simple_idct(block);

  626.     add_pixels_clamped(block, dest, line_size);

  627. }

  628. 

  629. #else

  630. 

  631. void simple_idct_put(UINT8 *dest, int line_size, INT16 *block)

  632. {

  633.     int i;

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

  635.         idctRowCondDC(block + i*8);

  636.     

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

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

  639. }

  640. 

  641. void simple_idct_add(UINT8 *dest, int line_size, INT16 *block)

  642. {

  643.     int i;

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

  645.         idctRowCondDC(block + i*8);

  646.     

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

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

  649. }

  650. 

  651. void simple_idct(INT16 *block)

  652. {

  653.     int i;

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

  655.         idctRowCondDC(block + i*8);

  656.     

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

  658.         idctSparseCol(block + i);

  659. }

  660. 

  661. #endif

  662. 

  663. #undef COL_SHIFT