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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
idctmmx.c
资源名称：DirectShowcode.rar　[点击查看]
上传用户：hhs829
上传日期：2022-06-17
资源大小：586k
文件大小：13k
源码类别：

DirextX编程

开发平台：

Visual C++

idctmmx.c：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. //  not functional
  3. //////////////////////////////////////////////////////////////////////
  4. // MPEG2AVI
  5. // -------- 
  6. //  v0.16B34
  7. //    performance optimization, idct_mmx32_rows() and idct_mmx32_cols() now
  8. //    transpose their respective outputs "in-place" (saves a bit of time)
  9. //
  10. //  v0.16B33 initial release
  11. //
  12. // MMX32 iDCT algorithm  (IEEE-1180 compliant) :: idct_mmx32()
  13. //
  14. //  This IDCT implementation is based on Intel Application Note AP-922.
  15. //
  16. //  This file implements the idct algorithm with no transpose.
  17. //  The other file (idctmm32_transpose.c) is faster, but transposes the 
  18. //  output-matrix.  (Intel's code-listing produces a transposed output.)
  19. //
  20. //  ALGORITHM OVERVIEW
  21. //  ------------------
  22. // This was one of the harder pieces of work to code.
  23. // Intel's app-note focuses on the numerical theory/issues of the IDCT 
  24. // implementation, but assumes the programmer is familiar with the
  25. // requisite mathematics, leaving the exact form of the complete IDCT 
  26. // code-listing up to the programmer's imagination.
  27. //
  28. // I played around with Intel's code-fragments for quite a few hours.  
  29. // This file is *A* working IDCT implementation, but it may not be
  30. // the implementation Intel originally intended.  Rest assured, I've
  31. // done everything in my power to guarantee its correctness. 
  32. // This implementation passes all six IEEE accuracy tests by a fair margin.
  33. //
  34. //   My IDCT algorithm consists of 4 steps:
  35. //
  36. //   1) IDCT-row transformation (using the IDCT-row function) on all 8 rows
  37. //      This yields an intermediate 8x8 matrix.
  38. //
  39. //   2) transpose of intermediate matrix (mandatory)
  40. //
  41. //   3) IDCT-row transformation (2nd time) on all 8 rows of the 
  42. //      intermediate matrix.
  43. //      At this point, we have the final-result, in transposed form.
  44. //
  45. //   4) post-transformation matrix transpose 
  46. //      (not necessary if the input-data is already transposed, this could
  47. //       be done during the MPEG "zig-zag" scan, but since my algorithm
  48. //       requires at least one transpose operation, why not re-use the
  49. //       transpose-code.)
  50. //
  51. //   Although the (1st) and (3rd) steps use the same basic row-transform 
  52. //   operation, the (3rd) step uses different shift&round constants 
  53. //   (explained later.)
  54. //
  55. //   Also note that the intermediate transpose (2) would not be neccessary,
  56. //   if the subsequent operation were a iDCT-column transformation.  Since
  57. //   we only have the iDCT-row transform, we transpose the intermediate
  58. //   matrix and use the iDCT-row transform a 2nd time.  I suppose one
  59. //   a faster (but more complicated) code-implementation is possible, 
  60. //   if these steps were merged.
  61. //
  62. //   I had to change some constants/variables for my method to work :
  63. //
  64. //      As given by Intel, #SHIFT_INV_COL and #RND_INV_COL are wrong.  
  65. //      Not surprising since I'm probably implementing the IDCT in
  66. //      perverse fashion.  
  67. //      round_inv_col[], which is given as "4 short" values, should have the
  68. //      same dimensions as round_inv_row[].  The corrected variables are 
  69. //      shown.
  70. //
  71. //      Intel's code defines 4 tables of constants.  My code only uses only
  72. //      one of these tables, row#0.  
  73. //
  74. //   IMPLEMENTATION DETAILs
  75. //   ----------------------
  76. // 
  77. //   I divided the 4-steps of my algorithm into two subroutines,
  78. //    1) idct_mmx32_rows() - transforms 8 rows, then transpose
  79. //    2) idct_mmx32_cols() - transforms 8 rows, then transpose
  80. //       yields final result ("drop-in" direct replacement for INT32 IDCT)
  81. //
  82. //   idct_mmx32_cols() is a carbon-copy of idct_mmx32_rows(), i.e. both
  83. //   execute a row-by-row transformations.  Only the shift&rounding 
  84. //   coefficients differ.
  85. //
  86. //      In the 1st function (rows), the shift & round instructions use 
  87. //       SHIFT_INV_ROW & round_inv_row[] (renamed to r_inv_row[])
  88. //
  89. //      In the 2nd function (cols)-> r_inv_col[], and
  90. //       SHIFT_INV_COL & round_inv_col[] (renamed to r_inv_col[])
  91. //
  92. //   Each function contains an integrated transpose-operator, which comes
  93. //   AFTER the primary transformation operation.  In the future, I'll optimize
  94. //   the code to do more of the transpose-work "in-place".  Right now, I've
  95. //   left the code as two subroutines and a main calling function, so other
  96. //   people can read the code more easily.
  99. //;=============================================================================
  100. //;
  101. //;  AP-922   http://developer.intel.com/vtune/cbts/strmsimd
  102. //; These examples contain code fragments for first stage iDCT 8x8
  103. //; (for rows) and first stage DCT 8x8 (for columns)
  104. //;
  105. //;=============================================================================
  107. #define BITS_INV_ACC 4 // 4 or 5 for IEEE
  108. // 5 yields higher accuracy, but lessens dynamic range on the input matrix
  109. #define SHIFT_INV_ROW (16 - BITS_INV_ACC)
  110. #define SHIFT_INV_COL (1 + BITS_INV_ACC + 14)
  111. #define RND_INV_ROW (1 << (SHIFT_INV_ROW-1))
  112. #define RND_INV_COL (1 << (SHIFT_INV_COL-1)) 
  113. #define RND_INV_CORR (RND_INV_COL - 1)
  115. const static int r_inv_row[2] = { RND_INV_ROW, RND_INV_ROW};
  116. const static int r_inv_col[2] = {RND_INV_COL, RND_INV_COL};
  117. const static int r_inv_corr[2] = {RND_INV_CORR, RND_INV_CORR};
  119. static const short tab_i_01234567[] = {
  120. 16384, 16384, 16384, -16384, 21407, 8867, 8867, -21407,
  121. 16384, -16384, 16384, 16384, -8867, 21407, -21407, -8867,
  122. 22725, 12873, 19266, -22725, 19266, 4520, -4520, -12873,
  123. 12873, 4520, 4520, 19266, -22725, 19266, -12873, -22725,
  124. };
  126. #define INP eax
  127. #define OUT ecx
  128. #define TABLE ebx
  129. #define round_inv_row edx
  130. #define round_inv_col edx
  131. #define ROW_STRIDE 16
  133. static __int64 qwTemp[32];
  135. __forceinline static void idct_mmx32_rows(short *block);
  136. __forceinline static void idct_mmx32_cols(short *block);
  138. // public interface to MMX32 IDCT 8x8 operation
  139. void MMX_IDCT(short *block)
  140. {
  141. idct_mmx32_rows(block);
  142. idct_mmx32_cols(block);
  143. }
  145. static void idct_mmx32_rows(short *block)
  146. {
  147. __asm
  148. {
  149. mov INP, [block]
  150. mov edi, 0x00
  151. lea TABLE, [tab_i_01234567]
  152. lea OUT, [qwTemp]
  153. lea round_inv_row, [r_inv_row]
  154. lpa:
  155. movq mm0, [INP]
  156. movq mm1, [INP+8]
  157. movq mm2, mm0
  158. movq mm3, [TABLE]
  159. punpcklwd mm0, mm1
  160. movq mm5, mm0
  161. punpckldq mm0, mm0
  162. movq mm4, [TABLE+8]
  163. punpckhwd mm2, mm1
  164. pmaddwd mm3, mm0
  165. movq mm6, mm2
  166. movq mm1, [TABLE+32]
  167. punpckldq mm2, mm2
  168. pmaddwd mm4, mm2
  169. punpckhdq mm5, mm5
  170. pmaddwd mm0, [TABLE+16]
  171. punpckhdq mm6, mm6
  172. movq mm7, [TABLE+40]
  173. pmaddwd mm1, mm5
  174. paddd mm3, [round_inv_row]
  175. pmaddwd mm7, mm6
  176. pmaddwd mm2, [TABLE+24]
  177. paddd mm3, mm4
  178. pmaddwd mm5, [TABLE+48]
  179. movq mm4, mm3
  180. pmaddwd mm6, [TABLE+56]
  181. paddd mm1, mm7
  182. paddd mm0, [round_inv_row]
  183. psubd mm3, mm1
  184. psrad mm3, SHIFT_INV_ROW
  185. paddd mm1, mm4
  186. paddd mm0, mm2
  187. psrad mm1, SHIFT_INV_ROW
  188. paddd mm5, mm6
  189. movq mm4, mm0
  190. paddd mm0, mm5
  191. psubd mm4, mm5
  192. add INP, 16
  193. psrad mm4, SHIFT_INV_ROW
  194. psrad mm0, SHIFT_INV_ROW
  195. packssdw mm4, mm3
  196. packssdw mm1, mm0
  197. movq mm7, mm4
  198. psrld mm4, 16
  199. movq [OUT], mm1
  200. pslld mm7, 16
  201. por mm7, mm4
  202. movq mm3, [TABLE]
  203. movq [OUT+8], mm7
  204. add edi, 0x01
  205. add OUT, 16
  206. cmp edi, 0x08
  207. jl lpa
  208. lea OUT, [qwTemp]
  209. movq mm0, [OUT+ROW_STRIDE*0]
  210. movq mm1, [OUT+ROW_STRIDE*1]
  211. movq mm4, mm0
  212. movq mm2, [OUT+ROW_STRIDE*2]
  213. punpcklwd mm0, mm1
  214. movq mm3, [OUT+ROW_STRIDE*3]
  215. punpckhwd mm4, mm1
  216. movq mm6, mm2
  217. punpcklwd mm2, mm3
  218. punpckhwd mm6, mm3
  219. movq mm1, mm0
  220. mov INP, [block]
  221. punpckldq mm0, mm2
  222. movq mm3, mm4
  223. punpckhdq mm1, mm2
  224. movq [INP+ROW_STRIDE*0], mm0
  225. punpckldq mm4, mm6
  226. movq mm0, [OUT+ROW_STRIDE*4+8]
  227. punpckhdq mm3, mm6
  228. movq [INP+ROW_STRIDE*2], mm4
  229. movq mm4, mm0
  230. movq [INP+ROW_STRIDE*1], mm1
  231. movq mm1, [OUT+ROW_STRIDE*5+8]
  232. movq [INP+ROW_STRIDE*3], mm3
  233. punpcklwd mm0, mm1
  234. movq mm2, [OUT+ROW_STRIDE*6+8]
  235. punpckhwd mm4, mm1
  236. movq mm3, [OUT+ROW_STRIDE*7+8]
  237. movq mm6, mm2
  238. punpcklwd mm2, mm3
  239. movq mm1, mm0
  240. punpckhwd mm6, mm3
  241. movq mm3, mm4
  242. punpckldq mm0, mm2
  243. punpckhdq mm1, mm2
  244. movq [INP+ROW_STRIDE*4+8], mm0
  245. punpckldq mm4, mm6
  246. movq mm0, [OUT+ROW_STRIDE*4]
  247. punpckhdq mm3, mm6
  248. movq [INP+ROW_STRIDE*6+8], mm4
  249. movq mm4, mm0
  250. movq [INP+ROW_STRIDE*5+8], mm1
  251. movq mm1, [OUT+ROW_STRIDE*5]
  252. movq [INP+ROW_STRIDE*7+8], mm3
  253. punpcklwd mm0, mm1
  254. movq mm2, [OUT+ROW_STRIDE*6]
  255. punpckhwd mm4, mm1
  256. movq mm3, [OUT+ROW_STRIDE*7]
  257. movq mm6, mm2
  258. punpcklwd mm2, mm3
  259. movq mm1, mm0
  260. punpckhwd mm6, mm3
  261. movq mm3, mm4
  262. punpckldq mm0, mm2
  263. punpckhdq mm1, mm2
  264. movq [INP+ROW_STRIDE*0+8], mm0
  265. punpckldq mm4, mm6
  266. movq mm0, [OUT+ROW_STRIDE*0+8]
  267. punpckhdq mm3, mm6
  268. movq [INP+ROW_STRIDE*2+8], mm4
  269. movq mm4, mm0
  270. movq [INP+ROW_STRIDE*1+8], mm1
  271. movq mm1, [OUT+ROW_STRIDE*1+8]
  272. movq [INP+ROW_STRIDE*3+8], mm3
  273. punpcklwd mm0, mm1
  274. movq mm2, [OUT+ROW_STRIDE*2+8]
  275. punpckhwd mm4, mm1
  276. movq mm3, [OUT+ROW_STRIDE*3+8]
  277. movq mm6, mm2
  278. punpcklwd mm2, mm3
  279. movq mm1, mm0
  280. punpckhwd mm6, mm3
  281. movq mm3, mm4
  282. punpckldq mm0, mm2
  283. punpckhdq mm1, mm2
  284. movq [INP+ROW_STRIDE*4], mm0
  285. punpckldq mm4, mm6
  286. movq [INP+ROW_STRIDE*5], mm1
  287. punpckhdq mm3, mm6
  288. movq [INP+ROW_STRIDE*6], mm4
  289. movq [INP+ROW_STRIDE*7], mm3
  290. }
  291. }
  293. static void idct_mmx32_cols(short *block)
  294. {
  295. __asm
  296. {
  297. mov INP, [block]
  298. mov edi, 0x00
  299. lea TABLE, [tab_i_01234567]
  300. lea OUT, [qwTemp]
  301. lea round_inv_col, [r_inv_col]
  302. acc_idct_colloop1:
  303. movq mm0, [INP]
  304. movq mm1, [INP+8]
  305. movq mm2, mm0
  306. movq mm3, [TABLE]
  307. punpcklwd mm0, mm1
  308. movq mm5, mm0
  309. punpckldq mm0, mm0
  310. movq mm4, [TABLE+8]
  311. punpckhwd mm2, mm1
  312. pmaddwd mm3, mm0
  313. movq mm6, mm2
  314. movq mm1, [TABLE+32]
  315. punpckldq mm2, mm2
  316. pmaddwd mm4, mm2
  317. punpckhdq mm5, mm5
  318. pmaddwd mm0, [TABLE+16]
  319. punpckhdq mm6, mm6
  320. movq mm7, [TABLE+40]
  321. pmaddwd mm1, mm5
  322. paddd mm3, [round_inv_col]
  323. pmaddwd mm7, mm6
  324. pmaddwd mm2, [TABLE+24]
  325. paddd mm3, mm4
  326. pmaddwd mm5, [TABLE+48]
  327. movq mm4, mm3
  328. pmaddwd mm6, [TABLE+56]
  329. paddd mm1, mm7
  330. paddd mm0, [round_inv_col]
  331. psubd mm3, mm1
  332. psrad mm3, SHIFT_INV_COL
  333. paddd mm1, mm4
  334. paddd mm0, mm2
  335. psrad mm1, SHIFT_INV_COL
  336. paddd mm5, mm6
  337. movq mm4, mm0
  338. paddd mm0, mm5
  339. psubd mm4, mm5
  340. add INP, 16
  341. psrad mm4, SHIFT_INV_COL
  342. add TABLE, 0
  343. psrad mm0, SHIFT_INV_COL
  344. packssdw mm4, mm3
  345. packssdw mm1, mm0
  346. movq mm7, mm4
  347. psrld mm4, 16
  348. movq [OUT], mm1
  349. pslld mm7, 16
  350. por mm7, mm4
  351. movq [OUT+8], mm7
  352. add edi, 0x01
  353. add OUT, 16
  354. cmp edi, 0x08
  355. jl acc_idct_colloop1
  356. lea OUT, [qwTemp]
  357. movq mm0, [OUT+ROW_STRIDE*0]
  358. movq mm1, [OUT+ROW_STRIDE*1]
  359. movq mm4, mm0
  360. movq mm2, [OUT+ROW_STRIDE*2]
  361. punpcklwd mm0, mm1
  362. movq mm3, [OUT+ROW_STRIDE*3]
  363. punpckhwd mm4, mm1
  364. movq mm6, mm2
  365. punpcklwd mm2, mm3
  366. punpckhwd mm6, mm3
  367. movq mm1, mm0
  368. mov INP, [block]
  369. punpckldq mm0, mm2
  370. movq mm3, mm4
  371. punpckhdq mm1, mm2
  372. movq [INP+ROW_STRIDE*0], mm0
  373. punpckldq mm4, mm6
  374. movq mm0, [OUT+ROW_STRIDE*4+8]
  375. punpckhdq mm3, mm6
  376. movq [INP+ROW_STRIDE*2], mm4
  377. movq mm4, mm0
  378. movq [INP+ROW_STRIDE*1], mm1
  379. movq mm1, [OUT+ROW_STRIDE*5+8]
  380. movq [INP+ROW_STRIDE*3], mm3
  381. punpcklwd mm0, mm1
  382. movq mm2, [OUT+ROW_STRIDE*6+8]
  383. punpckhwd mm4, mm1
  384. movq mm3, [OUT+ROW_STRIDE*7+8]
  385. movq mm6, mm2
  386. punpcklwd mm2, mm3
  387. movq mm1, mm0
  388. punpckhwd mm6, mm3
  389. movq mm3, mm4
  390. punpckldq mm0, mm2
  391. punpckhdq mm1, mm2
  392. movq [INP+ROW_STRIDE*4+8], mm0
  393. punpckldq mm4, mm6
  394. movq mm0, [OUT+ROW_STRIDE*4]
  395. punpckhdq mm3, mm6
  396. movq [INP+ROW_STRIDE*6+8], mm4
  397. movq mm4, mm0
  398. movq [INP+ROW_STRIDE*5+8], mm1
  399. movq mm1, [OUT+ROW_STRIDE*5]
  400. movq [INP+ROW_STRIDE*7+8], mm3
  401. punpcklwd mm0, mm1
  402. movq mm2, [OUT+ROW_STRIDE*6]
  403. punpckhwd mm4, mm1
  404. movq mm3, [OUT+ROW_STRIDE*7]
  405. movq mm6, mm2
  406. punpcklwd mm2, mm3
  407. movq mm1, mm0
  408. punpckhwd mm6, mm3
  409. movq mm3, mm4
  410. punpckldq mm0, mm2
  411. punpckhdq mm1, mm2
  412. movq [INP+ROW_STRIDE*0+8], mm0
  413. punpckldq mm4, mm6
  414. movq mm0, [OUT+ROW_STRIDE*0+8]
  415. punpckhdq mm3, mm6
  416. movq [INP+ROW_STRIDE*2+8], mm4
  417. movq mm4, mm0
  418. movq [INP+ROW_STRIDE*1+8], mm1
  419. movq mm1, [OUT + ROW_STRIDE*1+8]
  420. movq [INP+ROW_STRIDE*3+8], mm3
  421. punpcklwd mm0, mm1
  422. movq mm2, [OUT+ROW_STRIDE*2+8]
  423. punpckhwd mm4, mm1
  424. movq mm3, [OUT+ROW_STRIDE*3+8]
  425. movq mm6, mm2
  426. punpcklwd mm2, mm3
  427. movq mm1, mm0
  428. punpckhwd mm6, mm3
  429. movq mm3, mm4
  430. punpckldq mm0, mm2
  431. punpckhdq mm1, mm2
  432. movq [INP+ROW_STRIDE*4], mm0
  433. punpckldq mm4, mm6
  434. movq [INP+ROW_STRIDE*5], mm1
  435. punpckhdq mm3, mm6
  436. movq [INP+ROW_STRIDE*6], mm4
  437. movq [INP+ROW_STRIDE*7], mm3
  438. }
  439. }