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

589 lines
14KB
Raw Blame History 

  1. /*

  2.     Copyright (C) 2001 Michael Niedermayer (michaelni@gmx.at)

  3. 

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

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

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

  7.     (at your option) any later version.

  8. 

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

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

  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12.     GNU General Public License for more details.

  13. 

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

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

  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  17. */

  18. 

  19. /*

  20.   based upon some outcommented c code from mpeg2dec (idct_mmx.c written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)

  21. */

  22. 

  23. #include "avcodec.h"

  24. 

  25. #include "simple_idct.h"

  26. 

  27. #if 0

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

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

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

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

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

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

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

  35. #define ROW_SHIFT 8

  36. #define COL_SHIFT 17

  37. #else

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

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

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

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

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

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

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

  45. #define ROW_SHIFT 11

  46. #define COL_SHIFT 20 // 6

  47. #endif

  48. 

  49. /* 8x8 Matrix used to do a trivial (slow) 8 point IDCT */

  50. static int coeff[64]={

  51. 	W4, W4, W4, W4, W4, W4, W4, W4,

  52. 	W1, W3, W5, W7,-W7,-W5,-W3,-W1,

  53. 	W2, W6,-W6,-W2,-W2,-W6, W6, W2,

  54. 	W3,-W7,-W1,-W5, W5, W1, W7,-W3,

  55. 	W4,-W4,-W4, W4, W4,-W4,-W4, W4,

  56. 	W5,-W1, W7, W3,-W3,-W7, W1,-W5,

  57. 	W6,-W2, W2,-W6,-W6, W2,-W2, W6,

  58. 	W7,-W5, W3,-W1, W1,-W3, W5,-W7

  59. };

  60. 

  61. static int inline idctRowCondZ (int16_t * row)

  62. {

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

  64. 

  65. 	if( !( ((uint32_t*)row)[0]|((uint32_t*)row)[1] |((uint32_t*)row)[2] |((uint32_t*)row)[3])) {

  66. /*		row[0] = row[1] = row[2] = row[3] = row[4] =

  67. 			row[5] = row[6] = row[7] = 0;*/

  68. 		return 0;

  69. 	}

  70. 

  71. 	if(!( ((uint32_t*)row)[2] |((uint32_t*)row)[3] )){

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

  73. 		a1 = W4*row[0] + W6*row[2] + (1<<(ROW_SHIFT-1));

  74. 		a2 = W4*row[0] - W6*row[2] + (1<<(ROW_SHIFT-1));

  75. 		a3 = W4*row[0] - W2*row[2] + (1<<(ROW_SHIFT-1));

  76. 

  77. 		b0 = W1*row[1] + W3*row[3];

  78. 		b1 = W3*row[1] - W7*row[3];

  79. 		b2 = W5*row[1] - W1*row[3];

  80. 		b3 = W7*row[1] - W5*row[3];

  81. 	}else{

  82. 		a0 = W4*row[0] + W2*row[2] + W4*row[4] + W6*row[6] + (1<<(ROW_SHIFT-1));

  83. 		a1 = W4*row[0] + W6*row[2] - W4*row[4] - W2*row[6] + (1<<(ROW_SHIFT-1));

  84. 		a2 = W4*row[0] - W6*row[2] - W4*row[4] + W2*row[6] + (1<<(ROW_SHIFT-1));

  85. 		a3 = W4*row[0] - W2*row[2] + W4*row[4] - W6*row[6] + (1<<(ROW_SHIFT-1));

  86. 

  87. 		b0 = W1*row[1] + W3*row[3] + W5*row[5] + W7*row[7];

  88. 		b1 = W3*row[1] - W7*row[3] - W1*row[5] - W5*row[7];

  89. 		b2 = W5*row[1] - W1*row[3] + W7*row[5] + W3*row[7];

  90. 		b3 = W7*row[1] - W5*row[3] + W3*row[5] - W1*row[7];

  91. 	}

  92. 

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

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

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

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

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

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

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

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

  101. 	

  102. 	return 1;

  103. }

  104. 

  105. #ifdef ARCH_ALPHA

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

  107. static int inline idctRowCondDC(int16_t *row)

  108. {

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

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

  111. 

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

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

  114. 			return 0;

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

  116. 			uint64_t v;

  117. 

  118. 			a0 = W4 * row[0];

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

  120. 			a0 >>= ROW_SHIFT;

  121. 			v = (uint16_t) a0;

  122. 			v += v << 16;

  123. 			v += v << 32;

  124. 			lrow[0] = v;

  125. 			lrow[1] = v;

  126. 

  127. 			return 1;

  128. 		}

  129. 	}

  130. 

  131. 	a0 = W4 * row[0];

  132. 	a1 = W4 * row[0];

  133. 	a2 = W4 * row[0];

  134. 	a3 = W4 * row[0];

  135. 

  136. 	if (row[2]) {

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

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

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

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

  141. 	}

  142. 

  143. 	if (row[4]) {

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

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

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

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

  148. 	}

  149. 

  150. 	if (row[6]) {

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

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

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

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

  155. 	}

  156. 

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

  158. 	a1 += 1 << (ROW_SHIFT - 1);

  159. 	a2 += 1 << (ROW_SHIFT - 1);

  160. 	a3 += 1 << (ROW_SHIFT - 1);

  161. 

  162. 	if (row[1]) {

  163. 		b0 = W1 * row[1];

  164. 		b1 = W3 * row[1];

  165. 		b2 = W5 * row[1];

  166. 		b3 = W7 * row[1];

  167. 	} else {

  168. 		b0 = 0;

  169. 		b1 = 0;

  170. 		b2 = 0;

  171. 		b3 = 0;

  172. 	}

  173. 

  174. 	if (row[3]) {

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

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

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

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

  179. 	}

  180. 

  181. 	if (row[5]) {

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

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

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

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

  186. 	}

  187. 

  188. 	if (row[7]) {

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

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

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

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

  193. 	}

  194. 

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

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

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

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

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

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

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

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

  203. 

  204. 	return 2;

  205. }

  206. #else  /* not ARCH_ALPHA */

  207. static int inline idctRowCondDC (int16_t * row)

  208. {

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

  210. 

  211. 	if( !( ((uint32_t*)row)[1] |((uint32_t*)row)[2] |((uint32_t*)row)[3]| row[1])) {

  212. //		row[0] = row[1] = row[2] = row[3] = row[4] = row[5] = row[6] = row[7] = row[0]<<3;

  213. 		uint16_t temp= row[0]<<3;

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

  215. 		((uint32_t*)row)[2]=((uint32_t*)row)[3]= temp + (temp<<16);

  216. 		return 0;

  217. 	}

  218. 

  219. 	if(!( ((uint32_t*)row)[2] |((uint32_t*)row)[3] )){

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

  221. 		a1 = W4*row[0] + W6*row[2] + (1<<(ROW_SHIFT-1));

  222. 		a2 = W4*row[0] - W6*row[2] + (1<<(ROW_SHIFT-1));

  223. 		a3 = W4*row[0] - W2*row[2] + (1<<(ROW_SHIFT-1));

  224. 

  225. 		b0 = W1*row[1] + W3*row[3];

  226. 		b1 = W3*row[1] - W7*row[3];

  227. 		b2 = W5*row[1] - W1*row[3];

  228. 		b3 = W7*row[1] - W5*row[3];

  229. 	}else{

  230. 		a0 = W4*row[0] + W2*row[2] + W4*row[4] + W6*row[6] + (1<<(ROW_SHIFT-1));

  231. 		a1 = W4*row[0] + W6*row[2] - W4*row[4] - W2*row[6] + (1<<(ROW_SHIFT-1));

  232. 		a2 = W4*row[0] - W6*row[2] - W4*row[4] + W2*row[6] + (1<<(ROW_SHIFT-1));

  233. 		a3 = W4*row[0] - W2*row[2] + W4*row[4] - W6*row[6] + (1<<(ROW_SHIFT-1));

  234. 

  235. 		b0 = W1*row[1] + W3*row[3] + W5*row[5] + W7*row[7];

  236. 		b1 = W3*row[1] - W7*row[3] - W1*row[5] - W5*row[7];

  237. 		b2 = W5*row[1] - W1*row[3] + W7*row[5] + W3*row[7];

  238. 		b3 = W7*row[1] - W5*row[3] + W3*row[5] - W1*row[7];

  239. 	}

  240. 

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

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

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

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

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

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

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

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

  249. 	

  250. 	return 1;

  251. }

  252. #endif /* not ARCH_ALPHA */

  253. 

  254. static void inline idctCol (int16_t * col)

  255. {

  256. 

  257. /*

  258. 	if( !(col[8*1] | col[8*2] |col[8*3] |col[8*4] |col[8*5] |col[8*6] | col[8*7])) {

  259. 		col[8*0] = col[8*1] = col[8*2] = col[8*3] = col[8*4] =

  260. 			col[8*5] = col[8*6] = col[8*7] = col[8*0]<<3;

  261. 		return;

  262. 	}*/

  263. 

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

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

  266. 	a0 = W4*col[8*0] + W2*col[8*2] + W4*col[8*4] + W6*col[8*6];

  267. 	a1 = W4*col[8*0] + W6*col[8*2] - W4*col[8*4] - W2*col[8*6];

  268. 	a2 = W4*col[8*0] - W6*col[8*2] - W4*col[8*4] + W2*col[8*6];

  269. 	a3 = W4*col[8*0] - W2*col[8*2] + W4*col[8*4] - W6*col[8*6];

  270. 

  271. 	b0 = W1*col[8*1] + W3*col[8*3] + W5*col[8*5] + W7*col[8*7];

  272. 	b1 = W3*col[8*1] - W7*col[8*3] - W1*col[8*5] - W5*col[8*7];

  273. 	b2 = W5*col[8*1] - W1*col[8*3] + W7*col[8*5] + W3*col[8*7];

  274. 	b3 = W7*col[8*1] - W5*col[8*3] + W3*col[8*5] - W1*col[8*7];

  275. 

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

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

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

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

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

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

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

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

  284. }

  285. 

  286. static void inline idctSparseCol (int16_t * col)

  287. {

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

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

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

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

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

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

  294. 

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

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

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

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

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

  300. 	}

  301. 

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

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

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

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

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

  307. 	}

  308. 

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

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

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

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

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

  314. 	}

  315. 

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

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

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

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

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

  321. 	}else{

  322. 		b0 = 

  323. 		b1 = 

  324. 		b2 = 

  325. 		b3 = 0;

  326. 	}

  327. 

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

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

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

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

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

  333. 	}

  334. 

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

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

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

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

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

  340. 	}

  341. 

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

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

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

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

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

  347. 	}

  348. 

  349. #ifndef ARCH_ALPHA

  350. 	if(!(b0|b1|b2|b3)){

  351. 		col[8*0] = (a0) >> COL_SHIFT;

  352. 		col[8*7] = (a0) >> COL_SHIFT;

  353. 		col[8*1] = (a1) >> COL_SHIFT;

  354. 		col[8*6] = (a1) >> COL_SHIFT;

  355. 		col[8*2] = (a2) >> COL_SHIFT;

  356. 		col[8*5] = (a2) >> COL_SHIFT;

  357. 		col[8*3] = (a3) >> COL_SHIFT;

  358. 		col[8*4] = (a3) >> COL_SHIFT;

  359. 	}else{

  360. #endif

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

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

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

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

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

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

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

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

  369. #ifndef ARCH_ALPHA

  370. 	}

  371. #endif

  372. }

  373. 

  374. static void inline idctSparse2Col (int16_t * col)

  375. {

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

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

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

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

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

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

  382. 

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

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

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

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

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

  388. 	}

  389. 

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

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

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

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

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

  395. 	}

  396. 

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

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

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

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

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

  402. 	}

  403. 

  404. 	if(col[8*1] || 1){

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

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

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

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

  409. 	}else{

  410. 		b0 = 

  411. 		b1 = 

  412. 		b2 = 

  413. 		b3 = 0;

  414. 	}

  415. 

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

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

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

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

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

  421. 	}

  422. 

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

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

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

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

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

  428. 	}

  429. 

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

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

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

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

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

  435. 	}

  436. 

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

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

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

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

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

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

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

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

  445. }

  446. 

  447. #ifdef ARCH_ALPHA

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

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

  450. static inline void idctCol2(int16_t *col)

  451. {

  452. 	int i;

  453. 	uint64_t l, r;

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

  455. 

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

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

  458. 

  459. 		a0 *= W4;

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

  461. 		++col;

  462. 	}

  463. 

  464. 	l = lcol[0];

  465. 	r = lcol[1];

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

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

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

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

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

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

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

  473. }

  474. #endif

  475. 

  476. void simple_idct (short *block)

  477. {

  478. 

  479. 	int i;

  480. 	

  481. #if 0

  482. 	int nonZero[8];

  483. 	int buffer[64];

  484. 	int nNonZero=0;

  485. 	

  486. 	idctRowCondDC(block);

  487. 	

  488. 	for(i=1; i<8; i++)

  489. 	{

  490. 		nonZero[nNonZero]=i;

  491. 		nNonZero+= idctRowCondZ(block + i*8);

  492. 	}

  493. 	

  494. 	if(nNonZero==0)

  495. 	{

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

  497. 		{

  498. 			block[i   ]=

  499. 			block[i+8 ]=

  500. 			block[i+16]=

  501. 			block[i+24]=

  502. 			block[i+32]=

  503. 			block[i+40]=

  504. 			block[i+48]=

  505. 			block[i+56]= (W4*block[i] + (1<<(COL_SHIFT-1))) >> COL_SHIFT;

  506. 		}	

  507. 	}

  508. 	else if(nNonZero==1)

  509. 	{

  510. 		int index= nonZero[0]*8;

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

  512. 		{

  513. 			int bias= W4*block[i] + (1<<(COL_SHIFT-1));

  514. 			int c= block[i + index];

  515. 			block[i   ]= (c*coeff[index  ] + bias) >> COL_SHIFT;

  516. 			block[i+8 ]= (c*coeff[index+1] + bias) >> COL_SHIFT;

  517. 			block[i+16]= (c*coeff[index+2] + bias) >> COL_SHIFT;

  518. 			block[i+24]= (c*coeff[index+3] + bias) >> COL_SHIFT;

  519. 			block[i+32]= (c*coeff[index+4] + bias) >> COL_SHIFT;

  520. 			block[i+40]= (c*coeff[index+5] + bias) >> COL_SHIFT;

  521. 			block[i+48]= (c*coeff[index+6] + bias) >> COL_SHIFT;

  522. 			block[i+56]= (c*coeff[index+7] + bias) >> COL_SHIFT;

  523. 		}	

  524. 	}

  525. /*	else if(nNonZero==2)

  526. 	{

  527. 		int index1= nonZero[0]*8;

  528. 		int index2= nonZero[1]*8;

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

  530. 		{

  531. 			int bias= W4*block[i] + (1<<(COL_SHIFT-1));

  532. 			int c1= block[i + index1];

  533. 			int c2= block[i + index2];

  534. 			block[i   ]= (c1*coeff[index1  ] + c2*coeff[index2  ] + bias) >> COL_SHIFT;

  535. 			block[i+8 ]= (c1*coeff[index1+1] + c2*coeff[index2+1] + bias) >> COL_SHIFT;

  536. 			block[i+16]= (c1*coeff[index1+2] + c2*coeff[index2+2] + bias) >> COL_SHIFT;

  537. 			block[i+24]= (c1*coeff[index1+3] + c2*coeff[index2+3] + bias) >> COL_SHIFT;

  538. 			block[i+32]= (c1*coeff[index1+4] + c2*coeff[index2+4] + bias) >> COL_SHIFT;

  539. 			block[i+40]= (c1*coeff[index1+5] + c2*coeff[index2+5] + bias) >> COL_SHIFT;

  540. 			block[i+48]= (c1*coeff[index1+6] + c2*coeff[index2+6] + bias) >> COL_SHIFT;

  541. 			block[i+56]= (c1*coeff[index1+7] + c2*coeff[index2+7] + bias) >> COL_SHIFT;

  542. 		}	

  543. 	}*/

  544. 	else

  545. 	{

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

  547. 			idctSparse2Col(block + i);

  548. 	}

  549. #elif defined(ARCH_ALPHA)

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

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

  552. 

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

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

  555. 

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

  557.                         rowsZero = 0;

  558.                 if (sparseness == 2)

  559.                         rowsConstant = 0;

  560. 	}

  561. 

  562.         if (rowsZero) {

  563.                 idctCol2(block);

  564.         } else if (rowsConstant) {

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

  566. 

  567. 		idctSparseCol(block);

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

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

  570. 

  571. 			v += v << 16;

  572. 			v += v << 32;

  573. 			lblock[0] = v;

  574. 			lblock[1] = v;

  575. 			lblock += 2;

  576. 		}

  577. 	} else {

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

  579. 			idctSparseCol(block + i);

  580. 	}

  581. #else

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

  583. 		idctRowCondDC(block + i*8);

  584. 	

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

  586. 		idctSparseCol(block + i);

  587. #endif

  588. }