开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
idct_sse2.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

idct_sse2.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "libmpeg2.h"
  4. // Intel's SSE2 implementation of iDCT
  5. // AP-945
  6. // http://cache-www.intel.com/cd/00/00/01/76/17680_w_idct.pdf
  8. #define BITS_INV_ACC 4 // 4 or 5 for IEEE
  9. #define SHIFT_INV_ROW 16 - BITS_INV_ACC
  10. #define SHIFT_INV_COL 1 + BITS_INV_ACC
  11. const short RND_INV_ROW = 1024 * (6 - BITS_INV_ACC); //1 << (SHIFT_INV_ROW-1)
  12. const short RND_INV_COL = 16 * (BITS_INV_ACC - 3); // 1 << (SHIFT_INV_COL-1)
  13. const short RND_INV_CORR = RND_INV_COL - 1; // correction -1.0 and round
  15. __declspec(align(16)) short M128_one_corr[8] = {1,1,1,1,1,1,1,1};
  16. __declspec(align(16)) short M128_round_inv_row[8] = {RND_INV_ROW, 0, RND_INV_ROW, 0, RND_INV_ROW, 0, RND_INV_ROW, 0};
  17. __declspec(align(16)) short M128_round_inv_col[8] = {RND_INV_COL, RND_INV_COL, RND_INV_COL, RND_INV_COL, RND_INV_COL, RND_INV_COL, RND_INV_COL, RND_INV_COL};
  18. __declspec(align(16)) short M128_round_inv_corr[8]= {RND_INV_CORR, RND_INV_CORR, RND_INV_CORR, RND_INV_CORR, RND_INV_CORR, RND_INV_CORR, RND_INV_CORR, RND_INV_CORR};
  19. __declspec(align(16)) short M128_tg_1_16[8] = {13036, 13036, 13036, 13036, 13036, 13036, 13036, 13036}; // tg * (2<<16) + 0.5
  20. __declspec(align(16)) short M128_tg_2_16[8] = {27146, 27146, 27146, 27146, 27146, 27146, 27146, 27146}; // tg * (2<<16) + 0.5
  21. __declspec(align(16)) short M128_tg_3_16[8] = {-21746, -21746, -21746, -21746, -21746, -21746, -21746, -21746}; // tg * (2<<16) + 0.5
  22. __declspec(align(16)) short M128_cos_4_16[8] = {-19195, -19195, -19195, -19195, -19195, -19195, -19195, -19195};// cos * (2<<16) + 0.5
  24. //-----------------------------------------------------------------------------
  25. // Table for rows 0,4 - constants are multiplied on cos_4_16
  26. //movq -> w13 w12 w09 w08 w05 w04 w01 w00
  27. // w15 w14 w11 w10 w07 w06 w03 w02
  28. // w29 w28 w25 w24 w21 w20 w17 w16
  29. // w31 w30 w27 w26 w23 w22 w19 w18
  31. __declspec(align(16)) short M128_tab_i_04[] = 
  32. {
  33. 16384, 21407, 16384, 8867, //movq -> w05 w04 w01 w00
  34. 16384, -8867, 16384, -21407, // w13 w12 w09 w08
  35. 16384, 8867, -16384, -21407, // w07 w06 w03 w02
  36. -16384, 21407, 16384, -8867, // w15 w14 w11 w10
  37. 22725, 19266, 19266, -4520, // w21 w20 w17 w16
  38. 12873, -22725, 4520, -12873, // w29 w28 w25 w24
  39. 12873, 4520, -22725, -12873, // w23 w22 w19 w18
  40. 4520, 19266, 19266, -22725  // w31 w30 w27 w26
  41. };
  43. // Table for rows 1,7 - constants are multiplied on cos_1_16
  45. __declspec(align(16)) short M128_tab_i_17[] =
  46. {
  47. 22725, 29692, 22725, 12299, //movq -> w05 w04 w01 w00
  48. 22725, -12299, 22725, -29692, // w13 w12 w09 w08
  49. 22725, 12299, -22725, -29692, // w07 w06 w03 w02
  50. -22725, 29692, 22725, -12299, // w15 w14 w11 w10
  51. 31521, 26722, 26722, -6270, // w21 w20 w17 w16
  52. 17855, -31521, 6270, -17855, // w29 w28 w25 w24
  53. 17855, 6270, -31521, -17855, // w23 w22 w19 w18
  54. 6270, 26722, 26722, -31521 // w31 w30 w27 w26
  55. };
  57. // Table for rows 2,6 - constants are multiplied on cos_2_16
  59. __declspec(align(16)) short M128_tab_i_26[] =
  60. {
  61. 21407, 27969, 21407, 11585, //movq -> w05 w04 w01 w00
  62. 21407, -11585, 21407, -27969, // w13 w12 w09 w08
  63. 21407, 11585, -21407, -27969, // w07 w06 w03 w02
  64. -21407, 27969, 21407, -11585, // w15 w14 w11 w10
  65. 29692, 25172, 25172, -5906, // w21 w20 w17 w16
  66. 16819, -29692, 5906, -16819, // w29 w28 w25 w24
  67. 16819, 5906, -29692, -16819, // w23 w22 w19 w18
  68. 5906, 25172, 25172, -29692 // w31 w30 w27 w26
  69. };
  71. // Table for rows 3,5 - constants are multiplied on cos_3_16
  73. __declspec(align(16)) short M128_tab_i_35[] = 
  74. {
  75. 19266, 25172, 19266, 10426, //movq -> w05 w04 w01 w00
  76. 19266, -10426, 19266, -25172, // w13 w12 w09 w08
  77. 19266, 10426, -19266, -25172, // w07 w06 w03 w02
  78. -19266, 25172, 19266, -10426, // w15 w14 w11 w10
  79. 26722, 22654, 22654, -5315, // w21 w20 w17 w16
  80. 15137, -26722, 5315, -15137, // w29 w28 w25 w24
  81. 15137, 5315, -26722, -15137, // w23 w22 w19 w18
  82. 5315, 22654, 22654, -26722 // w31 w30 w27 w26
  83. };
  85. //-----------------------------------------------------------------------------
  86. /*
  87. ;=============================================================================
  88. ;=============================================================================
  89. ;=============================================================================
  90. ;
  91. ; Inverse DCT
  92. ;
  93. ;-----------------------------------------------------------------------------
  94. ;
  95. ; This implementation calculates iDCT-2D by a row-column method.
  96. ; On the first stage the iDCT-1D is calculated for each row with use
  97. ; direct algorithm, on the second stage the calculation is executed
  98. ; at once for four columns with use of scaled iDCT-1D algorithm.
  99. ; Base R&Y algorithm for iDCT-1D is modified for second stage.
  100. ;
  101. ;=============================================================================
  102. ;-----------------------------------------------------------------------------
  103. ;
  104. ; The first stage - inverse DCTs of rows
  105. ;
  106. ;-----------------------------------------------------------------------------
  107. ; The 8-point inverse DCT direct algorithm
  108. ;-----------------------------------------------------------------------------
  109. ;
  110. ; static const short w[32] = {
  111. ; FIX(cos_4_16), FIX(cos_2_16), FIX(cos_4_16), FIX(cos_6_16),
  112. ; FIX(cos_4_16), FIX(cos_6_16), -FIX(cos_4_16), -FIX(cos_2_16),
  113. ; FIX(cos_4_16), -FIX(cos_6_16), -FIX(cos_4_16), FIX(cos_2_16),
  114. ; FIX(cos_4_16), -FIX(cos_2_16), FIX(cos_4_16), -FIX(cos_6_16),
  115. ; FIX(cos_1_16), FIX(cos_3_16), FIX(cos_5_16), FIX(cos_7_16),
  116. ; FIX(cos_3_16), -FIX(cos_7_16), -FIX(cos_1_16), -FIX(cos_5_16),
  117. ; FIX(cos_5_16), -FIX(cos_1_16), FIX(cos_7_16), FIX(cos_3_16),
  118. ; FIX(cos_7_16), -FIX(cos_5_16), FIX(cos_3_16), -FIX(cos_1_16) };
  119. ;
  120. ; #define DCT_8_INV_ROW(x, y)
  121. ; {
  122. ; int a0, a1, a2, a3, b0, b1, b2, b3;
  123. ;
  124. ; a0 = x[0] * w[ 0] + x[2] * w[ 1] + x[4] * w[ 2] + x[6] * w[ 3];
  125. ; a1 = x[0] * w[ 4] + x[2] * w[ 5] + x[4] * w[ 6] + x[6] * w[ 7];
  126. ; a2 = x[0] * w[ 8] + x[2] * w[ 9] + x[4] * w[10] + x[6] * w[11];
  127. ; a3 = x[0] * w[12] + x[2] * w[13] + x[4] * w[14] + x[6] * w[15];
  128. ; b0 = x[1] * w[16] + x[3] * w[17] + x[5] * w[18] + x[7] * w[19];
  129. ; b1 = x[1] * w[20] + x[3] * w[21] + x[5] * w[22] + x[7] * w[23];
  130. ; b2 = x[1] * w[24] + x[3] * w[25] + x[5] * w[26] + x[7] * w[27];
  131. ; b3 = x[1] * w[28] + x[3] * w[29] + x[5] * w[30] + x[7] * w[31];
  132. ;
  133. ; y[0] = SHIFT_ROUND ( a0 + b0 );
  134. ; y[1] = SHIFT_ROUND ( a1 + b1 );
  135. ; y[2] = SHIFT_ROUND ( a2 + b2 );
  136. ; y[3] = SHIFT_ROUND ( a3 + b3 );
  137. ; y[4] = SHIFT_ROUND ( a3 - b3 );
  138. ; y[5] = SHIFT_ROUND ( a2 - b2 );
  139. ; y[6] = SHIFT_ROUND ( a1 - b1 );
  140. ; y[7] = SHIFT_ROUND ( a0 - b0 );
  141. ; }
  142. ;
  143. ;-----------------------------------------------------------------------------
  144. ;
  145. ; In this implementation the outputs of the iDCT-1D are multiplied
  146. ; for rows 0,4 - on cos_4_16,
  147. ; for rows 1,7 - on cos_1_16,
  148. ; for rows 2,6 - on cos_2_16,
  149. ; for rows 3,5 - on cos_3_16
  150. ; and are shifted to the left for rise of accuracy
  151. ;
  152. ; For used constants
  153. ; FIX(float_const) = (short) (float_const * (1<<15) + 0.5)
  154. ;
  155. ;-----------------------------------------------------------------------------
  156. ;-----------------------------------------------------------------------------
  157. ;
  158. ; The second stage - inverse DCTs of columns
  159. ;
  160. ; The inputs are multiplied
  161. ; for rows 0,4 - on cos_4_16,
  162. ; for rows 1,7 - on cos_1_16,
  163. ; for rows 2,6 - on cos_2_16,
  164. ; for rows 3,5 - on cos_3_16
  165. ; and are shifted to the left for rise of accuracy
  166. ;
  167. ;-----------------------------------------------------------------------------
  168. ;
  169. ; The 8-point scaled inverse DCT algorithm (26a8m)
  170. ;
  171. ;-----------------------------------------------------------------------------
  172. ;
  173. ; #define DCT_8_INV_COL(x, y)
  174. ; {
  175. ; short t0, t1, t2, t3, t4, t5, t6, t7;
  176. ; short tp03, tm03, tp12, tm12, tp65, tm65;
  177. ; short tp465, tm465, tp765, tm765;
  178. ;
  179. ; tp765 = x[1] + x[7] * tg_1_16;
  180. ; tp465 = x[1] * tg_1_16 - x[7];
  181. ; tm765 = x[5] * tg_3_16 + x[3];
  182. ; tm465 = x[5] - x[3] * tg_3_16;
  183. ;
  184. ; t7 = tp765 + tm765;
  185. ; tp65 = tp765 - tm765;
  186. ; t4 = tp465 + tm465;
  187. ; tm65 = tp465 - tm465;
  188. ;
  189. ; t6 = ( tp65 + tm65 ) * cos_4_16;
  190. ; t5 = ( tp65 - tm65 ) * cos_4_16;
  191. ;
  192. ; tp03 = x[0] + x[4];
  193. ; tp12 = x[0] - x[4];
  194. ;
  195. ; tm03 = x[2] + x[6] * tg_2_16;
  196. ; tm12 = x[2] * tg_2_16 - x[6];
  197. ;
  198. ; t0 = tp03 + tm03;
  199. ; t3 = tp03 - tm03;
  200. ; t1 = tp12 + tm12;
  201. ; t2 = tp12 - tm12;
  202. ;
  203. ; y[0] = SHIFT_ROUND ( t0 + t7 );
  204. ; y[7] = SHIFT_ROUND ( t0 - t7 );
  205. ; y[1] = SHIFT_ROUND ( t1 + t6 );
  206. ; y[6] = SHIFT_ROUND ( t1 - t6 );
  207. ; y[2] = SHIFT_ROUND ( t2 + t5 );
  208. ; y[5] = SHIFT_ROUND ( t2 - t5 );
  209. ; y[3] = SHIFT_ROUND ( t3 + t4 );
  210. ; y[4] = SHIFT_ROUND ( t3 - t4 );
  211. ; }
  212. ;
  213. ;-----------------------------------------------------------------------------
  214. */
  215. //xmm7 = round_inv_row
  216. #define DCT_8_INV_ROW __asm{ 
  217. __asm pshuflw xmm0, xmm0, 0xD8 
  218. __asm pshufd xmm1, xmm0, 0 
  219. __asm pmaddwd xmm1, [esi] 
  220. __asm pshufd xmm3, xmm0, 0x55 
  221. __asm pshufhw xmm0, xmm0, 0xD8 
  222. __asm pmaddwd xmm3, [esi+32] 
  223. __asm pshufd xmm2, xmm0, 0xAA 
  224. __asm pshufd xmm0, xmm0, 0xFF 
  225. __asm pmaddwd xmm2, [esi+16] 
  226. __asm pshufhw xmm4, xmm4, 0xD8 
  227. __asm paddd xmm1, M128_round_inv_row 
  228. __asm pshuflw xmm4, xmm4, 0xD8 
  229. __asm pmaddwd xmm0, [esi+48] 
  230. __asm pshufd xmm5, xmm4, 0 
  231. __asm pshufd xmm6, xmm4, 0xAA 
  232. __asm pmaddwd xmm5, [ecx] 
  233. __asm paddd xmm1, xmm2 
  234. __asm movdqa xmm2, xmm1 
  235. __asm pshufd xmm7, xmm4, 0x55 
  236. __asm pmaddwd xmm6, [ecx+16] 
  237. __asm paddd xmm0, xmm3 
  238. __asm pshufd xmm4, xmm4, 0xFF 
  239. __asm psubd xmm2, xmm0 
  240. __asm pmaddwd xmm7, [ecx+32] 
  241. __asm paddd xmm0, xmm1 
  242. __asm psrad xmm2, 12 
  243. __asm paddd xmm5, M128_round_inv_row 
  244. __asm pmaddwd xmm4, [ecx+48] 
  245. __asm paddd xmm5, xmm6 
  246. __asm movdqa xmm6, xmm5 
  247. __asm psrad xmm0, 12 
  248. __asm pshufd xmm2, xmm2, 0x1B 
  249. __asm packssdw xmm0, xmm2 
  250. __asm paddd xmm4, xmm7 
  251. __asm psubd xmm6, xmm4 
  252. __asm paddd xmm4, xmm5 
  253. __asm psrad xmm6, 12 
  254. __asm psrad xmm4, 12 
  255. __asm pshufd xmm6, xmm6, 0x1B 
  256. __asm packssdw xmm4, xmm6 
  257. }
  258. #define DCT_8_INV_COL_8 __asm{ 
  259. __asm movdqa xmm1, XMMWORD PTR M128_tg_3_16 
  260. __asm movdqa xmm2, xmm0 
  261. __asm movdqa xmm3, XMMWORD PTR [edx+3*16] 
  262. __asm pmulhw xmm0, xmm1 
  263. __asm pmulhw xmm1, xmm3 
  264. __asm movdqa xmm5, XMMWORD PTR M128_tg_1_16 
  265. __asm movdqa xmm6, xmm4 
  266. __asm pmulhw xmm4, xmm5 
  267. __asm paddsw xmm0, xmm2 
  268. __asm pmulhw xmm5, [edx+1*16] 
  269. __asm paddsw xmm1, xmm3 
  270. __asm movdqa xmm7, XMMWORD PTR [edx+6*16] 
  271. __asm paddsw xmm0, xmm3 
  272. __asm movdqa xmm3, XMMWORD PTR M128_tg_2_16 
  273. __asm psubsw xmm2, xmm1 
  274. __asm pmulhw xmm7, xmm3 
  275. __asm movdqa xmm1, xmm0 
  276. __asm pmulhw xmm3, [edx+2*16] 
  277. __asm psubsw xmm5, xmm6 
  278. __asm paddsw xmm4, [edx+1*16] 
  279. __asm paddsw xmm0, xmm4 
  280. __asm paddsw xmm0, XMMWORD PTR M128_one_corr 
  281. __asm psubsw xmm4, xmm1 
  282. __asm movdqa xmm6, xmm5 
  283. __asm psubsw xmm5, xmm2 
  284. __asm paddsw xmm5, XMMWORD PTR M128_one_corr 
  285. __asm paddsw xmm6, xmm2 
  286. __asm movdqa [edx+7*16], xmm0 
  287. __asm movdqa xmm1, xmm4 
  288. __asm movdqa xmm0, XMMWORD PTR M128_cos_4_16 
  289. __asm paddsw xmm4, xmm5 
  290. __asm movdqa xmm2, XMMWORD PTR M128_cos_4_16 
  291. __asm pmulhw xmm2, xmm4 
  292. __asm movdqa [edx+3*16], xmm6 
  293. __asm psubsw xmm1, xmm5 
  294. __asm paddsw xmm7, [edx+2*16] 
  295. __asm psubsw xmm3, [edx+6*16] 
  296. __asm movdqa xmm6, [edx] 
  297. __asm pmulhw xmm0, xmm1 
  298. __asm movdqa xmm5, [edx+4*16] 
  299. __asm paddsw xmm5, xmm6 
  300. __asm psubsw xmm6, [edx+4*16] 
  301. __asm paddsw xmm4, xmm2 
  302. __asm por xmm4, XMMWORD PTR M128_one_corr 
  303. __asm paddsw xmm0, xmm1 
  304. __asm por xmm0, XMMWORD PTR M128_one_corr 
  305. __asm movdqa xmm2, xmm5 
  306. __asm paddsw xmm5, xmm7 
  307. __asm movdqa xmm1, xmm6 
  308. __asm paddsw xmm5, XMMWORD PTR M128_round_inv_col 
  309. __asm psubsw xmm2, xmm7 
  310. __asm movdqa xmm7, [edx+7*16] 
  311. __asm paddsw xmm6, xmm3 
  312. __asm paddsw xmm6, XMMWORD PTR M128_round_inv_col 
  313. __asm paddsw xmm7, xmm5 
  314. __asm psraw xmm7, SHIFT_INV_COL 
  315. __asm psubsw xmm1, xmm3 
  316. __asm paddsw xmm1, XMMWORD PTR M128_round_inv_corr 
  317. __asm movdqa xmm3, xmm6 
  318. __asm paddsw xmm2, XMMWORD PTR M128_round_inv_corr 
  319. __asm paddsw xmm6, xmm4 
  320. __asm movdqa [edx], xmm7 
  321. __asm psraw xmm6, SHIFT_INV_COL 
  322. __asm movdqa xmm7, xmm1 
  323. __asm paddsw xmm1, xmm0 
  324. __asm movdqa [edx+1*16], xmm6 
  325. __asm psraw xmm1, SHIFT_INV_COL 
  326. __asm movdqa xmm6, [edx+3*16] 
  327. __asm psubsw xmm7, xmm0 
  328. __asm psraw xmm7, SHIFT_INV_COL 
  329. __asm movdqa [edx+2*16], xmm1 
  330. __asm psubsw xmm5, [edx+7*16] 
  331. __asm psraw xmm5, SHIFT_INV_COL 
  332. __asm movdqa [edx+7*16], xmm5 
  333. __asm psubsw xmm3, xmm4 
  334. __asm paddsw xmm6, xmm2 
  335. __asm psubsw xmm2, [edx+3*16] 
  336. __asm psraw xmm6, SHIFT_INV_COL 
  337. __asm psraw xmm2, SHIFT_INV_COL 
  338. __asm movdqa [edx+3*16], xmm6 
  339. __asm psraw xmm3, SHIFT_INV_COL 
  340. __asm movdqa [edx+4*16], xmm2 
  341. __asm movdqa [edx+5*16], xmm7 
  342. __asm movdqa [edx+6*16], xmm3 
  343. }
  345. //assumes src and destination are aligned on a 16-byte boundary
  347. static void idct_M128ASM(short* src)
  348. {
  349. ASSERT(((DWORD)src & 0xf) == 0); //aligned on 16-byte boundary
  351. __asm mov edx, src
  353. __asm movdqa xmm0, XMMWORD PTR[edx] //row 1
  354. __asm lea esi, M128_tab_i_04
  355. __asm movdqa xmm4, XMMWORD PTR[edx+16*2] //row 3
  356. __asm lea ecx, M128_tab_i_26
  357. DCT_8_INV_ROW; //Row 1, tab_i_04 and Row 3, tab_i_26
  358. __asm movdqa XMMWORD PTR[edx], xmm0
  359. __asm movdqa XMMWORD PTR[edx+16*2], xmm4
  361. __asm movdqa xmm0, XMMWORD PTR[edx+16*4] //row 5
  362. //__asm lea esi, M128_tab_i_04
  363. __asm movdqa xmm4, XMMWORD PTR[edx+16*6] //row 7
  364. //__asm lea ecx, M128_tab_i_26
  365. DCT_8_INV_ROW; //Row 5, tab_i_04 and Row 7, tab_i_26
  366. __asm movdqa XMMWORD PTR[edx+16*4], xmm0
  367. __asm movdqa XMMWORD PTR[edx+16*6], xmm4
  369. __asm movdqa xmm0, XMMWORD PTR[edx+16*3] //row 4
  370. __asm lea esi, M128_tab_i_35
  371. __asm movdqa xmm4, XMMWORD PTR[edx+16*1] //row 2
  372. __asm lea ecx, M128_tab_i_17
  373. DCT_8_INV_ROW; //Row 4, tab_i_35 and Row 2, tab_i_17
  374. __asm movdqa XMMWORD PTR[edx+16*3], xmm0
  375. __asm movdqa XMMWORD PTR[edx+16*1], xmm4
  377. __asm movdqa xmm0, XMMWORD PTR[edx+16*5] //row 6
  378. //__asm lea esi, M128_tab_i_35
  379. __asm movdqa xmm4, XMMWORD PTR[edx+16*7] //row 8
  380. //__asm lea ecx, M128_tab_i_17
  381. DCT_8_INV_ROW; //Row 6, tab_i_35 and Row 8, tab_i_17
  382. //__asm movdqa XMMWORD PTR[edx+80], xmm0
  383. //__asm movdqa xmm0, XMMWORD PTR [edx+80] /* 0 /* x5 */
  384. //__asm movdqa XMMWORD PTR[edx+16*7], xmm4
  385. //__asm movdqa xmm4, XMMWORD PTR [edx+7*16]/* 4 ; x7 */
  386. DCT_8_INV_COL_8
  387. // __asm emms
  388. }
  390. /////////////
  392. #define CLIP(x) (x < 0 ? 0 : x > 255 ? 255 : x)
  394. void mpeg2_idct_copy_sse2(int16_t* block, uint8_t* dest, const int stride)
  395. {
  396. idct_M128ASM(block);
  397. /*
  398.     for(int i = 0; i < 8; i++)
  399. {
  400. dest[0] = CLIP(block[0]);
  401. dest[1] = CLIP(block[1]);
  402. dest[2] = CLIP(block[2]);
  403. dest[3] = CLIP(block[3]);
  404. dest[4] = CLIP(block[4]);
  405. dest[5] = CLIP(block[5]);
  406. dest[6] = CLIP(block[6]);
  407. dest[7] = CLIP(block[7]);
  409. memset(block, 0, sizeof(short)*8);
  411. dest += stride;
  412. block += 8;
  413.     }
  414. */
  415. __asm
  416. {
  417. mov esi, block
  418. mov edi, dest
  419. mov edx, stride
  420. lea ecx, [edx+edx]
  422. movdqa xmm0, [esi+16*0]
  423. movdqa xmm1, [esi+16*1]
  424. movdqa xmm2, [esi+16*2]
  425. movdqa xmm3, [esi+16*3]
  426. movdqa xmm4, [esi+16*4]
  427. movdqa xmm5, [esi+16*5]
  428. movdqa xmm6, [esi+16*6]
  429. movdqa xmm7, [esi+16*7]
  431. packuswb xmm0, xmm1
  432. packuswb xmm2, xmm3
  433. packuswb xmm4, xmm5
  434. packuswb xmm6, xmm7
  436. movlps [edi], xmm0
  437. movhps [edi+edx], xmm0
  438. add edi, ecx
  439. movlps [edi], xmm2
  440. movhps [edi+edx], xmm2
  441. add edi, ecx
  442. movlps [edi], xmm4
  443. movhps [edi+edx], xmm4
  444. add edi, ecx
  445. movlps [edi], xmm6
  446. movhps [edi+edx], xmm6
  448. xorps xmm7, xmm7
  449. movdqa [esi+16*0], xmm7
  450. movdqa [esi+16*1], xmm7
  451. movdqa [esi+16*2], xmm7
  452. movdqa [esi+16*3], xmm7
  453. movdqa [esi+16*4], xmm7
  454. movdqa [esi+16*5], xmm7
  455. movdqa [esi+16*6], xmm7
  456. movdqa [esi+16*7], xmm7
  457. }
  459. }
  461. void mpeg2_idct_add_sse2(const int last, int16_t* block, uint8_t* dest, const int stride)
  462. {
  463. idct_M128ASM(block);
  464. /*
  465.     for(int i = 0; i < 8; i++)
  466. {
  467. dest[0] = CLIP(block[0] + dest[0]);
  468. dest[1] = CLIP(block[1] + dest[1]);
  469. dest[2] = CLIP(block[2] + dest[2]);
  470. dest[3] = CLIP(block[3] + dest[3]);
  471. dest[4] = CLIP(block[4] + dest[4]);
  472. dest[5] = CLIP(block[5] + dest[5]);
  473. dest[6] = CLIP(block[6] + dest[6]);
  474. dest[7] = CLIP(block[7] + dest[7]);
  476. memset(block, 0, sizeof(short)*8);
  478. dest += stride;
  479. block += 8;
  480.     }
  481. */
  482. __asm
  483. {
  484. mov esi, block
  485. mov edi, dest
  486. mov ecx, 4
  487. mov edx, stride
  488. xorps xmm7, xmm7
  490. mpeg2_idct_add_sse2_loop:
  492. movdqa xmm0, [esi]
  493. movdqa xmm1, [esi+16]
  495. movlps xmm2, [edi]
  496. punpcklbw xmm2, xmm7
  497. paddsw xmm0, xmm2
  499. movlps xmm2, [edi+edx]
  500. punpcklbw xmm2, xmm7
  501. paddsw xmm1, xmm2
  503. packuswb xmm0, xmm1
  505. movdqa [esi], xmm7
  506. movdqa [esi+16], xmm7
  508. movlps [edi], xmm0
  509. movhps [edi+edx], xmm0
  511. lea esi, [esi+16*2]
  512. lea edi, [edi+edx*2]
  514. dec ecx
  515. jnz mpeg2_idct_add_sse2_loop
  516. }
  517. }
  519. void mpeg2_idct_init_sse2()
  520. {
  521. }