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
511MB
Tree: 789bee1264
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '789bee1264'
${ noResults }
FFmpeg/libavcodec/i386/idct_mmx.c

591 lines
18KB
Raw Blame History 

  1. /*

  2.  * Note: For libavcodec, this code can also be used under the LGPL license

  3.  */

  4. /*

  5.  * idct_mmx.c

  6.  * Copyright (C) 1999-2001 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>

  7.  *

  8.  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.

  9.  *

  10.  * mpeg2dec is free software; you can redistribute it and/or modify

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

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

  13.  * (at your option) any later version.

  14.  *

  15.  * mpeg2dec is distributed in the hope that it will be useful,

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

  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  18.  * GNU General Public License for more details.

  19.  *

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

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

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

  23.  */

  24. 

  25. #include "../common.h"

  26. 

  27. #include "mmx.h"

  28. 

  29. #define ATTR_ALIGN(align) __attribute__ ((__aligned__ (align)))

  30. 

  31. #define ROW_SHIFT 11

  32. #define COL_SHIFT 6

  33. 

  34. #define round(bias) ((int)(((bias)+0.5) * (1<<ROW_SHIFT)))

  35. #define rounder(bias) {round (bias), round (bias)}

  36. 

  37. #if 0

  38. /* C row IDCT - its just here to document the MMXEXT and MMX versions */

  39. static inline void idct_row (int16_t * row, int offset,

  40. 			     int16_t * table, int32_t * rounder)

  41. {

  42.     int C1, C2, C3, C4, C5, C6, C7;

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

  44. 

  45.     row += offset;

  46. 

  47.     C1 = table[1];

  48.     C2 = table[2];

  49.     C3 = table[3];

  50.     C4 = table[4];

  51.     C5 = table[5];

  52.     C6 = table[6];

  53.     C7 = table[7];

  54. 

  55.     a0 = C4*row[0] + C2*row[2] + C4*row[4] + C6*row[6] + *rounder;

  56.     a1 = C4*row[0] + C6*row[2] - C4*row[4] - C2*row[6] + *rounder;

  57.     a2 = C4*row[0] - C6*row[2] - C4*row[4] + C2*row[6] + *rounder;

  58.     a3 = C4*row[0] - C2*row[2] + C4*row[4] - C6*row[6] + *rounder;

  59. 

  60.     b0 = C1*row[1] + C3*row[3] + C5*row[5] + C7*row[7];

  61.     b1 = C3*row[1] - C7*row[3] - C1*row[5] - C5*row[7];

  62.     b2 = C5*row[1] - C1*row[3] + C7*row[5] + C3*row[7];

  63.     b3 = C7*row[1] - C5*row[3] + C3*row[5] - C1*row[7];

  64. 

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

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

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

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

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

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

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

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

  73. }

  74. #endif

  75. 

  76. 

  77. /* MMXEXT row IDCT */

  78. 

  79. #define mmxext_table(c1,c2,c3,c4,c5,c6,c7)	{  c4,  c2, -c4, -c2,	\

  80. 						   c4,  c6,  c4,  c6,	\

  81. 						   c1,  c3, -c1, -c5,	\

  82. 						   c5,  c7,  c3, -c7,	\

  83. 						   c4, -c6,  c4, -c6,	\

  84. 						  -c4,  c2,  c4, -c2,	\

  85. 						   c5, -c1,  c3, -c1,	\

  86. 						   c7,  c3,  c7, -c5 }

  87. 

  88. static inline void mmxext_row_head (int16_t * row, int offset, int16_t * table)

  89. {

  90.     movq_m2r (*(row+offset), mm2);	// mm2 = x6 x4 x2 x0

  91. 

  92.     movq_m2r (*(row+offset+4), mm5);	// mm5 = x7 x5 x3 x1

  93.     movq_r2r (mm2, mm0);		// mm0 = x6 x4 x2 x0

  94. 

  95.     movq_m2r (*table, mm3);		// mm3 = -C2 -C4 C2 C4

  96.     movq_r2r (mm5, mm6);		// mm6 = x7 x5 x3 x1

  97. 

  98.     movq_m2r (*(table+4), mm4);		// mm4 = C6 C4 C6 C4

  99.     pmaddwd_r2r (mm0, mm3);		// mm3 = -C4*x4-C2*x6 C4*x0+C2*x2

  100. 

  101.     pshufw_r2r (mm2, mm2, 0x4e);	// mm2 = x2 x0 x6 x4

  102. }

  103. 

  104. static inline void mmxext_row (int16_t * table, int32_t * rounder)

  105. {

  106.     movq_m2r (*(table+8), mm1);		// mm1 = -C5 -C1 C3 C1

  107.     pmaddwd_r2r (mm2, mm4);		// mm4 = C4*x0+C6*x2 C4*x4+C6*x6

  108. 

  109.     pmaddwd_m2r (*(table+16), mm0);	// mm0 = C4*x4-C6*x6 C4*x0-C6*x2

  110.     pshufw_r2r (mm6, mm6, 0x4e);	// mm6 = x3 x1 x7 x5

  111. 

  112.     movq_m2r (*(table+12), mm7);	// mm7 = -C7 C3 C7 C5

  113.     pmaddwd_r2r (mm5, mm1);		// mm1 = -C1*x5-C5*x7 C1*x1+C3*x3

  114. 

  115.     paddd_m2r (*rounder, mm3);		// mm3 += rounder

  116.     pmaddwd_r2r (mm6, mm7);		// mm7 = C3*x1-C7*x3 C5*x5+C7*x7

  117. 

  118.     pmaddwd_m2r (*(table+20), mm2);	// mm2 = C4*x0-C2*x2 -C4*x4+C2*x6

  119.     paddd_r2r (mm4, mm3);		// mm3 = a1 a0 + rounder

  120. 

  121.     pmaddwd_m2r (*(table+24), mm5);	// mm5 = C3*x5-C1*x7 C5*x1-C1*x3

  122.     movq_r2r (mm3, mm4);		// mm4 = a1 a0 + rounder

  123. 

  124.     pmaddwd_m2r (*(table+28), mm6);	// mm6 = C7*x1-C5*x3 C7*x5+C3*x7

  125.     paddd_r2r (mm7, mm1);		// mm1 = b1 b0

  126. 

  127.     paddd_m2r (*rounder, mm0);		// mm0 += rounder

  128.     psubd_r2r (mm1, mm3);		// mm3 = a1-b1 a0-b0 + rounder

  129. 

  130.     psrad_i2r (ROW_SHIFT, mm3);		// mm3 = y6 y7

  131.     paddd_r2r (mm4, mm1);		// mm1 = a1+b1 a0+b0 + rounder

  132. 

  133.     paddd_r2r (mm2, mm0);		// mm0 = a3 a2 + rounder

  134.     psrad_i2r (ROW_SHIFT, mm1);		// mm1 = y1 y0

  135. 

  136.     paddd_r2r (mm6, mm5);		// mm5 = b3 b2

  137.     movq_r2r (mm0, mm4);		// mm4 = a3 a2 + rounder

  138. 

  139.     paddd_r2r (mm5, mm0);		// mm0 = a3+b3 a2+b2 + rounder

  140.     psubd_r2r (mm5, mm4);		// mm4 = a3-b3 a2-b2 + rounder

  141. }

  142. 

  143. static inline void mmxext_row_tail (int16_t * row, int store)

  144. {

  145.     psrad_i2r (ROW_SHIFT, mm0);		// mm0 = y3 y2

  146. 

  147.     psrad_i2r (ROW_SHIFT, mm4);		// mm4 = y4 y5

  148. 

  149.     packssdw_r2r (mm0, mm1);		// mm1 = y3 y2 y1 y0

  150. 

  151.     packssdw_r2r (mm3, mm4);		// mm4 = y6 y7 y4 y5

  152. 

  153.     movq_r2m (mm1, *(row+store));	// save y3 y2 y1 y0

  154.     pshufw_r2r (mm4, mm4, 0xb1);	// mm4 = y7 y6 y5 y4

  155. 

  156.     /* slot */

  157. 

  158.     movq_r2m (mm4, *(row+store+4));	// save y7 y6 y5 y4

  159. }

  160. 

  161. static inline void mmxext_row_mid (int16_t * row, int store,

  162. 				   int offset, int16_t * table)

  163. {

  164.     movq_m2r (*(row+offset), mm2);	// mm2 = x6 x4 x2 x0

  165.     psrad_i2r (ROW_SHIFT, mm0);		// mm0 = y3 y2

  166. 

  167.     movq_m2r (*(row+offset+4), mm5);	// mm5 = x7 x5 x3 x1

  168.     psrad_i2r (ROW_SHIFT, mm4);		// mm4 = y4 y5

  169. 

  170.     packssdw_r2r (mm0, mm1);		// mm1 = y3 y2 y1 y0

  171.     movq_r2r (mm5, mm6);		// mm6 = x7 x5 x3 x1

  172. 

  173.     packssdw_r2r (mm3, mm4);		// mm4 = y6 y7 y4 y5

  174.     movq_r2r (mm2, mm0);		// mm0 = x6 x4 x2 x0

  175. 

  176.     movq_r2m (mm1, *(row+store));	// save y3 y2 y1 y0

  177.     pshufw_r2r (mm4, mm4, 0xb1);	// mm4 = y7 y6 y5 y4

  178. 

  179.     movq_m2r (*table, mm3);		// mm3 = -C2 -C4 C2 C4

  180.     movq_r2m (mm4, *(row+store+4));	// save y7 y6 y5 y4

  181. 

  182.     pmaddwd_r2r (mm0, mm3);		// mm3 = -C4*x4-C2*x6 C4*x0+C2*x2

  183. 

  184.     movq_m2r (*(table+4), mm4);		// mm4 = C6 C4 C6 C4

  185.     pshufw_r2r (mm2, mm2, 0x4e);	// mm2 = x2 x0 x6 x4

  186. }

  187. 

  188. 

  189. /* MMX row IDCT */

  190. 

  191. #define mmx_table(c1,c2,c3,c4,c5,c6,c7)	{  c4,  c2,  c4,  c6,	\

  192. 					   c4,  c6, -c4, -c2,	\

  193. 					   c1,  c3,  c3, -c7,	\

  194. 					   c5,  c7, -c1, -c5,	\

  195. 					   c4, -c6,  c4, -c2,	\

  196. 					  -c4,  c2,  c4, -c6,	\

  197. 					   c5, -c1,  c7, -c5,	\

  198. 					   c7,  c3,  c3, -c1 }

  199. 

  200. static inline void mmx_row_head (int16_t * row, int offset, int16_t * table)

  201. {

  202.     movq_m2r (*(row+offset), mm2);	// mm2 = x6 x4 x2 x0

  203. 

  204.     movq_m2r (*(row+offset+4), mm5);	// mm5 = x7 x5 x3 x1

  205.     movq_r2r (mm2, mm0);		// mm0 = x6 x4 x2 x0

  206. 

  207.     movq_m2r (*table, mm3);		// mm3 = C6 C4 C2 C4

  208.     movq_r2r (mm5, mm6);		// mm6 = x7 x5 x3 x1

  209. 

  210.     punpckldq_r2r (mm0, mm0);		// mm0 = x2 x0 x2 x0

  211. 

  212.     movq_m2r (*(table+4), mm4);		// mm4 = -C2 -C4 C6 C4

  213.     pmaddwd_r2r (mm0, mm3);		// mm3 = C4*x0+C6*x2 C4*x0+C2*x2

  214. 

  215.     movq_m2r (*(table+8), mm1);		// mm1 = -C7 C3 C3 C1

  216.     punpckhdq_r2r (mm2, mm2);		// mm2 = x6 x4 x6 x4

  217. }

  218. 

  219. static inline void mmx_row (int16_t * table, int32_t * rounder)

  220. {

  221.     pmaddwd_r2r (mm2, mm4);		// mm4 = -C4*x4-C2*x6 C4*x4+C6*x6

  222.     punpckldq_r2r (mm5, mm5);		// mm5 = x3 x1 x3 x1

  223. 

  224.     pmaddwd_m2r (*(table+16), mm0);	// mm0 = C4*x0-C2*x2 C4*x0-C6*x2

  225.     punpckhdq_r2r (mm6, mm6);		// mm6 = x7 x5 x7 x5

  226. 

  227.     movq_m2r (*(table+12), mm7);	// mm7 = -C5 -C1 C7 C5

  228.     pmaddwd_r2r (mm5, mm1);		// mm1 = C3*x1-C7*x3 C1*x1+C3*x3

  229. 

  230.     paddd_m2r (*rounder, mm3);		// mm3 += rounder

  231.     pmaddwd_r2r (mm6, mm7);		// mm7 = -C1*x5-C5*x7 C5*x5+C7*x7

  232. 

  233.     pmaddwd_m2r (*(table+20), mm2);	// mm2 = C4*x4-C6*x6 -C4*x4+C2*x6

  234.     paddd_r2r (mm4, mm3);		// mm3 = a1 a0 + rounder

  235. 

  236.     pmaddwd_m2r (*(table+24), mm5);	// mm5 = C7*x1-C5*x3 C5*x1-C1*x3

  237.     movq_r2r (mm3, mm4);		// mm4 = a1 a0 + rounder

  238. 

  239.     pmaddwd_m2r (*(table+28), mm6);	// mm6 = C3*x5-C1*x7 C7*x5+C3*x7

  240.     paddd_r2r (mm7, mm1);		// mm1 = b1 b0

  241. 

  242.     paddd_m2r (*rounder, mm0);		// mm0 += rounder

  243.     psubd_r2r (mm1, mm3);		// mm3 = a1-b1 a0-b0 + rounder

  244. 

  245.     psrad_i2r (ROW_SHIFT, mm3);		// mm3 = y6 y7

  246.     paddd_r2r (mm4, mm1);		// mm1 = a1+b1 a0+b0 + rounder

  247. 

  248.     paddd_r2r (mm2, mm0);		// mm0 = a3 a2 + rounder

  249.     psrad_i2r (ROW_SHIFT, mm1);		// mm1 = y1 y0

  250. 

  251.     paddd_r2r (mm6, mm5);		// mm5 = b3 b2

  252.     movq_r2r (mm0, mm7);		// mm7 = a3 a2 + rounder

  253. 

  254.     paddd_r2r (mm5, mm0);		// mm0 = a3+b3 a2+b2 + rounder

  255.     psubd_r2r (mm5, mm7);		// mm7 = a3-b3 a2-b2 + rounder

  256. }

  257. 

  258. static inline void mmx_row_tail (int16_t * row, int store)

  259. {

  260.     psrad_i2r (ROW_SHIFT, mm0);		// mm0 = y3 y2

  261. 

  262.     psrad_i2r (ROW_SHIFT, mm7);		// mm7 = y4 y5

  263. 

  264.     packssdw_r2r (mm0, mm1);		// mm1 = y3 y2 y1 y0

  265. 

  266.     packssdw_r2r (mm3, mm7);		// mm7 = y6 y7 y4 y5

  267. 

  268.     movq_r2m (mm1, *(row+store));	// save y3 y2 y1 y0

  269.     movq_r2r (mm7, mm4);		// mm4 = y6 y7 y4 y5

  270. 

  271.     pslld_i2r (16, mm7);		// mm7 = y7 0 y5 0

  272. 

  273.     psrld_i2r (16, mm4);		// mm4 = 0 y6 0 y4

  274. 

  275.     por_r2r (mm4, mm7);			// mm7 = y7 y6 y5 y4

  276. 

  277.     /* slot */

  278. 

  279.     movq_r2m (mm7, *(row+store+4));	// save y7 y6 y5 y4

  280. }

  281. 

  282. static inline void mmx_row_mid (int16_t * row, int store,

  283. 				int offset, int16_t * table)

  284. {

  285.     movq_m2r (*(row+offset), mm2);	// mm2 = x6 x4 x2 x0

  286.     psrad_i2r (ROW_SHIFT, mm0);		// mm0 = y3 y2

  287. 

  288.     movq_m2r (*(row+offset+4), mm5);	// mm5 = x7 x5 x3 x1

  289.     psrad_i2r (ROW_SHIFT, mm7);		// mm7 = y4 y5

  290. 

  291.     packssdw_r2r (mm0, mm1);		// mm1 = y3 y2 y1 y0

  292.     movq_r2r (mm5, mm6);		// mm6 = x7 x5 x3 x1

  293. 

  294.     packssdw_r2r (mm3, mm7);		// mm7 = y6 y7 y4 y5

  295.     movq_r2r (mm2, mm0);		// mm0 = x6 x4 x2 x0

  296. 

  297.     movq_r2m (mm1, *(row+store));	// save y3 y2 y1 y0

  298.     movq_r2r (mm7, mm1);		// mm1 = y6 y7 y4 y5

  299. 

  300.     punpckldq_r2r (mm0, mm0);		// mm0 = x2 x0 x2 x0

  301.     psrld_i2r (16, mm7);		// mm7 = 0 y6 0 y4

  302. 

  303.     movq_m2r (*table, mm3);		// mm3 = C6 C4 C2 C4

  304.     pslld_i2r (16, mm1);		// mm1 = y7 0 y5 0

  305. 

  306.     movq_m2r (*(table+4), mm4);		// mm4 = -C2 -C4 C6 C4

  307.     por_r2r (mm1, mm7);			// mm7 = y7 y6 y5 y4

  308. 

  309.     movq_m2r (*(table+8), mm1);		// mm1 = -C7 C3 C3 C1

  310.     punpckhdq_r2r (mm2, mm2);		// mm2 = x6 x4 x6 x4

  311. 

  312.     movq_r2m (mm7, *(row+store+4));	// save y7 y6 y5 y4

  313.     pmaddwd_r2r (mm0, mm3);		// mm3 = C4*x0+C6*x2 C4*x0+C2*x2

  314. }

  315. 

  316. 

  317. #if 0

  318. // C column IDCT - its just here to document the MMXEXT and MMX versions

  319. static inline void idct_col (int16_t * col, int offset)

  320. {

  321. /* multiplication - as implemented on mmx */

  322. #define F(c,x) (((c) * (x)) >> 16)

  323. 

  324. /* saturation - it helps us handle torture test cases */

  325. #define S(x) (((x)>32767) ? 32767 : ((x)<-32768) ? -32768 : (x))

  326. 

  327.     int16_t x0, x1, x2, x3, x4, x5, x6, x7;

  328.     int16_t y0, y1, y2, y3, y4, y5, y6, y7;

  329.     int16_t a0, a1, a2, a3, b0, b1, b2, b3;

  330.     int16_t u04, v04, u26, v26, u17, v17, u35, v35, u12, v12;

  331. 

  332.     col += offset;

  333. 

  334.     x0 = col[0*8];

  335.     x1 = col[1*8];

  336.     x2 = col[2*8];

  337.     x3 = col[3*8];

  338.     x4 = col[4*8];

  339.     x5 = col[5*8];

  340.     x6 = col[6*8];

  341.     x7 = col[7*8];

  342. 

  343.     u04 = S (x0 + x4);

  344.     v04 = S (x0 - x4);

  345.     u26 = S (F (T2, x6) + x2);

  346.     v26 = S (F (T2, x2) - x6);

  347. 

  348.     a0 = S (u04 + u26);

  349.     a1 = S (v04 + v26);

  350.     a2 = S (v04 - v26);

  351.     a3 = S (u04 - u26);

  352. 

  353.     u17 = S (F (T1, x7) + x1);

  354.     v17 = S (F (T1, x1) - x7);

  355.     u35 = S (F (T3, x5) + x3);

  356.     v35 = S (F (T3, x3) - x5);

  357. 

  358.     b0 = S (u17 + u35);

  359.     b3 = S (v17 - v35);

  360.     u12 = S (u17 - u35);

  361.     v12 = S (v17 + v35);

  362.     u12 = S (2 * F (C4, u12));

  363.     v12 = S (2 * F (C4, v12));

  364.     b1 = S (u12 + v12);

  365.     b2 = S (u12 - v12);

  366. 

  367.     y0 = S (a0 + b0) >> COL_SHIFT;

  368.     y1 = S (a1 + b1) >> COL_SHIFT;

  369.     y2 = S (a2 + b2) >> COL_SHIFT;

  370.     y3 = S (a3 + b3) >> COL_SHIFT;

  371. 

  372.     y4 = S (a3 - b3) >> COL_SHIFT;

  373.     y5 = S (a2 - b2) >> COL_SHIFT;

  374.     y6 = S (a1 - b1) >> COL_SHIFT;

  375.     y7 = S (a0 - b0) >> COL_SHIFT;

  376. 

  377.     col[0*8] = y0;

  378.     col[1*8] = y1;

  379.     col[2*8] = y2;

  380.     col[3*8] = y3;

  381.     col[4*8] = y4;

  382.     col[5*8] = y5;

  383.     col[6*8] = y6;

  384.     col[7*8] = y7;

  385. }

  386. #endif

  387. 

  388. 

  389. // MMX column IDCT

  390. static inline void idct_col (int16_t * col, int offset)

  391. {

  392. #define T1 13036

  393. #define T2 27146

  394. #define T3 43790

  395. #define C4 23170

  396. 

  397.     static short _T1[] ATTR_ALIGN(8) = {T1,T1,T1,T1};

  398.     static short _T2[] ATTR_ALIGN(8) = {T2,T2,T2,T2};

  399.     static short _T3[] ATTR_ALIGN(8) = {T3,T3,T3,T3};

  400.     static short _C4[] ATTR_ALIGN(8) = {C4,C4,C4,C4};

  401. 

  402.     /* column code adapted from peter gubanov */

  403.     /* http://www.elecard.com/peter/idct.shtml */

  404. 

  405.     movq_m2r (*_T1, mm0);		// mm0 = T1

  406. 

  407.     movq_m2r (*(col+offset+1*8), mm1);	// mm1 = x1

  408.     movq_r2r (mm0, mm2);		// mm2 = T1

  409. 

  410.     movq_m2r (*(col+offset+7*8), mm4);	// mm4 = x7

  411.     pmulhw_r2r (mm1, mm0);		// mm0 = T1*x1

  412. 

  413.     movq_m2r (*_T3, mm5);		// mm5 = T3

  414.     pmulhw_r2r (mm4, mm2);		// mm2 = T1*x7

  415. 

  416.     movq_m2r (*(col+offset+5*8), mm6);	// mm6 = x5

  417.     movq_r2r (mm5, mm7);		// mm7 = T3-1

  418. 

  419.     movq_m2r (*(col+offset+3*8), mm3);	// mm3 = x3

  420.     psubsw_r2r (mm4, mm0);		// mm0 = v17

  421. 

  422.     movq_m2r (*_T2, mm4);		// mm4 = T2

  423.     pmulhw_r2r (mm3, mm5);		// mm5 = (T3-1)*x3

  424. 

  425.     paddsw_r2r (mm2, mm1);		// mm1 = u17

  426.     pmulhw_r2r (mm6, mm7);		// mm7 = (T3-1)*x5

  427. 

  428.     /* slot */

  429. 

  430.     movq_r2r (mm4, mm2);		// mm2 = T2

  431.     paddsw_r2r (mm3, mm5);		// mm5 = T3*x3

  432. 

  433.     pmulhw_m2r (*(col+offset+2*8), mm4);// mm4 = T2*x2

  434.     paddsw_r2r (mm6, mm7);		// mm7 = T3*x5

  435. 

  436.     psubsw_r2r (mm6, mm5);		// mm5 = v35

  437.     paddsw_r2r (mm3, mm7);		// mm7 = u35

  438. 

  439.     movq_m2r (*(col+offset+6*8), mm3);	// mm3 = x6

  440.     movq_r2r (mm0, mm6);		// mm6 = v17

  441. 

  442.     pmulhw_r2r (mm3, mm2);		// mm2 = T2*x6

  443.     psubsw_r2r (mm5, mm0);		// mm0 = b3

  444. 

  445.     psubsw_r2r (mm3, mm4);		// mm4 = v26

  446.     paddsw_r2r (mm6, mm5);		// mm5 = v12

  447. 

  448.     movq_r2m (mm0, *(col+offset+3*8));	// save b3 in scratch0

  449.     movq_r2r (mm1, mm6);		// mm6 = u17

  450. 

  451.     paddsw_m2r (*(col+offset+2*8), mm2);// mm2 = u26

  452.     paddsw_r2r (mm7, mm6);		// mm6 = b0

  453. 

  454.     psubsw_r2r (mm7, mm1);		// mm1 = u12

  455.     movq_r2r (mm1, mm7);		// mm7 = u12

  456. 

  457.     movq_m2r (*(col+offset+0*8), mm3);	// mm3 = x0

  458.     paddsw_r2r (mm5, mm1);		// mm1 = u12+v12

  459. 

  460.     movq_m2r (*_C4, mm0);		// mm0 = C4/2

  461.     psubsw_r2r (mm5, mm7);		// mm7 = u12-v12

  462. 

  463.     movq_r2m (mm6, *(col+offset+5*8));	// save b0 in scratch1

  464.     pmulhw_r2r (mm0, mm1);		// mm1 = b1/2

  465. 

  466.     movq_r2r (mm4, mm6);		// mm6 = v26

  467.     pmulhw_r2r (mm0, mm7);		// mm7 = b2/2

  468. 

  469.     movq_m2r (*(col+offset+4*8), mm5);	// mm5 = x4

  470.     movq_r2r (mm3, mm0);		// mm0 = x0

  471. 

  472.     psubsw_r2r (mm5, mm3);		// mm3 = v04

  473.     paddsw_r2r (mm5, mm0);		// mm0 = u04

  474. 

  475.     paddsw_r2r (mm3, mm4);		// mm4 = a1

  476.     movq_r2r (mm0, mm5);		// mm5 = u04

  477. 

  478.     psubsw_r2r (mm6, mm3);		// mm3 = a2

  479.     paddsw_r2r (mm2, mm5);		// mm5 = a0

  480. 

  481.     paddsw_r2r (mm1, mm1);		// mm1 = b1

  482.     psubsw_r2r (mm2, mm0);		// mm0 = a3

  483. 

  484.     paddsw_r2r (mm7, mm7);		// mm7 = b2

  485.     movq_r2r (mm3, mm2);		// mm2 = a2

  486. 

  487.     movq_r2r (mm4, mm6);		// mm6 = a1

  488.     paddsw_r2r (mm7, mm3);		// mm3 = a2+b2

  489. 

  490.     psraw_i2r (COL_SHIFT, mm3);		// mm3 = y2

  491.     paddsw_r2r (mm1, mm4);		// mm4 = a1+b1

  492. 

  493.     psraw_i2r (COL_SHIFT, mm4);		// mm4 = y1

  494.     psubsw_r2r (mm1, mm6);		// mm6 = a1-b1

  495. 

  496.     movq_m2r (*(col+offset+5*8), mm1);	// mm1 = b0

  497.     psubsw_r2r (mm7, mm2);		// mm2 = a2-b2

  498. 

  499.     psraw_i2r (COL_SHIFT, mm6);		// mm6 = y6

  500.     movq_r2r (mm5, mm7);		// mm7 = a0

  501. 

  502.     movq_r2m (mm4, *(col+offset+1*8));	// save y1

  503.     psraw_i2r (COL_SHIFT, mm2);		// mm2 = y5

  504. 

  505.     movq_r2m (mm3, *(col+offset+2*8));	// save y2

  506.     paddsw_r2r (mm1, mm5);		// mm5 = a0+b0

  507. 

  508.     movq_m2r (*(col+offset+3*8), mm4);	// mm4 = b3

  509.     psubsw_r2r (mm1, mm7);		// mm7 = a0-b0

  510. 

  511.     psraw_i2r (COL_SHIFT, mm5);		// mm5 = y0

  512.     movq_r2r (mm0, mm3);		// mm3 = a3

  513. 

  514.     movq_r2m (mm2, *(col+offset+5*8));	// save y5

  515.     psubsw_r2r (mm4, mm3);		// mm3 = a3-b3

  516. 

  517.     psraw_i2r (COL_SHIFT, mm7);		// mm7 = y7

  518.     paddsw_r2r (mm0, mm4);		// mm4 = a3+b3

  519. 

  520.     movq_r2m (mm5, *(col+offset+0*8));	// save y0

  521.     psraw_i2r (COL_SHIFT, mm3);		// mm3 = y4

  522. 

  523.     movq_r2m (mm6, *(col+offset+6*8));	// save y6

  524.     psraw_i2r (COL_SHIFT, mm4);		// mm4 = y3

  525. 

  526.     movq_r2m (mm7, *(col+offset+7*8));	// save y7

  527. 

  528.     movq_r2m (mm3, *(col+offset+4*8));	// save y4

  529. 

  530.     movq_r2m (mm4, *(col+offset+3*8));	// save y3

  531. }

  532. 

  533. 

  534. static int32_t rounder0[] ATTR_ALIGN(8) =

  535.     rounder ((1 << (COL_SHIFT - 1)) - 0.5);

  536. static int32_t rounder4[] ATTR_ALIGN(8) = rounder (0);

  537. static int32_t rounder1[] ATTR_ALIGN(8) =

  538.     rounder (1.25683487303);	/* C1*(C1/C4+C1+C7)/2 */

  539. static int32_t rounder7[] ATTR_ALIGN(8) =

  540.     rounder (-0.25);		/* C1*(C7/C4+C7-C1)/2 */

  541. static int32_t rounder2[] ATTR_ALIGN(8) =

  542.     rounder (0.60355339059);	/* C2 * (C6+C2)/2 */

  543. static int32_t rounder6[] ATTR_ALIGN(8) =

  544.     rounder (-0.25);		/* C2 * (C6-C2)/2 */

  545. static int32_t rounder3[] ATTR_ALIGN(8) =

  546.     rounder (0.087788325588);	/* C3*(-C3/C4+C3+C5)/2 */

  547. static int32_t rounder5[] ATTR_ALIGN(8) =

  548.     rounder (-0.441341716183);	/* C3*(-C5/C4+C5-C3)/2 */

  549. 

  550. 

  551. #define declare_idct(idct,table,idct_row_head,idct_row,idct_row_tail,idct_row_mid)	\

  552. void idct (int16_t * block)					\

  553. {									\

  554.     static int16_t table04[] ATTR_ALIGN(16) =				\

  555. 	table (22725, 21407, 19266, 16384, 12873,  8867, 4520);		\

  556.     static int16_t table17[] ATTR_ALIGN(16) =				\

  557. 	table (31521, 29692, 26722, 22725, 17855, 12299, 6270);		\

  558.     static int16_t table26[] ATTR_ALIGN(16) =				\

  559. 	table (29692, 27969, 25172, 21407, 16819, 11585, 5906);		\

  560.     static int16_t table35[] ATTR_ALIGN(16) =				\

  561. 	table (26722, 25172, 22654, 19266, 15137, 10426, 5315);		\

  562. 									\

  563.     idct_row_head (block, 0*8, table04);				\

  564.     idct_row (table04, rounder0);					\

  565.     idct_row_mid (block, 0*8, 4*8, table04);				\

  566.     idct_row (table04, rounder4);					\

  567.     idct_row_mid (block, 4*8, 1*8, table17);				\

  568.     idct_row (table17, rounder1);					\

  569.     idct_row_mid (block, 1*8, 7*8, table17);				\

  570.     idct_row (table17, rounder7);					\

  571.     idct_row_mid (block, 7*8, 2*8, table26);				\

  572.     idct_row (table26, rounder2);					\

  573.     idct_row_mid (block, 2*8, 6*8, table26);				\

  574.     idct_row (table26, rounder6);					\

  575.     idct_row_mid (block, 6*8, 3*8, table35);				\

  576.     idct_row (table35, rounder3);					\

  577.     idct_row_mid (block, 3*8, 5*8, table35);				\

  578.     idct_row (table35, rounder5);					\

  579.     idct_row_tail (block, 5*8);						\

  580. 									\

  581.     idct_col (block, 0);						\

  582.     idct_col (block, 4);						\

  583. }

  584. 

  585. 

  586. declare_idct (ff_mmxext_idct, mmxext_table,

  587. 	      mmxext_row_head, mmxext_row, mmxext_row_tail, mmxext_row_mid)

  588. 

  589. declare_idct (ff_mmx_idct, mmx_table,

  590. 	      mmx_row_head, mmx_row, mmx_row_tail, mmx_row_mid)