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

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

多媒体编程

开发平台：

Visual C++

MPEG2Dec.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "MPEG2Dec.h"
  4. int testint;
  6. struct CPU {
  7. BOOL mmx;
  8. BOOL _3dnow;
  9. BOOL ssemmx;
  10. BOOL ssefpu;
  11. } cpu;
  13. void CheckCPU()
  14. {
  15. __asm
  16. {
  17. mov eax, 1
  18. cpuid
  19. test edx, 0x00800000 // STD MMX
  20. jz TEST_SSE
  21. mov [cpu.mmx], 1
  22. TEST_SSE:
  23. test edx, 0x02000000 // STD SSE
  24. jz TEST_3DNOW
  25. mov [cpu.ssemmx], 1
  26. mov [cpu.ssefpu], 1
  27. TEST_3DNOW:
  28. mov eax, 0x80000001
  29. cpuid
  30. test edx, 0x80000000 // 3D NOW
  31. jz TEST_SSEMMX
  32. mov [cpu._3dnow], 1
  33. TEST_SSEMMX:
  34. test edx, 0x00400000 // SSE MMX
  35. jz TEST_END
  36. mov [cpu.ssemmx], 1
  37. TEST_END:
  38. }
  39. }
  42. // idct
  43. extern "C" void __fastcall MMX_IDCT(short *block);
  44. extern "C" void __fastcall SSEMMX_IDCT(short *block);
  45. extern void Initialize_FPU_IDCT(void);
  46. extern void FPU_IDCT(short *block);
  47. extern void Initialize_REF_IDCT(void);
  48. extern void REF_IDCT(short *block);
  50. /* default intra quantization matrix */
  51. static unsigned char default_intra_quantizer_matrix[64] =
  52. {
  53. 8, 16, 19, 22, 26, 27, 29, 34,
  54. 16, 16, 22, 24, 27, 29, 34, 37,
  55. 19, 22, 26, 27, 29, 34, 34, 38,
  56. 22, 22, 26, 27, 29, 34, 37, 40,
  57. 22, 26, 27, 29, 32, 35, 40, 48,
  58. 26, 27, 29, 32, 35, 40, 48, 58,
  59. 26, 27, 29, 34, 38, 46, 56, 69,
  60. 27, 29, 35, 38, 46, 56, 69, 83
  61. };
  63. /* zig-zag and alternate scan patterns */
  64. static unsigned char scan[2][64] =
  65. {
  66. { /* Zig-Zag scan pattern  */
  67. 0,  1,  8, 16,  9,  2,  3, 10,
  68.    17, 24, 32, 25, 18, 11,  4,  5,
  69.    12, 19, 26, 33, 40, 48, 41, 34,
  70.    27, 20, 13,  6,  7, 14, 21, 28,
  71.    35, 42, 49, 56, 57, 50, 43, 36,
  72.    29, 22, 15, 23, 30, 37, 44, 51,
  73.    58, 59, 52, 45, 38, 31, 39, 46,
  74.    53, 60, 61, 54, 47, 55, 62, 63
  75. }
  76. ,
  77. { /* Alternate scan pattern */
  78. 0,  8, 16, 24,  1,  9,  2, 10,
  79.    17, 25, 32, 40, 48, 56, 57, 49,
  80.    41, 33, 26, 18,  3, 11, 4,  12,
  81.    19, 27, 34, 42, 50, 58, 35, 43,
  82.    51, 59, 20, 28,  5, 13,  6, 14,
  83.    21, 29, 36, 44, 52, 60, 37, 45,
  84.    53, 61, 22, 30,  7, 15, 23, 31,
  85.    38, 46, 54, 62, 39, 47, 55, 63
  86. }
  87. };
  89. /* non-linear quantization coefficient table */
  90. static unsigned char Non_Linear_quantizer_scale[32] =
  91. {
  92. 0, 1, 2, 3, 4, 5, 6, 7,
  93. 8, 10, 12, 14, 16, 18, 20, 22,
  94. 24, 28, 32, 36, 40, 44, 48, 52,
  95. 56, 64, 72, 80, 88, 96, 104, 112
  96. };
  98. #define ERROR_VALUE (-1)
  100. typedef struct {
  101. char run, level, len;
  102. } DCTtab;
  104. typedef struct {
  105. char val, len;
  106. } VLCtab;
  108. /* Table B-10, motion_code, codes 0001 ... 01xx */
  109. static VLCtab MVtab0[8] =
  110. {
  111. {ERROR_VALUE,0}, {3,3}, {2,2}, {2,2}, {1,1}, {1,1}, {1,1}, {1,1}
  112. };
  114. /* Table B-10, motion_code, codes 0000011 ... 000011x */
  115. static VLCtab MVtab1[8] =
  116. {
  117. {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {7,6}, {6,6}, {5,6}, {4,5}, {4,5}
  118. };
  120. /* Table B-10, motion_code, codes 0000001100 ... 000001011x */
  121. static VLCtab MVtab2[12] =
  122. {
  123. {16,9}, {15,9}, {14,9}, {13,9},
  124. {12,9}, {11,9}, {10,8}, {10,8},
  125. {9,8},  {9,8},  {8,8},  {8,8}
  126. };
  128. /* Table B-9, coded_block_pattern, codes 01000 ... 111xx */
  129. static VLCtab CBPtab0[32] =
  130. {
  131. {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0},
  132. {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0},
  133. {62,5}, {2,5},  {61,5}, {1,5},  {56,5}, {52,5}, {44,5}, {28,5},
  134. {40,5}, {20,5}, {48,5}, {12,5}, {32,4}, {32,4}, {16,4}, {16,4},
  135. {8,4},  {8,4},  {4,4},  {4,4},  {60,3}, {60,3}, {60,3}, {60,3}
  136. };
  138. /* Table B-9, coded_block_pattern, codes 00000100 ... 001111xx */
  139. static VLCtab CBPtab1[64] =
  140. {
  141. {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0},
  142. {58,8}, {54,8}, {46,8}, {30,8},
  143. {57,8}, {53,8}, {45,8}, {29,8}, {38,8}, {26,8}, {37,8}, {25,8},
  144. {43,8}, {23,8}, {51,8}, {15,8}, {42,8}, {22,8}, {50,8}, {14,8},
  145. {41,8}, {21,8}, {49,8}, {13,8}, {35,8}, {19,8}, {11,8}, {7,8},
  146. {34,7}, {34,7}, {18,7}, {18,7}, {10,7}, {10,7}, {6,7},  {6,7},
  147. {33,7}, {33,7}, {17,7}, {17,7}, {9,7},  {9,7},  {5,7},  {5,7},
  148. {63,6}, {63,6}, {63,6}, {63,6}, {3,6},  {3,6},  {3,6},  {3,6},
  149. {36,6}, {36,6}, {36,6}, {36,6}, {24,6}, {24,6}, {24,6}, {24,6}
  150. };
  152. /* Table B-9, coded_block_pattern, codes 000000001 ... 000000111 */
  153. static VLCtab CBPtab2[8] =
  154. {
  155. {ERROR_VALUE,0}, {0,9}, {39,9}, {27,9}, {59,9}, {55,9}, {47,9}, {31,9}
  156. };
  158. /* Table B-1, macroblock_address_increment, codes 00010 ... 011xx */
  159. static VLCtab MBAtab1[16] =
  160. {
  161. {ERROR_VALUE,0}, {ERROR_VALUE,0}, {7,5}, {6,5}, {5,4}, {5,4}, {4,4},
  162. {4,4}, {3,3}, {3,3}, {3,3}, {3,3}, {2,3}, {2,3}, {2,3}, {2,3}
  163. };
  165. /* Table B-1, macroblock_address_increment, codes 00000011000 ... 0000111xxxx */
  166. static VLCtab MBAtab2[104] =
  167. {
  168. {33,11}, {32,11}, {31,11}, {30,11}, {29,11}, {28,11}, {27,11}, {26,11},
  169. {25,11}, {24,11}, {23,11}, {22,11}, {21,10}, {21,10}, {20,10}, {20,10},
  170. {19,10}, {19,10}, {18,10}, {18,10}, {17,10}, {17,10}, {16,10}, {16,10},
  171. {15,8},  {15,8},  {15,8},  {15,8},  {15,8},  {15,8},  {15,8},  {15,8},
  172. {14,8},  {14,8},  {14,8},  {14,8},  {14,8},  {14,8},  {14,8},  {14,8},
  173. {13,8},  {13,8},  {13,8},  {13,8},  {13,8},  {13,8},  {13,8},  {13,8},
  174. {12,8},  {12,8},  {12,8},  {12,8},  {12,8},  {12,8},  {12,8},  {12,8},
  175. {11,8},  {11,8},  {11,8},  {11,8},  {11,8},  {11,8},  {11,8},  {11,8},
  176. {10,8},  {10,8},  {10,8},  {10,8},  {10,8},  {10,8},  {10,8},  {10,8},
  177. {9,7},   {9,7},   {9,7},   {9,7},   {9,7},   {9,7},   {9,7},   {9,7},
  178. {9,7},   {9,7},   {9,7},   {9,7},   {9,7},   {9,7},   {9,7},   {9,7},
  179. {8,7},   {8,7},   {8,7},   {8,7},   {8,7},   {8,7},   {8,7},   {8,7},
  180. {8,7},   {8,7},   {8,7},   {8,7},   {8,7},   {8,7},   {8,7},   {8,7}
  181. };
  183. /* Table B-12, dct_dc_size_luminance, codes 00xxx ... 11110 */
  184. static VLCtab DClumtab0[32] =
  185. {
  186. {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  187. {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  188. {0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
  189. {4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}, {ERROR_VALUE, 0}
  190. };
  192. /* Table B-12, dct_dc_size_luminance, codes 111110xxx ... 111111111 */
  193. static VLCtab DClumtab1[16] =
  194. {
  195. {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6},
  196. {8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10,9}, {11,9}
  197. };
  199. /* Table B-13, dct_dc_size_chrominance, codes 00xxx ... 11110 */
  200. static VLCtab DCchromtab0[32] =
  201. {
  202. {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
  203. {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  204. {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  205. {3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}, {ERROR_VALUE, 0}
  206. };
  208. /* Table B-13, dct_dc_size_chrominance, codes 111110xxxx ... 1111111111 */
  209. static VLCtab DCchromtab1[32] =
  210. {
  211. {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
  212. {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
  213. {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7},
  214. {8, 8}, {8, 8}, {8, 8}, {8, 8}, {9, 9}, {9, 9}, {10,10}, {11,10}
  215. };
  217. /* Table B-14, DCT coefficients table zero,
  218.  * codes 0100 ... 1xxx (used for first (DC) coefficient)
  219.  */
  220. static DCTtab DCTtabfirst[12] =
  221. {
  222. {0,2,4}, {2,1,4}, {1,1,3}, {1,1,3},
  223. {0,1,1}, {0,1,1}, {0,1,1}, {0,1,1},
  224. {0,1,1}, {0,1,1}, {0,1,1}, {0,1,1}
  225. };
  227. /* Table B-14, DCT coefficients table zero,
  228.  * codes 0100 ... 1xxx (used for all other coefficients)
  229.  */
  230. static DCTtab DCTtabnext[12] =
  231. {
  232. {0,2,4},  {2,1,4},  {1,1,3},  {1,1,3},
  233. {64,0,2}, {64,0,2}, {64,0,2}, {64,0,2}, /* EOB */
  234. {0,1,2},  {0,1,2},  {0,1,2},  {0,1,2}
  235. };
  237. /* Table B-14, DCT coefficients table zero,
  238.  * codes 000001xx ... 00111xxx
  239.  */
  240. static DCTtab DCTtab0[60] =
  241. {
  242. {65,0,6}, {65,0,6}, {65,0,6}, {65,0,6}, /* Escape */
  243. {2,2,7}, {2,2,7}, {9,1,7}, {9,1,7},
  244. {0,4,7}, {0,4,7}, {8,1,7}, {8,1,7},
  245. {7,1,6}, {7,1,6}, {7,1,6}, {7,1,6},
  246. {6,1,6}, {6,1,6}, {6,1,6}, {6,1,6},
  247. {1,2,6}, {1,2,6}, {1,2,6}, {1,2,6},
  248. {5,1,6}, {5,1,6}, {5,1,6}, {5,1,6},
  249. {13,1,8}, {0,6,8}, {12,1,8}, {11,1,8},
  250. {3,2,8}, {1,3,8}, {0,5,8}, {10,1,8},
  251. {0,3,5}, {0,3,5}, {0,3,5}, {0,3,5},
  252. {0,3,5}, {0,3,5}, {0,3,5}, {0,3,5},
  253. {4,1,5}, {4,1,5}, {4,1,5}, {4,1,5},
  254. {4,1,5}, {4,1,5}, {4,1,5}, {4,1,5},
  255. {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5},
  256. {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5}
  257. };
  259. /* Table B-15, DCT coefficients table one,
  260.  * codes 000001xx ... 11111111
  261. */
  262. static DCTtab DCTtab0a[252] =
  263. {
  264. {65,0,6}, {65,0,6}, {65,0,6}, {65,0,6}, /* Escape */
  265. {7,1,7}, {7,1,7}, {8,1,7}, {8,1,7},
  266. {6,1,7}, {6,1,7}, {2,2,7}, {2,2,7},
  267. {0,7,6}, {0,7,6}, {0,7,6}, {0,7,6},
  268. {0,6,6}, {0,6,6}, {0,6,6}, {0,6,6},
  269. {4,1,6}, {4,1,6}, {4,1,6}, {4,1,6},
  270. {5,1,6}, {5,1,6}, {5,1,6}, {5,1,6},
  271. {1,5,8}, {11,1,8}, {0,11,8}, {0,10,8},
  272. {13,1,8}, {12,1,8}, {3,2,8}, {1,4,8},
  273. {2,1,5}, {2,1,5}, {2,1,5}, {2,1,5},
  274. {2,1,5}, {2,1,5}, {2,1,5}, {2,1,5},
  275. {1,2,5}, {1,2,5}, {1,2,5}, {1,2,5},
  276. {1,2,5}, {1,2,5}, {1,2,5}, {1,2,5},
  277. {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5},
  278. {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5},
  279. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  280. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  281. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  282. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  283. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  284. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  285. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  286. {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
  287. {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4}, /* EOB */
  288. {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4},
  289. {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4},
  290. {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4},
  291. {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
  292. {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
  293. {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
  294. {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
  295. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  296. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  297. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  298. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  299. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  300. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  301. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  302. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  303. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  304. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  305. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  306. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  307. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  308. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  309. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  310. {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
  311. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  312. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  313. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  314. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  315. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  316. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  317. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  318. {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
  319. {0,4,5}, {0,4,5}, {0,4,5}, {0,4,5},
  320. {0,4,5}, {0,4,5}, {0,4,5}, {0,4,5},
  321. {0,5,5}, {0,5,5}, {0,5,5}, {0,5,5},
  322. {0,5,5}, {0,5,5}, {0,5,5}, {0,5,5},
  323. {9,1,7}, {9,1,7}, {1,3,7}, {1,3,7},
  324. {10,1,7}, {10,1,7}, {0,8,7}, {0,8,7},
  325. {0,9,7}, {0,9,7}, {0,12,8}, {0,13,8},
  326. {2,3,8}, {4,2,8}, {0,14,8}, {0,15,8}
  327. };
  329. /* Table B-14, DCT coefficients table zero,
  330.  * codes 0000001000 ... 0000001111
  331.  */
  332. static DCTtab DCTtab1[8] =
  333. {
  334. {16,1,10}, {5,2,10}, {0,7,10}, {2,3,10},
  335. {1,4,10}, {15,1,10}, {14,1,10}, {4,2,10}
  336. };
  338. /* Table B-15, DCT coefficients table one,
  339.  * codes 000000100x ... 000000111x
  340.  */
  341. static DCTtab DCTtab1a[8] =
  342. {
  343. {5,2,9}, {5,2,9}, {14,1,9}, {14,1,9},
  344. {2,4,10}, {16,1,10}, {15,1,9}, {15,1,9}
  345. };
  347. /* Table B-14/15, DCT coefficients table zero / one,
  348.  * codes 000000010000 ... 000000011111
  349.  */
  350. static DCTtab DCTtab2[16] =
  351. {
  352. {0,11,12}, {8,2,12}, {4,3,12}, {0,10,12},
  353. {2,4,12}, {7,2,12}, {21,1,12}, {20,1,12},
  354. {0,9,12}, {19,1,12}, {18,1,12}, {1,5,12},
  355. {3,3,12}, {0,8,12}, {6,2,12}, {17,1,12}
  356. };
  358. /* Table B-14/15, DCT coefficients table zero / one,
  359.  * codes 0000000010000 ... 0000000011111
  360.  */
  361. static DCTtab DCTtab3[16] =
  362. {
  363. {10,2,13}, {9,2,13}, {5,3,13}, {3,4,13},
  364. {2,5,13}, {1,7,13}, {1,6,13}, {0,15,13},
  365. {0,14,13}, {0,13,13}, {0,12,13}, {26,1,13},
  366. {25,1,13}, {24,1,13}, {23,1,13}, {22,1,13}
  367. };
  369. /* Table B-14/15, DCT coefficients table zero / one,
  370.  * codes 00000000010000 ... 00000000011111
  371.  */
  372. static DCTtab DCTtab4[16] =
  373. {
  374. {0,31,14}, {0,30,14}, {0,29,14}, {0,28,14},
  375. {0,27,14}, {0,26,14}, {0,25,14}, {0,24,14},
  376. {0,23,14}, {0,22,14}, {0,21,14}, {0,20,14},
  377. {0,19,14}, {0,18,14}, {0,17,14}, {0,16,14}
  378. };
  380. /* Table B-14/15, DCT coefficients table zero / one,
  381.  * codes 000000000010000 ... 000000000011111
  382.  */
  383. static DCTtab DCTtab5[16] =
  384. {
  385. {0,40,15}, {0,39,15}, {0,38,15}, {0,37,15},
  386. {0,36,15}, {0,35,15}, {0,34,15}, {0,33,15},
  387. {0,32,15}, {1,14,15}, {1,13,15}, {1,12,15},
  388. {1,11,15}, {1,10,15}, {1,9,15}, {1,8,15}
  389. };
  391. /* Table B-14/15, DCT coefficients table zero / one,
  392.  * codes 0000000000010000 ... 0000000000011111
  393.  */
  394. static DCTtab DCTtab6[16] =
  395. {
  396. {1,18,16}, {1,17,16}, {1,16,16}, {1,15,16},
  397. {6,3,16}, {16,2,16}, {15,2,16}, {14,2,16},
  398. {13,2,16}, {12,2,16}, {11,2,16}, {31,1,16},
  399. {30,1,16}, {29,1,16}, {28,1,16}, {27,1,16}
  400. };
  402. /* Table B-3, macroblock_type in P-pictures, codes 001..1xx */
  403. static VLCtab PMBtab0[8] =
  404. {
  405. {ERROR_VALUE,0},
  406. {MACROBLOCK_MOTION_FORWARD,3},
  407. {MACROBLOCK_PATTERN,2}, {MACROBLOCK_PATTERN,2},
  408. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1}, 
  409. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1},
  410. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1}, 
  411. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1}
  412. };
  414. /* Table B-3, macroblock_type in P-pictures, codes 000001..00011x */
  415. static VLCtab PMBtab1[8] =
  416. {
  417. {ERROR_VALUE,0},
  418. {MACROBLOCK_QUANT|MACROBLOCK_INTRA,6},
  419. {MACROBLOCK_QUANT|MACROBLOCK_PATTERN,5}, {MACROBLOCK_QUANT|MACROBLOCK_PATTERN,5},
  420. {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,5}, {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,5},
  421. {MACROBLOCK_INTRA,5}, {MACROBLOCK_INTRA,5}
  422. };
  424. /* Table B-4, macroblock_type in B-pictures, codes 0010..11xx */
  425. static VLCtab BMBtab0[16] =
  426. {
  427. {ERROR_VALUE,0}, 
  428. {ERROR_VALUE,0},
  429. {MACROBLOCK_MOTION_FORWARD,4},
  430. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,4},
  431. {MACROBLOCK_MOTION_BACKWARD,3}, 
  432. {MACROBLOCK_MOTION_BACKWARD,3},
  433. {MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,3}, 
  434. {MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,3},
  435. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2}, 
  436. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2},
  437. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2}, 
  438. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2},
  439. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2},
  440. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2},
  441. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2},
  442. {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2}
  443. };
  445. /* Table B-4, macroblock_type in B-pictures, codes 000001..00011x */
  446. static VLCtab BMBtab1[8] =
  447. {
  448. {ERROR_VALUE,0},
  449. {MACROBLOCK_QUANT|MACROBLOCK_INTRA,6},
  450. {MACROBLOCK_QUANT|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,6},
  451. {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,6},
  452. {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,5},
  453. {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,5},
  454. {MACROBLOCK_INTRA,5}, 
  455. {MACROBLOCK_INTRA,5}
  456. };
  458. //
  459. // getbit
  460. //
  462. void CMPEG2Dec::Initialize_Buffer()
  463. {
  464. Rdptr = Rdbfr + BUFFER_SIZE;
  465. Rdmax = Rdptr;
  467. if (SystemStream_Flag)
  468. {
  469. if (Rdptr >= Rdmax)
  470. Next_Packet();
  471. CurrentBfr = *Rdptr++ << 24;
  473. if (Rdptr >= Rdmax)
  474. Next_Packet();
  475. CurrentBfr += *Rdptr++ << 16;
  477. if (Rdptr >= Rdmax)
  478. Next_Packet();
  479. CurrentBfr += *Rdptr++ << 8;
  481. if (Rdptr >= Rdmax)
  482. Next_Packet();
  483. CurrentBfr += *Rdptr++;
  485. Fill_Next();
  486. }
  487. else
  488. {
  489. Fill_Buffer();
  491. CurrentBfr = (*Rdptr << 24) + (*(Rdptr+1) << 16) + (*(Rdptr+2) << 8) + *(Rdptr+3);
  492. Rdptr += 4;
  494. Fill_Next();
  495. }
  497. BitsLeft = 32;
  498. }
  500. unsigned int CMPEG2Dec::Get_Bits_All(unsigned int N)
  501. {
  502. N -= BitsLeft;
  503. Val = (CurrentBfr << (32 - BitsLeft)) >> (32 - BitsLeft);
  505. if (N != 0)
  506. Val = (Val << N) + (NextBfr >> (32 - N));
  508. CurrentBfr = NextBfr;
  509. BitsLeft = 32 - N;
  510. Fill_Next();
  512. return Val;
  513. }
  515. void CMPEG2Dec::Flush_Buffer_All(unsigned int N)
  516. {
  517. CurrentBfr = NextBfr;
  518. BitsLeft = BitsLeft + 32 - N;
  519. Fill_Next();
  520. }
  522. void CMPEG2Dec::Next_Packet()
  523. {
  524. unsigned int code, Packet_Length, Packet_Header_Length;
  526. for (;;)
  527. {
  528. code = Get_Short();
  529. code = (code<<16) + Get_Short();
  531. // remove system layer byte stuffing
  532. while ((code & 0xffffff00) != 0x00000100)
  533. code = (code<<8) + Get_Byte();
  535. switch (code)
  536. {
  537. case PACK_START_CODE:
  538. Rdptr += 8;
  539. break;
  541. case VIDEO_ELEMENTARY_STREAM:   
  542. Packet_Length = Get_Short();
  543. Rdmax = Rdptr + Packet_Length;
  545. code = Get_Byte();
  547. if ((code & 0xc0)==0x80)
  548. {
  549. code = Get_Byte();
  550. Packet_Header_Length = Get_Byte();
  552. Rdptr += Packet_Header_Length;
  553. return;
  554. }
  555. else
  556. Rdptr += Packet_Length-1;
  557. break;
  559. default:
  560. if (code>=SYSTEM_START_CODE)
  561. {
  562. code = Get_Short();
  563. Rdptr += code;
  564. }
  565. break;
  566. }
  567. }
  568. }
  570. void CMPEG2Dec::Fill_Buffer()
  571. {
  572. Read = _read(Infile[File_Flag], Rdbfr, BUFFER_SIZE);
  574. if (Read < BUFFER_SIZE)
  575. Next_File();
  577. if (KeyOp_Flag && (Rdbfr[20] & 0x10))
  578. {
  579. BufferOp(Rdbfr, lfsr0, lfsr1);
  580. Rdbfr[20] &= ~0x10;
  581. }
  583. Rdptr = Rdbfr;
  585. if (SystemStream_Flag)
  586. Rdmax -= BUFFER_SIZE;
  587. }
  589. void CMPEG2Dec::Next_File()
  590. {
  591. if (File_Flag < File_Limit-1)
  592. File_Flag ++;
  594. _lseeki64(Infile[File_Flag], 0, SEEK_SET);
  595. _read(Infile[File_Flag], Rdbfr + Read, BUFFER_SIZE - Read);
  596. }
  599. unsigned int CMPEG2Dec::Show_Bits(unsigned int N)
  600. {
  601. if (N <= BitsLeft)
  602. return (CurrentBfr << (32 - BitsLeft)) >> (32 - N);
  603. else
  604. {
  605. N -= BitsLeft;
  606. return (((CurrentBfr << (32 - BitsLeft)) >> (32 - BitsLeft)) << N) + (NextBfr >> (32 - N));
  607. }
  608. }
  610. unsigned int CMPEG2Dec::Get_Bits(unsigned int N)
  611. {
  612. if (N < BitsLeft)
  613. {
  614. Val = (CurrentBfr << (32 - BitsLeft)) >> (32 - N);
  615. BitsLeft -= N;
  616. return Val;
  617. }
  618. else
  619. return Get_Bits_All(N);
  620. }
  622. void CMPEG2Dec::Flush_Buffer(unsigned int N)
  623. {
  624. if (N < BitsLeft)
  625. BitsLeft -= N;
  626. else
  627. Flush_Buffer_All(N);
  628. }
  630. void CMPEG2Dec::Fill_Next()
  631. {
  632. if (SystemStream_Flag && Rdptr>=Rdmax-4)
  633. {
  634. if (Rdptr >= Rdmax)
  635. Next_Packet();
  636. NextBfr = Get_Byte() << 24;
  638. if (Rdptr >= Rdmax)
  639. Next_Packet();
  640. NextBfr += Get_Byte() << 16;
  642. if (Rdptr >= Rdmax)
  643. Next_Packet();
  644. NextBfr += Get_Byte() << 8;
  646. if (Rdptr >= Rdmax)
  647. Next_Packet();
  648. NextBfr += Get_Byte();
  649. }
  650. else if (Rdptr < Rdbfr+BUFFER_SIZE-4)
  651. {
  652. NextBfr = (*Rdptr << 24) + (*(Rdptr+1) << 16) + (*(Rdptr+2) << 8) + *(Rdptr+3);
  653. Rdptr += 4;
  654. }
  655. else
  656. {
  657. if (Rdptr >= Rdbfr+BUFFER_SIZE)
  658. Fill_Buffer();
  659. NextBfr = *Rdptr++ << 24;
  661. if (Rdptr >= Rdbfr+BUFFER_SIZE)
  662. Fill_Buffer();
  663. NextBfr += *Rdptr++ << 16;
  665. if (Rdptr >= Rdbfr+BUFFER_SIZE)
  666. Fill_Buffer();
  667. NextBfr += *Rdptr++ << 8;
  669. if (Rdptr >= Rdbfr+BUFFER_SIZE)
  670. Fill_Buffer();
  671. NextBfr += *Rdptr++;
  672. }
  673. }
  675. unsigned int CMPEG2Dec::Get_Byte()
  676. {
  677. while (Rdptr >= (Rdbfr + BUFFER_SIZE))
  678. {
  679. Read = _read(Infile[File_Flag], Rdbfr, BUFFER_SIZE);
  681. if (Read < BUFFER_SIZE)
  682. Next_File();
  684. if (KeyOp_Flag && (Rdbfr[20] & 0x10))
  685. {
  686. BufferOp(Rdbfr, lfsr0, lfsr1);
  687. Rdbfr[20] &= ~0x10;
  688. }
  690. Rdptr -= BUFFER_SIZE;
  691. Rdmax -= BUFFER_SIZE;
  692. }
  694. return *Rdptr++;
  695. }
  697. unsigned int CMPEG2Dec::Get_Short()
  698. {
  699. unsigned int i = Get_Byte();
  700. return (i<<8) + Get_Byte();
  701. }
  703. void CMPEG2Dec::next_start_code()
  704. {
  705. Flush_Buffer(BitsLeft & 7);
  707. while (Show_Bits(24) != 1)
  708. Flush_Buffer(8);
  709. }
  711. //
  712. // gethdr
  713. //
  715. int CMPEG2Dec::Get_Hdr()
  716. {
  717. for (;;)
  718. {
  719. /* look for next_start_code */
  720. next_start_code();
  722. switch (Get_Bits(32))
  723. {
  724. case SEQUENCE_HEADER_CODE:
  725. sequence_header();
  726. break;
  728. case GROUP_START_CODE:
  729. group_of_pictures_header();
  730. break;
  732. case PICTURE_START_CODE:
  733. picture_header();
  734. return 1;
  735. }
  736. }
  737. }
  739. /* decode group of pictures header */
  740. /* ISO/IEC 13818-2 section 6.2.2.6 */
  741. void CMPEG2Dec::group_of_pictures_header()
  742. {
  743. int gop_hour;
  744. int gop_minute;
  745. int gop_sec;
  746. int gop_frame;
  748. int drop_flag;
  749. int closed_gop;
  750. int broken_link;
  752. drop_flag   = Get_Bits(1);
  753. gop_hour    = Get_Bits(5);
  754. gop_minute  = Get_Bits(6);
  755. Flush_Buffer(1); // marker bit
  756. gop_sec     = Get_Bits(6);
  757. gop_frame = Get_Bits(6);
  758. closed_gop  = Get_Bits(1);
  759. broken_link = Get_Bits(1);
  761. extension_and_user_data();
  762. }
  764. /* decode picture header */
  765. /* ISO/IEC 13818-2 section 6.2.3 */
  766. void CMPEG2Dec::picture_header()
  767. {
  768. int vbv_delay;
  769. int full_pel_forward_vector;
  770. int forward_f_code;
  771. int full_pel_backward_vector;
  772. int backward_f_code;
  773. int Extra_Information_Byte_Count;
  775. temporal_reference  = Get_Bits(10);
  776. picture_coding_type = Get_Bits(3);
  777. vbv_delay           = Get_Bits(16);
  779. if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)
  780. {
  781. full_pel_forward_vector = Get_Bits(1);
  782. forward_f_code = Get_Bits(3);
  783. }
  785. if (picture_coding_type==B_TYPE)
  786. {
  787. full_pel_backward_vector = Get_Bits(1);
  788. backward_f_code = Get_Bits(3);
  789. }
  791. Extra_Information_Byte_Count = extra_bit_information();
  792. extension_and_user_data();
  793. }
  795. /* decode sequence header */
  796. void CMPEG2Dec::sequence_header()
  797. {
  798. int frame_rate_code;
  799. int vbv_buffer_size;
  800. int aspect_ratio_information;
  801. int bit_rate_value;
  803. int constrained_parameters_flag;
  804. int i;
  806. horizontal_size             = Get_Bits(12);
  807. vertical_size               = Get_Bits(12);
  808. aspect_ratio_information    = Get_Bits(4);
  809. frame_rate_code             = Get_Bits(4);
  810. bit_rate_value              = Get_Bits(18);
  811. Flush_Buffer(1); // marker bit
  812. vbv_buffer_size             = Get_Bits(10);
  813. constrained_parameters_flag = Get_Bits(1);
  815. if (load_intra_quantizer_matrix = Get_Bits(1))
  816. {
  817. for (i=0; i<64; i++)
  818. intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  819. }
  820. else
  821. {
  822. for (i=0; i<64; i++)
  823. intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
  824. }
  826. if (load_non_intra_quantizer_matrix = Get_Bits(1))
  827. {
  828. for (i=0; i<64; i++)
  829. non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  830. }
  831. else
  832. {
  833. for (i=0; i<64; i++)
  834. non_intra_quantizer_matrix[i] = 16;
  835. }
  837. /* copy luminance to chrominance matrices */
  838. for (i=0; i<64; i++)
  839. {
  840. chroma_intra_quantizer_matrix[i] = intra_quantizer_matrix[i];
  841. chroma_non_intra_quantizer_matrix[i] = non_intra_quantizer_matrix[i];
  842. }
  843. extension_and_user_data();
  844. }
  846. /* decode slice header */
  847. /* ISO/IEC 13818-2 section 6.2.4 */
  848. int CMPEG2Dec::slice_header()
  849. {
  850. int slice_vertical_position_extension;
  851. int quantizer_scale_code;
  852. int slice_picture_id_enable = 0;
  853. int slice_picture_id = 0;
  854. int extra_information_slice = 0;
  856. slice_vertical_position_extension = vertical_size>2800 ? Get_Bits(3) : 0;
  858. quantizer_scale_code = Get_Bits(5);
  859. quantizer_scale = q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] : quantizer_scale_code<<1;
  861. /* slice_id introduced in March 1995 as part of the video corridendum
  862.    (after the IS was drafted in November 1994) */
  863. if (Get_Bits(1))
  864. {
  865. Get_Bits(1); // intra slice
  867. slice_picture_id_enable = Get_Bits(1);
  868. slice_picture_id = Get_Bits(6);
  870. extra_information_slice = extra_bit_information();
  871. }
  873. return slice_vertical_position_extension;
  874. }
  876. /* decode extension and user data */
  877. /* ISO/IEC 13818-2 section 6.2.2.2 */
  878. void CMPEG2Dec::extension_and_user_data()
  879. {
  880. int code, ext_ID;
  882. next_start_code();
  884. while ((code = Show_Bits(32))==EXTENSION_START_CODE || code==USER_DATA_START_CODE)
  885. {
  886. if (code==EXTENSION_START_CODE)
  887. {
  888. Flush_Buffer(32);
  889. ext_ID = Get_Bits(4);
  891. switch (ext_ID)
  892. {
  893. case SEQUENCE_EXTENSION_ID:
  894. sequence_extension();
  895. break;
  897. case SEQUENCE_DISPLAY_EXTENSION_ID:
  898. sequence_display_extension();
  899. break;
  901. case QUANT_MATRIX_EXTENSION_ID:
  902. quant_matrix_extension();
  903. break;
  905. case PICTURE_DISPLAY_EXTENSION_ID:
  906. picture_display_extension();
  907. break;
  909. case PICTURE_CODING_EXTENSION_ID:
  910. picture_coding_extension();
  911. break;
  913. case COPYRIGHT_EXTENSION_ID:
  914. copyright_extension();
  915. break;
  916. }
  917. next_start_code();
  918. }
  919. else
  920. {
  921. Flush_Buffer(32);
  922. next_start_code();
  923. }
  924. }
  925. }
  927. /* decode sequence extension */
  928. /* ISO/IEC 13818-2 section 6.2.2.3 */
  929. void CMPEG2Dec::sequence_extension()
  930. {
  931. int profile_and_level_indication;
  932. int low_delay;
  933. int frame_rate_extension_n;
  934. int frame_rate_extension_d;
  936. int horizontal_size_extension;
  937. int vertical_size_extension;
  938. int bit_rate_extension;
  939. int vbv_buffer_size_extension;
  941. profile_and_level_indication = Get_Bits(8);
  942. progressive_sequence         = Get_Bits(1);
  943. chroma_format                = Get_Bits(2);
  944. horizontal_size_extension    = Get_Bits(2);
  945. vertical_size_extension      = Get_Bits(2);
  946. bit_rate_extension           = Get_Bits(12);
  947. Flush_Buffer(1); // marker bit
  948. vbv_buffer_size_extension    = Get_Bits(8);
  949. low_delay                    = Get_Bits(1);
  950.  
  951. frame_rate_extension_n       = Get_Bits(2);
  952. frame_rate_extension_d       = Get_Bits(5);
  954. horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
  955. vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);
  956. }
  958. /* decode sequence display extension */
  959. void CMPEG2Dec::sequence_display_extension()
  960. {
  961. int video_format;  
  962. int color_description;
  963. int color_primaries;
  964. int transfer_characteristics;
  965. int matrix_coefficients;
  966. int display_horizontal_size;
  967. int display_vertical_size;
  969. video_format      = Get_Bits(3);
  970. color_description = Get_Bits(1);
  972. if (color_description)
  973. {
  974. color_primaries          = Get_Bits(8);
  975. transfer_characteristics = Get_Bits(8);
  976. matrix_coefficients      = Get_Bits(8);
  977. }
  979. display_horizontal_size = Get_Bits(14);
  980. Flush_Buffer(1); // marker bit
  981. display_vertical_size   = Get_Bits(14);
  982. }
  984. /* decode quant matrix entension */
  985. /* ISO/IEC 13818-2 section 6.2.3.2 */
  986. void CMPEG2Dec::quant_matrix_extension()
  987. {
  988. int i;
  990. if (load_intra_quantizer_matrix = Get_Bits(1))
  991. for (i=0; i<64; i++)
  992. chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  993. = intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  995. if (load_non_intra_quantizer_matrix = Get_Bits(1))
  996. for (i=0; i<64; i++)
  997. chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  998. = non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  1000. if (load_chroma_intra_quantizer_matrix = Get_Bits(1))
  1001. for (i=0; i<64; i++)
  1002. chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  1004. if (load_chroma_non_intra_quantizer_matrix = Get_Bits(1))
  1005. for (i=0; i<64; i++)
  1006. chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  1007. }
  1009. /* decode picture display extension */
  1010. /* ISO/IEC 13818-2 section 6.2.3.3. */
  1011. void CMPEG2Dec::picture_display_extension()
  1012. {
  1013. int frame_center_horizontal_offset[3];
  1014. int frame_center_vertical_offset[3];
  1016. int i;
  1017. int number_of_frame_center_offsets;
  1019. /* based on ISO/IEC 13818-2 section 6.3.12 
  1020.    (November 1994) Picture display extensions */
  1022. /* derive number_of_frame_center_offsets */
  1023. if (progressive_sequence)
  1024. {
  1025. if (repeat_first_field)
  1026. {
  1027. if (top_field_first)
  1028. number_of_frame_center_offsets = 3;
  1029. else
  1030. number_of_frame_center_offsets = 2;
  1031. }
  1032. else
  1033. number_of_frame_center_offsets = 1;
  1034. }
  1035. else
  1036. {
  1037. if (picture_structure!=FRAME_PICTURE)
  1038. number_of_frame_center_offsets = 1;
  1039. else
  1040. {
  1041. if (repeat_first_field)
  1042. number_of_frame_center_offsets = 3;
  1043. else
  1044. number_of_frame_center_offsets = 2;
  1045. }
  1046. }
  1048. /* now parse */
  1049. for (i=0; i<number_of_frame_center_offsets; i++)
  1050. {
  1051. frame_center_horizontal_offset[i] = Get_Bits(16);
  1052. Flush_Buffer(1); // marker bit
  1054. frame_center_vertical_offset[i] = Get_Bits(16);
  1055. Flush_Buffer(1); // marker bit
  1056. }
  1057. }
  1059. /* decode picture coding extension */
  1060. void CMPEG2Dec::picture_coding_extension()
  1061. {
  1062. int chroma_420_type;
  1063. int composite_display_flag;
  1064. int v_axis;
  1065. int field_sequence;
  1066. int sub_carrier;
  1067. int burst_amplitude;
  1068. int sub_carrier_phase;
  1070. f_code[0][0] = Get_Bits(4);
  1071. f_code[0][1] = Get_Bits(4);
  1072. f_code[1][0] = Get_Bits(4);
  1073. f_code[1][1] = Get_Bits(4);
  1075. intra_dc_precision         = Get_Bits(2);
  1076. picture_structure          = Get_Bits(2);
  1077. top_field_first            = Get_Bits(1);
  1078. frame_pred_frame_dct       = Get_Bits(1);
  1079. concealment_motion_vectors = Get_Bits(1);
  1080. q_scale_type    = Get_Bits(1);
  1081. intra_vlc_format           = Get_Bits(1);
  1082. alternate_scan    = Get_Bits(1);
  1083. repeat_first_field         = Get_Bits(1);
  1084. chroma_420_type            = Get_Bits(1);
  1085. progressive_frame          = Get_Bits(1);
  1086. composite_display_flag     = Get_Bits(1);
  1088. pf_current = progressive_frame;
  1090. if (composite_display_flag)
  1091. {
  1092. v_axis            = Get_Bits(1);
  1093. field_sequence    = Get_Bits(3);
  1094. sub_carrier       = Get_Bits(1);
  1095. burst_amplitude   = Get_Bits(7);
  1096. sub_carrier_phase = Get_Bits(8);
  1097. }
  1098. }
  1100. /* decode extra bit information */
  1101. /* ISO/IEC 13818-2 section 6.2.3.4. */
  1102. int CMPEG2Dec::extra_bit_information()
  1103. {
  1104. int Byte_Count = 0;
  1106. while (Get_Bits(1))
  1107. {
  1108. Flush_Buffer(8);
  1109. Byte_Count ++;
  1110. }
  1112. return(Byte_Count);
  1113. }
  1115. /* Copyright extension */
  1116. /* ISO/IEC 13818-2 section 6.2.3.6. */
  1117. /* (header added in November, 1994 to the IS document) */
  1118. void CMPEG2Dec::copyright_extension()
  1119. {
  1120. int copyright_flag;
  1121. int copyright_identifier;
  1122. int original_or_copy;
  1123. int copyright_number_1;
  1124. int copyright_number_2;
  1125. int copyright_number_3;
  1127. int reserved_data;
  1129. copyright_flag =       Get_Bits(1); 
  1130. copyright_identifier = Get_Bits(8);
  1131. original_or_copy =     Get_Bits(1);
  1132.   
  1133. /* reserved */
  1134. reserved_data = Get_Bits(7);
  1136. Flush_Buffer(1); // marker bit
  1137. copyright_number_1 =   Get_Bits(20);
  1138. Flush_Buffer(1); // marker bit
  1139. copyright_number_2 =   Get_Bits(22);
  1140. Flush_Buffer(1); // marker bit
  1141. copyright_number_3 =   Get_Bits(22);
  1142. }
  1144. //
  1145. // getpic
  1146. //
  1148. static const unsigned char cc_table[12] = {
  1149. 0, 0, 0, 0, 1, 2, 1, 2, 1, 2, 1, 2
  1150. };
  1152. void CMPEG2Dec::Decode_Picture(int ref, unsigned char *dst, int pitch)
  1153. {
  1154. if (picture_structure==FRAME_PICTURE && Second_Field)
  1155. Second_Field = 0;
  1157. if (picture_coding_type!=B_TYPE)
  1158. {
  1159. pf_forward = pf_backward;
  1160. pf_backward = pf_current;
  1161. }
  1163. Update_Picture_Buffers();
  1165. picture_data();
  1167. if (ref && (picture_structure==FRAME_PICTURE || Second_Field))
  1168. {
  1169. if (picture_coding_type==B_TYPE)
  1170. assembleFrame(auxframe, pf_current, dst, pitch);
  1171. else
  1172. assembleFrame(forward_reference_frame, pf_forward, dst, pitch);
  1173. }
  1175. if (picture_structure!=FRAME_PICTURE)
  1176. Second_Field = !Second_Field;
  1177. }
  1179. /* reuse old picture buffers as soon as they are no longer needed */
  1180. void CMPEG2Dec::Update_Picture_Buffers()
  1181. {                           
  1182. int cc;              /* color component index */
  1183. unsigned char *tmp;  /* temporary swap pointer */
  1185. for (cc=0; cc<3; cc++)
  1186. {
  1187. /* B pictures  do not need to be save for future reference */
  1188. if (picture_coding_type==B_TYPE)
  1189. current_frame[cc] = auxframe[cc];
  1190. else
  1191. {
  1192. if (!Second_Field)
  1193. {
  1194. /* only update at the beginning of the coded frame */
  1195. tmp = forward_reference_frame[cc];
  1197. /* the previously decoded reference frame is stored coincident with the 
  1198.    location where the backward reference frame is stored (backwards 
  1199.    prediction is not needed in P pictures) */
  1200. forward_reference_frame[cc] = backward_reference_frame[cc];
  1202. /* update pointer for potential future B pictures */
  1203. backward_reference_frame[cc] = tmp;
  1204. }
  1206. /* can erase over old backward reference frame since it is not used
  1207.    in a P picture, and since any subsequent B pictures will use the 
  1208.    previously decoded I or P frame as the backward_reference_frame */
  1209. current_frame[cc] = backward_reference_frame[cc];
  1210. }
  1212.     if (picture_structure==BOTTOM_FIELD)
  1213. current_frame[cc] += (cc==0) ? Coded_Picture_Width : Chroma_Width;
  1214. }
  1215. }
  1217. /* decode all macroblocks of the current picture */
  1218. /* stages described in ISO/IEC 13818-2 section 7 */
  1219. void CMPEG2Dec::picture_data()
  1220. {
  1221. int MBAmax;
  1223. /* number of macroblocks per picture */
  1224. MBAmax = mb_width*mb_height;
  1226. if (picture_structure!=FRAME_PICTURE)
  1227. MBAmax>>=1;
  1229. for (;;)
  1230. if (slice(MBAmax)<0)
  1231. return;
  1232. }
  1234. /* decode all macroblocks of the current picture */
  1235. /* ISO/IEC 13818-2 section 6.3.16 */
  1236. /* return 0 : go to next slice */
  1237. /* return -1: go to next picture */
  1238. int CMPEG2Dec::slice(int MBAmax)
  1239. {
  1240. int MBA = 0, MBAinc =0, macroblock_type, motion_type, dct_type, ret;
  1241. int dc_dct_pred[3], PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2];
  1243. if ((ret=start_of_slice(&MBA, &MBAinc, dc_dct_pred, PMV))!=1)
  1244. return ret;
  1246. for (;;)
  1247. {
  1248. /* this is how we properly exit out of picture */
  1249. if (MBA>=MBAmax) return -1; // all macroblocks decoded
  1251. if (MBAinc==0)
  1252. {
  1253. if (!Show_Bits(23) || Fault_Flag) // next_start_code or fault
  1254. {
  1255. resync:
  1256. Fault_Flag = 0;
  1257. return 0; // trigger: go to next slice
  1258. }
  1259. else /* neither next_start_code nor Fault_Flag */
  1260. {
  1261. /* decode macroblock address increment */
  1262. MBAinc = Get_macroblock_address_increment();
  1263. if (Fault_Flag) goto resync;
  1264. }
  1265. }
  1267. if (MBAinc==1) /* not skipped */
  1268. {
  1269. if (!decode_macroblock(&macroblock_type, &motion_type, &dct_type, PMV,
  1270. dc_dct_pred, motion_vertical_field_select, dmvector))
  1271. goto resync;
  1272. }
  1273. else /* MBAinc!=1: skipped macroblock */
  1274. /* ISO/IEC 13818-2 section 7.6.6 */
  1275. skipped_macroblock(dc_dct_pred, PMV, &motion_type, motion_vertical_field_select, &macroblock_type);
  1277. /* ISO/IEC 13818-2 section 7.6 */
  1278. motion_compensation(MBA, macroblock_type, motion_type, PMV,
  1279. motion_vertical_field_select, dmvector, dct_type);
  1281. /* advance to next macroblock */
  1282. MBA++; MBAinc--;
  1284. if (MBA>=MBAmax) return -1; // all macroblocks decoded
  1285. }
  1286. }
  1288. /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
  1289. void CMPEG2Dec::macroblock_modes(int *pmacroblock_type, int *pmotion_type,
  1290.  int *pmotion_vector_count, int *pmv_format,
  1291.  int *pdmv, int *pmvscale, int *pdct_type)
  1292. {
  1293. int macroblock_type, motion_type = 0, motion_vector_count;
  1294. int mv_format, dmv, mvscale, dct_type;
  1296. /* get macroblock_type */
  1297. macroblock_type = Get_macroblock_type();
  1298. if (Fault_Flag) return;
  1300. /* get frame/field motion type */
  1301. if (macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD))
  1302. {
  1303. if (picture_structure==FRAME_PICTURE)
  1304. motion_type = frame_pred_frame_dct ? MC_FRAME : Get_Bits(2);
  1305. else
  1306. motion_type = Get_Bits(2);
  1307.     }
  1308. else if ((macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
  1309. motion_type = (picture_structure==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
  1311. /* derive motion_vector_count, mv_format and dmv, (table 6-17, 6-18) */
  1312. if (picture_structure==FRAME_PICTURE)
  1313. {
  1314. motion_vector_count = (motion_type==MC_FIELD) ? 2 : 1;
  1315. mv_format = (motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
  1316. }
  1317. else
  1318. {
  1319. motion_vector_count = (motion_type==MC_16X8) ? 2 : 1;
  1320. mv_format = MV_FIELD;
  1321. }
  1323. dmv = (motion_type==MC_DMV); /* dual prime */
  1325. /*
  1326.    field mv predictions in frame pictures have to be scaled
  1327.    ISO/IEC 13818-2 section 7.6.3.1 Decoding the motion vectors
  1328. */
  1329. mvscale = (mv_format==MV_FIELD && picture_structure==FRAME_PICTURE);
  1331. /* get dct_type (frame DCT / field DCT) */
  1332. dct_type = (picture_structure==FRAME_PICTURE) && (!frame_pred_frame_dct)
  1333. && (macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA)) ? Get_Bits(1) : 0;
  1335. /* return values */
  1336. *pmacroblock_type = macroblock_type;
  1337. *pmotion_type = motion_type;
  1338. *pmotion_vector_count = motion_vector_count;
  1339. *pmv_format = mv_format;
  1340. *pdmv = dmv;
  1341. *pmvscale = mvscale;
  1342. *pdct_type = dct_type;
  1343. }
  1345. /* move/add 8x8-Block from block[comp] to backward_reference_frame */
  1346. /* copy reconstructed 8x8 block from block[comp] to current_frame[]
  1347.    ISO/IEC 13818-2 section 7.6.8: Adding prediction and coefficient data
  1348.    This stage also embodies some of the operations implied by:
  1349.    - ISO/IEC 13818-2 section 7.6.7: Combining predictions
  1350.    - ISO/IEC 13818-2 section 6.1.3: Macroblock
  1351. */
  1352. void CMPEG2Dec::Add_Block(int count, int bx, int by, int dct_type, int addflag)
  1353. {
  1354. static const __int64 mmmask_128 = 0x0080008000800080;
  1356. int comp, cc, iincr, bxh, byh;
  1357. unsigned char *rfp;
  1358. short *Block_Ptr;
  1360. for (comp=0; comp<count; comp++)
  1361. {
  1362. Block_Ptr = block[comp];
  1363. cc = cc_table[comp];
  1365. bxh = bx; byh = by;
  1367. if (cc==0)
  1368. {
  1369. if (picture_structure==FRAME_PICTURE)
  1370. {
  1371. if (dct_type)
  1372. {
  1373. rfp = current_frame[0] + Coded_Picture_Width*(by+((comp&2)>>1)) + bx + ((comp&1)<<3);
  1374. iincr = Coded_Picture_Width<<1;
  1375. }
  1376. else
  1377. {
  1378. rfp = current_frame[0] + Coded_Picture_Width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  1379. iincr = Coded_Picture_Width;
  1380. }
  1381. }
  1382. else
  1383. {
  1384. rfp = current_frame[0] + (Coded_Picture_Width<<1)*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  1385. iincr = Coded_Picture_Width<<1;
  1386. }
  1387. }
  1388. else
  1389. {
  1390. if (chroma_format!=CHROMA444)
  1391. bxh >>= 1;
  1392. if (chroma_format==CHROMA420)
  1393. byh >>= 1;
  1395. if (picture_structure==FRAME_PICTURE)
  1396. {
  1397. if (dct_type && chroma_format!=CHROMA420)
  1398. {
  1399. /* field DCT coding */
  1400. rfp = current_frame[cc] + Chroma_Width*(byh+((comp&2)>>1)) + bxh + (comp&8);
  1401. iincr = Chroma_Width<<1;
  1402. }
  1403. else
  1404. {
  1405. /* frame DCT coding */
  1406. rfp = current_frame[cc] + Chroma_Width*(byh+((comp&2)<<2)) + bxh + (comp&8);
  1407. iincr = Chroma_Width;
  1408. }
  1409. }
  1410. else
  1411. {
  1412. /* field picture */
  1413. rfp = current_frame[cc] + (Chroma_Width<<1)*(byh+((comp&2)<<2)) + bxh + (comp&8);
  1414. iincr = Chroma_Width<<1;
  1415. }
  1416. }
  1418. if (addflag)
  1419. {
  1420. __asm
  1421. {
  1422. pxor mm0, mm0
  1423. mov eax, [rfp]
  1424. mov ebx, [Block_Ptr]
  1425. mov edi, 8
  1426. addon:
  1427. movq mm2, [ebx+8]
  1429. movq mm3, [eax]
  1430. movq mm4, mm3
  1432. movq mm1, [ebx]
  1433. punpckhbw mm3, mm0
  1435. paddsw mm3, mm2
  1436. packuswb mm3, mm0
  1438. punpcklbw mm4, mm0
  1439. psllq mm3, 32
  1441. paddsw mm4, mm1
  1442. packuswb mm4, mm0
  1444. por mm3, mm4
  1445. add ebx, 16
  1447. dec edi
  1448. movq [eax], mm3
  1450. add eax, [iincr]
  1451. cmp edi, 0x00
  1452. jg addon
  1453. }
  1454. }
  1455. else
  1456. {
  1457. __asm
  1458. {
  1459. mov eax, [rfp]
  1460. mov ebx, [Block_Ptr]
  1461. mov edi, 8
  1463. pxor mm0, mm0
  1464. movq mm7, [mmmask_128]
  1465. addoff:
  1466. movq mm3, [ebx+8]
  1467. movq mm4, [ebx]
  1469. paddsw mm3, mm7
  1470. paddsw mm4, mm7
  1472. packuswb mm3, mm0
  1473. packuswb mm4, mm0
  1475. psllq mm3, 32
  1476. por mm3, mm4
  1478. add ebx, 16
  1479. dec edi
  1481. movq [eax], mm3
  1483. add eax, [iincr]
  1484. cmp edi, 0x00
  1485. jg addoff
  1486. }
  1487. }
  1488. }
  1489. }
  1491. /* set scratch pad macroblock to zero */
  1492. void CMPEG2Dec::Clear_Block(int count)
  1493. {
  1494. int comp;
  1495. short *Block_Ptr;
  1497. for (comp=0; comp<count; comp++)
  1498. {
  1499. Block_Ptr = block[comp];
  1501. __asm
  1502. {
  1503. mov eax, [Block_Ptr];
  1504. pxor mm0, mm0;
  1505. movq [eax+0 ], mm0;
  1506. movq [eax+8 ], mm0;
  1507. movq [eax+16], mm0;
  1508. movq [eax+24], mm0;
  1509. movq [eax+32], mm0;
  1510. movq [eax+40], mm0;
  1511. movq [eax+48], mm0;
  1512. movq [eax+56], mm0;
  1513. movq [eax+64], mm0;
  1514. movq [eax+72], mm0;
  1515. movq [eax+80], mm0;
  1516. movq [eax+88], mm0;
  1517. movq [eax+96], mm0;
  1518. movq [eax+104],mm0;
  1519. movq [eax+112],mm0;
  1520. movq [eax+120],mm0;
  1521. }
  1522. }
  1523. }
  1525. /* ISO/IEC 13818-2 section 7.6 */
  1526. void CMPEG2Dec::motion_compensation(int MBA, int macroblock_type, int motion_type, 
  1527. int PMV[2][2][2], int motion_vertical_field_select[2][2],
  1528. int dmvector[2], int dct_type)
  1529. {
  1530. int bx, by;
  1531. int comp;
  1533. /* derive current macroblock position within picture */
  1534. /* ISO/IEC 13818-2 section 6.3.1.6 and 6.3.1.7 */
  1535. bx = 16*(MBA%mb_width);
  1536. by = 16*(MBA/mb_width);
  1538. /* motion compensation */
  1539. if (!(macroblock_type & MACROBLOCK_INTRA))
  1540. form_predictions(bx, by, macroblock_type, motion_type, PMV, 
  1541. motion_vertical_field_select, dmvector);
  1543. switch (IDCT_Flag)
  1544. {
  1545. case IDCT_MMX:
  1546. for (comp=0; comp<block_count; comp++)
  1547. MMX_IDCT(block[comp]);
  1548. break;
  1550. case IDCT_SSEMMX:
  1551. for (comp=0; comp<block_count; comp++)
  1552. SSEMMX_IDCT(block[comp]);
  1553. break;
  1555. case IDCT_FPU:
  1556. __asm emms;
  1557. for (comp=0; comp<block_count; comp++)
  1558. FPU_IDCT(block[comp]);
  1559. break;
  1561. case IDCT_REF:
  1562. __asm emms;
  1563. for (comp=0; comp<block_count; comp++)
  1564. REF_IDCT(block[comp]);
  1565. break;
  1566. }
  1568. Add_Block(block_count, bx, by, dct_type, (macroblock_type & MACROBLOCK_INTRA)==0);
  1569. }
  1571. /* ISO/IEC 13818-2 section 7.6.6 */
  1572. void CMPEG2Dec::skipped_macroblock(int dc_dct_pred[3], int PMV[2][2][2], int *motion_type, 
  1573.    int motion_vertical_field_select[2][2], int *macroblock_type)
  1574. {
  1575. Clear_Block(block_count);
  1577. /* reset intra_dc predictors */
  1578. /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  1579. dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  1581. /* reset motion vector predictors */
  1582. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  1583. if (picture_coding_type==P_TYPE)
  1584. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  1586. /* derive motion_type */
  1587. if (picture_structure==FRAME_PICTURE)
  1588. *motion_type = MC_FRAME;
  1589. else
  1590. {
  1591. *motion_type = MC_FIELD;
  1592. motion_vertical_field_select[0][0] = motion_vertical_field_select[0][1] = 
  1593. (picture_structure==BOTTOM_FIELD);
  1594. }
  1596. /* clear MACROBLOCK_INTRA */
  1597. *macroblock_type&= ~MACROBLOCK_INTRA;
  1598. }
  1600. /* return==-1 means go to next picture */
  1601. /* the expression "start of slice" is used throughout the normative
  1602.    body of the MPEG specification */
  1603. int CMPEG2Dec::start_of_slice(int *MBA, int *MBAinc,
  1604.   int dc_dct_pred[3], int PMV[2][2][2])
  1605. {
  1606. unsigned int code;
  1607. int slice_vert_pos_ext;
  1609. next_start_code();
  1610. code = Get_Bits(32);
  1612. if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
  1613. {
  1614. // only slice headers are allowed in picture_data
  1615. Fault_Flag = 10;
  1616. return -1;
  1617. }
  1619. /* decode slice header (may change quantizer_scale) */
  1620. slice_vert_pos_ext = slice_header();
  1622. /* decode macroblock address increment */
  1623. *MBAinc = Get_macroblock_address_increment();
  1624. if (Fault_Flag) return -1;
  1626. /* set current location */
  1627. /* NOTE: the arithmetic used to derive macroblock_address below is
  1628.    equivalent to ISO/IEC 13818-2 section 6.3.17: Macroblock */
  1629. *MBA = ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + *MBAinc - 1;
  1630. *MBAinc = 1; // first macroblock in slice: not skipped
  1632. /* reset all DC coefficient and motion vector predictors */
  1633. /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  1634. dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  1635.   
  1636. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  1637. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  1638. PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  1640. /* successfull: trigger decode macroblocks in slice */
  1641. return 1;
  1642. }
  1644. /* ISO/IEC 13818-2 sections 7.2 through 7.5 */
  1645. int CMPEG2Dec::decode_macroblock(int *macroblock_type, int *motion_type, int *dct_type,
  1646.  int PMV[2][2][2], int dc_dct_pred[3], 
  1647.  int motion_vertical_field_select[2][2], int dmvector[2])
  1648. {
  1649. int quantizer_scale_code, comp, motion_vector_count, mv_format; 
  1650. int dmv, mvscale, coded_block_pattern;
  1652. /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
  1653. macroblock_modes(macroblock_type, motion_type, &motion_vector_count, &mv_format,
  1654.  &dmv, &mvscale, dct_type);
  1655. if (Fault_Flag) return 0; // trigger: go to next slice
  1657. if (*macroblock_type & MACROBLOCK_QUANT)
  1658. {
  1659. quantizer_scale_code = Get_Bits(5);
  1661. /* ISO/IEC 13818-2 section 7.4.2.2: Quantizer scale factor */
  1662. quantizer_scale = q_scale_type ?
  1663. Non_Linear_quantizer_scale[quantizer_scale_code] : (quantizer_scale_code << 1);
  1664. }
  1666. /* ISO/IEC 13818-2 section 6.3.17.2: Motion vectors */
  1667. /* decode forward motion vectors */
  1668. if ((*macroblock_type & MACROBLOCK_MOTION_FORWARD) 
  1669. || ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors))
  1670. motion_vectors(PMV, dmvector, motion_vertical_field_select, 0,
  1671. motion_vector_count, mv_format, f_code[0][0]-1, f_code[0][1]-1, dmv, mvscale);
  1672. if (Fault_Flag) return 0; // trigger: go to next slice
  1674. /* decode backward motion vectors */
  1675. if (*macroblock_type & MACROBLOCK_MOTION_BACKWARD)
  1676. motion_vectors(PMV, dmvector, motion_vertical_field_select, 1,
  1677. motion_vector_count,mv_format, f_code[1][0]-1, f_code[1][1]-1, 0, mvscale);
  1678. if (Fault_Flag) return 0;  // trigger: go to next slice
  1680. if ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
  1681. Flush_Buffer(1); // marker bit
  1683. /* macroblock_pattern */
  1684. /* ISO/IEC 13818-2 section 6.3.17.4: Coded block pattern */
  1685. if (*macroblock_type & MACROBLOCK_PATTERN)
  1686. {
  1687. coded_block_pattern = Get_coded_block_pattern();
  1689. if (chroma_format==CHROMA422)
  1690. coded_block_pattern = (coded_block_pattern<<2) | Get_Bits(2);
  1691. else if (chroma_format==CHROMA444)
  1692. coded_block_pattern = (coded_block_pattern<<6) | Get_Bits(6);
  1693. }
  1694. else
  1695.     coded_block_pattern = (*macroblock_type & MACROBLOCK_INTRA) ? (1<<block_count)-1 : 0;
  1697. if (Fault_Flag) return 0; // trigger: go to next slice
  1699. Clear_Block(block_count);
  1701. /* decode blocks */
  1702. for (comp=0; comp<block_count; comp++)
  1703. {
  1704. if (coded_block_pattern & (1<<(block_count-1-comp)))
  1705. {
  1706. if (*macroblock_type & MACROBLOCK_INTRA)
  1707. Decode_MPEG2_Intra_Block(comp, dc_dct_pred);
  1708. else
  1709. Decode_MPEG2_Non_Intra_Block(comp);
  1710. if (Fault_Flag) return 0; // trigger: go to next slice
  1711. }
  1712. }
  1714. /* reset intra_dc predictors */
  1715. /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
  1716. if (!(*macroblock_type & MACROBLOCK_INTRA))
  1717. dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  1719. /* reset motion vector predictors */
  1720. if ((*macroblock_type & MACROBLOCK_INTRA) && !concealment_motion_vectors)
  1721. {
  1722. /* intra mb without concealment motion vectors */
  1723. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  1724. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  1725. PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  1726. }
  1728. /* special "No_MC" macroblock_type case */
  1729. /* ISO/IEC 13818-2 section 7.6.3.5: Prediction in P pictures */
  1730. if ((picture_coding_type==P_TYPE) 
  1731. && !(*macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_INTRA)))
  1732. {
  1733. /* non-intra mb without forward mv in a P picture */
  1734. /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
  1735. PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  1737. /* derive motion_type */
  1738. /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes, frame_motion_type */
  1739. if (picture_structure==FRAME_PICTURE)
  1740. *motion_type = MC_FRAME;
  1741. else
  1742. {
  1743. *motion_type = MC_FIELD;
  1744. motion_vertical_field_select[0][0] = (picture_structure==BOTTOM_FIELD);
  1745. }
  1746. }
  1747. /* successfully decoded macroblock */
  1748. return 1 ;
  1749. }
  1751. /* decode one intra coded MPEG-2 block */
  1752. void CMPEG2Dec::Decode_MPEG2_Intra_Block(int comp, int dc_dct_pred[])
  1753. {
  1754. int val, i, j, sign, *qmat;
  1755. unsigned int code;
  1756. DCTtab *tab;
  1757. short *bp;
  1759. bp = block[comp];
  1760. qmat = (comp<4 || chroma_format==CHROMA420) 
  1761. ? intra_quantizer_matrix : chroma_intra_quantizer_matrix;
  1763. /* ISO/IEC 13818-2 section 7.2.1: decode DC coefficients */
  1764. switch (cc_table[comp])
  1765. {
  1766. case 0:
  1767. val = (dc_dct_pred[0]+= Get_Luma_DC_dct_diff());
  1768. break;
  1770. case 1:
  1771. val = (dc_dct_pred[1]+= Get_Chroma_DC_dct_diff());
  1772. break;
  1774. case 2:
  1775. val = (dc_dct_pred[2]+= Get_Chroma_DC_dct_diff());
  1776. break;
  1777. }
  1779. bp[0] = val << (3-intra_dc_precision);
  1781. /* decode AC coefficients */
  1782. for (i=1; ; i++)
  1783. {
  1784. code = Show_Bits(16);
  1786. if (code>=16384 && !intra_vlc_format)
  1787. tab = &DCTtabnext[(code>>12)-4];
  1788. else if (code>=1024)
  1789. {
  1790. if (intra_vlc_format)
  1791. tab = &DCTtab0a[(code>>8)-4];
  1792. else
  1793. tab = &DCTtab0[(code>>8)-4];
  1794. }
  1795. else if (code>=512)
  1796. {
  1797. if (intra_vlc_format)
  1798. tab = &DCTtab1a[(code>>6)-8];
  1799. else
  1800. tab = &DCTtab1[(code>>6)-8];
  1801. }
  1802. else if (code>=256)
  1803. tab = &DCTtab2[(code>>4)-16];
  1804. else if (code>=128)
  1805. tab = &DCTtab3[(code>>3)-16];
  1806. else if (code>=64)
  1807. tab = &DCTtab4[(code>>2)-16];
  1808. else if (code>=32)
  1809. tab = &DCTtab5[(code>>1)-16];
  1810. else if (code>=16)
  1811. tab = &DCTtab6[code-16];
  1812. else
  1813. {
  1814. Fault_Flag = 1;
  1815. return;
  1816. }
  1818. Flush_Buffer(tab->len);
  1820. if (tab->run<64)
  1821. {
  1822. i+= tab->run;
  1823. val = tab->level;
  1824. sign = Get_Bits(1);
  1825. }
  1826. else if (tab->run==64) /* end_of_block */
  1827. return;
  1828. else /* escape */
  1829. {
  1830. i+= Get_Bits(6);
  1831. val = Get_Bits(12);
  1833. if (sign = (val>=2048))
  1834. val = 4096 - val;
  1835. }
  1837. j = scan[alternate_scan][i];
  1839. val = (val * quantizer_scale * qmat[j]) >> 4;
  1840. bp[j] = sign ? -val : val;
  1841. }
  1842. }
  1844. /* decode one non-intra coded MPEG-2 block */
  1845. void CMPEG2Dec::Decode_MPEG2_Non_Intra_Block(int comp)
  1846. {
  1847. int val, i, j, sign, *qmat;
  1848. unsigned int code;
  1849. DCTtab *tab;
  1850. short *bp;
  1852. bp = block[comp];
  1853. qmat = (comp<4 || chroma_format==CHROMA420) 
  1854. ? non_intra_quantizer_matrix : chroma_non_intra_quantizer_matrix;
  1856. /* decode AC coefficients */
  1857. for (i=0; ; i++)
  1858. {
  1859. code = Show_Bits(16);
  1861. if (code>=16384)
  1862. {
  1863. if (i==0)
  1864. tab = &DCTtabfirst[(code>>12)-4];
  1865. else
  1866. tab = &DCTtabnext[(code>>12)-4];
  1867. }
  1868. else if (code>=1024)
  1869. tab = &DCTtab0[(code>>8)-4];
  1870. else if (code>=512)
  1871. tab = &DCTtab1[(code>>6)-8];
  1872. else if (code>=256)
  1873. tab = &DCTtab2[(code>>4)-16];
  1874. else if (code>=128)
  1875. tab = &DCTtab3[(code>>3)-16];
  1876. else if (code>=64)
  1877. tab = &DCTtab4[(code>>2)-16];
  1878. else if (code>=32)
  1879. tab = &DCTtab5[(code>>1)-16];
  1880. else if (code>=16)
  1881. tab = &DCTtab6[code-16];
  1882. else
  1883. {
  1884. Fault_Flag = 1;
  1885. return;
  1886. }
  1888. Flush_Buffer(tab->len);
  1890. if (tab->run<64)
  1891. {
  1892. i+= tab->run;
  1893. val = tab->level;
  1894. sign = Get_Bits(1);
  1895. }
  1896. else if (tab->run==64) /* end_of_block */
  1897. return;
  1898. else /* escape */
  1899. {
  1900. i+= Get_Bits(6);
  1901. val = Get_Bits(12);
  1903. if (sign = (val>=2048))
  1904. val = 4096 - val;
  1905. }
  1907. j = scan[alternate_scan][i];
  1909. val = (((val<<1)+1) * quantizer_scale * qmat[j]) >> 5;
  1910. bp[j] = sign ? -val : val;
  1911. }
  1912. }
  1914. int CMPEG2Dec::Get_macroblock_type()
  1915. {
  1916. int macroblock_type;
  1918. switch (picture_coding_type)
  1919. {
  1920. case I_TYPE:
  1921. macroblock_type = Get_I_macroblock_type();
  1922. break;
  1924. case P_TYPE:
  1925. macroblock_type = Get_P_macroblock_type();
  1926. break;
  1928. case B_TYPE:
  1929. macroblock_type = Get_B_macroblock_type();
  1930. break;
  1931. }
  1933. return macroblock_type;
  1934. }
  1936. int CMPEG2Dec::Get_I_macroblock_type()
  1937. {
  1938. if (Get_Bits(1))
  1939. return 1;
  1941. if (!Get_Bits(1))
  1942. Fault_Flag = 2;
  1944. return 17;
  1945. }
  1947. int CMPEG2Dec::Get_P_macroblock_type()
  1948. {
  1949. int code;
  1951. if ((code = Show_Bits(6))>=8)
  1952. {
  1953. code >>= 3;
  1954. Flush_Buffer(PMBtab0[code].len);
  1956. return PMBtab0[code].val;
  1957. }
  1959. if (code==0)
  1960. {
  1961. Fault_Flag = 2;
  1962. return 0;
  1963. }
  1965. Flush_Buffer(PMBtab1[code].len);
  1967. return PMBtab1[code].val;
  1968. }
  1970. int CMPEG2Dec::Get_B_macroblock_type()
  1971. {
  1972. int code;
  1974. if ((code = Show_Bits(6))>=8)
  1975. {
  1976. code >>= 2;
  1977. Flush_Buffer(BMBtab0[code].len);
  1979. return BMBtab0[code].val;
  1980. }
  1982. if (code==0)
  1983. {
  1984. Fault_Flag = 2;
  1985. return 0;
  1986. }
  1988. Flush_Buffer(BMBtab1[code].len);
  1990. return BMBtab1[code].val;
  1991. }
  1993. int CMPEG2Dec::Get_coded_block_pattern()
  1994. {
  1995. int code;
  1997. if ((code = Show_Bits(9))>=128)
  1998. {
  1999. code >>= 4;
  2000. Flush_Buffer(CBPtab0[code].len);
  2002. return CBPtab0[code].val;
  2003. }
  2005. if (code>=8)
  2006. {
  2007. code >>= 1;
  2008. Flush_Buffer(CBPtab1[code].len);
  2010. return CBPtab1[code].val;
  2011. }
  2013. if (code<1)
  2014. {
  2015. Fault_Flag = 3;
  2016. return 0;
  2017. }
  2019. Flush_Buffer(CBPtab2[code].len);
  2021. return CBPtab2[code].val;
  2022. }
  2024. int CMPEG2Dec::Get_macroblock_address_increment()
  2025. {
  2026. int code, val;
  2028. val = 0;
  2030. while ((code = Show_Bits(11))<24)
  2031. {
  2032. if (code!=15) /* if not macroblock_stuffing */
  2033. {
  2034. if (code==8) /* if macroblock_escape */
  2035. val+= 33;
  2036. else
  2037. {
  2038. Fault_Flag = 4;
  2039. return 1;
  2040. }
  2041. }
  2042. Flush_Buffer(11);
  2043. }
  2045. /* macroblock_address_increment == 1 */
  2046. /* ('1' is in the MSB position of the lookahead) */
  2047. if (code>=1024)
  2048. {
  2049. Flush_Buffer(1);
  2050. return val + 1;
  2051. }
  2053. /* codes 00010 ... 011xx */
  2054. if (code>=128)
  2055. {
  2056. /* remove leading zeros */
  2057. code >>= 6;
  2058. Flush_Buffer(MBAtab1[code].len);
  2059.     
  2060. return val + MBAtab1[code].val;
  2061. }
  2062.   
  2063. /* codes 00000011000 ... 0000111xxxx */
  2064. code-= 24; /* remove common base */
  2065. Flush_Buffer(MBAtab2[code].len);
  2067. return val + MBAtab2[code].val;
  2068. }
  2070. /*
  2071.    parse VLC and perform dct_diff arithmetic.
  2072.    MPEG-2:  ISO/IEC 13818-2 section 7.2.1 
  2074.    Note: the arithmetic here is presented more elegantly than
  2075.    the spec, yet the results, dct_diff, are the same.
  2076. */
  2077. int CMPEG2Dec::Get_Luma_DC_dct_diff()
  2078. {
  2079. int code, size, dct_diff;
  2081. /* decode length */
  2082. code = Show_Bits(5);
  2084. if (code<31)
  2085. {
  2086. size = DClumtab0[code].val;
  2087. Flush_Buffer(DClumtab0[code].len);
  2088. }
  2089. else
  2090. {
  2091. code = Show_Bits(9) - 0x1f0;
  2092. size = DClumtab1[code].val;
  2093. Flush_Buffer(DClumtab1[code].len);
  2094. }
  2096. if (size==0)
  2097. dct_diff = 0;
  2098. else
  2099. {
  2100. dct_diff = Get_Bits(size);
  2102. if ((dct_diff & (1<<(size-1)))==0)
  2103. dct_diff-= (1<<size) - 1;
  2104. }
  2106. return dct_diff;
  2107. }
  2109. int CMPEG2Dec::Get_Chroma_DC_dct_diff()
  2110. {
  2111. int code, size, dct_diff;
  2113. /* decode length */
  2114. code = Show_Bits(5);
  2116. if (code<31)
  2117. {
  2118. size = DCchromtab0[code].val;
  2119. Flush_Buffer(DCchromtab0[code].len);
  2120. }
  2121. else
  2122. {
  2123. code = Show_Bits(10) - 0x3e0;
  2124. size = DCchromtab1[code].val;
  2125. Flush_Buffer(DCchromtab1[code].len);
  2126. }
  2128. if (size==0)
  2129. dct_diff = 0;
  2130. else
  2131. {
  2132. dct_diff = Get_Bits(size);
  2134. if ((dct_diff & (1<<(size-1)))==0)
  2135. dct_diff-= (1<<size) - 1;
  2136. }
  2138. return dct_diff;
  2139. }
  2141. /*
  2142. static int currentfield;
  2143. static unsigned char **predframe;
  2144. static int DMV[2][2];
  2145. static int stw;
  2146. */
  2148. void CMPEG2Dec::form_predictions(int bx, int by, int macroblock_type, int motion_type,
  2149.   int PMV[2][2][2], int motion_vertical_field_select[2][2],
  2150.   int dmvector[2])
  2151. {
  2152. int currentfield;
  2153. unsigned char **predframe;
  2154. int DMV[2][2];
  2155. int stw;
  2157. stw = 0;
  2159. if ((macroblock_type & MACROBLOCK_MOTION_FORWARD) || (picture_coding_type==P_TYPE))
  2160. {
  2161. if (picture_structure==FRAME_PICTURE)
  2162. {
  2163. if ((motion_type==MC_FRAME) || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
  2164. {
  2165. /* frame-based prediction (broken into top and bottom halves
  2166.    for spatial scalability prediction purposes) */
  2167. form_prediction(forward_reference_frame, 0, current_frame, 0, Coded_Picture_Width, 
  2168. Coded_Picture_Width<<1, 16, 8, bx, by, PMV[0][0][0], PMV[0][0][1], stw);
  2170. form_prediction(forward_reference_frame, 1, current_frame, 1, Coded_Picture_Width, 
  2171. Coded_Picture_Width<<1, 16, 8, bx, by, PMV[0][0][0], PMV[0][0][1], stw);
  2172. }
  2173. else if (motion_type==MC_FIELD) /* field-based prediction */
  2174. {
  2175. /* top field prediction */
  2176. form_prediction(forward_reference_frame, motion_vertical_field_select[0][0], 
  2177. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  2178. bx, by>>1, PMV[0][0][0], PMV[0][0][1]>>1, stw);
  2180. /* bottom field prediction */
  2181. form_prediction(forward_reference_frame, motion_vertical_field_select[1][0], 
  2182. current_frame, 1, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  2183. bx, by>>1, PMV[1][0][0], PMV[1][0][1]>>1, stw);
  2184. }
  2185. else if (motion_type==MC_DMV) /* dual prime prediction */
  2186. {
  2187. /* calculate derived motion vectors */
  2188. Dual_Prime_Arithmetic(DMV, dmvector, PMV[0][0][0], PMV[0][0][1]>>1);
  2190. /* predict top field from top field */
  2191. form_prediction(forward_reference_frame, 0, current_frame, 0, 
  2192. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  2193. PMV[0][0][0], PMV[0][0][1]>>1, 0);
  2195. /* predict and add to top field from bottom field */
  2196. form_prediction(forward_reference_frame, 1, current_frame, 0,
  2197. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  2198. DMV[0][0], DMV[0][1], 1);
  2200. /* predict bottom field from bottom field */
  2201. form_prediction(forward_reference_frame, 1, current_frame, 1,
  2202. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  2203. PMV[0][0][0], PMV[0][0][1]>>1, 0);
  2205. /* predict and add to bottom field from top field */
  2206. form_prediction(forward_reference_frame, 0, current_frame, 1,
  2207. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
  2208. DMV[1][0], DMV[1][1], 1);
  2209. }
  2210. else
  2211. Fault_Flag = 5;
  2212. }
  2213. else
  2214. {
  2215. /* field picture */
  2216. currentfield = (picture_structure==BOTTOM_FIELD);
  2218. /* determine which frame to use for prediction */
  2219. if (picture_coding_type==P_TYPE && Second_Field && currentfield!=motion_vertical_field_select[0][0])
  2220. predframe = backward_reference_frame;
  2221. else
  2222. predframe = forward_reference_frame;
  2224. if ((motion_type==MC_FIELD) || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
  2225. {
  2226. form_prediction(predframe, motion_vertical_field_select[0][0], current_frame, 0, 
  2227. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
  2228. PMV[0][0][0], PMV[0][0][1], stw);
  2229. }
  2230. else if (motion_type==MC_16X8)
  2231. {
  2232. form_prediction(predframe, motion_vertical_field_select[0][0], current_frame, 0, 
  2233. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by,
  2234. PMV[0][0][0], PMV[0][0][1], stw);
  2236. if (picture_coding_type==P_TYPE && Second_Field && currentfield!=motion_vertical_field_select[1][0])
  2237. predframe = backward_reference_frame;
  2238. else
  2239. predframe = forward_reference_frame;
  2241. form_prediction(predframe, motion_vertical_field_select[1][0], current_frame, 
  2242. 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by+8,
  2243. PMV[1][0][0], PMV[1][0][1], stw);
  2244. }
  2245. else if (motion_type==MC_DMV)
  2246. {
  2247. if (Second_Field)
  2248. predframe = backward_reference_frame;
  2249. else
  2250. predframe = forward_reference_frame;
  2252. /* calculate derived motion vectors */
  2253. Dual_Prime_Arithmetic(DMV, dmvector, PMV[0][0][0], PMV[0][0][1]);
  2255. /* predict from field of same parity */
  2256. form_prediction(forward_reference_frame, currentfield, current_frame, 0, 
  2257. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
  2258. PMV[0][0][0], PMV[0][0][1], 0);
  2260. /* predict from field of opposite parity */
  2261. form_prediction(predframe, !currentfield, current_frame, 0,
  2262. Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
  2263. DMV[0][0], DMV[0][1], 1);
  2264. }
  2265. else
  2266. Fault_Flag = 5;
  2267. }
  2269. stw = 1;
  2270. }
  2272. if (macroblock_type & MACROBLOCK_MOTION_BACKWARD)
  2273. {
  2274. if (picture_structure==FRAME_PICTURE)
  2275. {
  2276. if (motion_type==MC_FRAME)
  2277. {
  2278. /* frame-based prediction */
  2279. form_prediction(backward_reference_frame, 0, current_frame, 0,
  2280. Coded_Picture_Width, Coded_Picture_Width<<1, 16, 8, bx, by,
  2281. PMV[0][1][0], PMV[0][1][1], stw);
  2283. form_prediction(backward_reference_frame, 1, current_frame, 1,
  2284. Coded_Picture_Width, Coded_Picture_Width<<1, 16, 8, bx, by,
  2285. PMV[0][1][0], PMV[0][1][1], stw);
  2286. }
  2287. else /* field-based prediction */
  2288. {
  2289. /* top field prediction */
  2290. form_prediction(backward_reference_frame, motion_vertical_field_select[0][1], 
  2291. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  2292. bx, by>>1, PMV[0][1][0], PMV[0][1][1]>>1, stw);
  2294. /* bottom field prediction */
  2295. form_prediction(backward_reference_frame, motion_vertical_field_select[1][1], 
  2296. current_frame, 1, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  2297. bx, by>>1, PMV[1][1][0], PMV[1][1][1]>>1, stw);
  2298. }
  2299. }
  2300. else
  2301. {
  2302. /* field picture */
  2303. if (motion_type==MC_FIELD)
  2304. {
  2305. /* field-based prediction */
  2306. form_prediction(backward_reference_frame, motion_vertical_field_select[0][1], 
  2307. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16,
  2308. bx, by, PMV[0][1][0], PMV[0][1][1], stw);
  2309. }
  2310. else if (motion_type==MC_16X8)
  2311. {
  2312. form_prediction(backward_reference_frame, motion_vertical_field_select[0][1],
  2313. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  2314. bx, by, PMV[0][1][0], PMV[0][1][1], stw);
  2316. form_prediction(backward_reference_frame, motion_vertical_field_select[1][1],
  2317. current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
  2318. bx, by+8, PMV[1][1][0], PMV[1][1][1], stw);
  2319. }
  2320. else
  2321. Fault_Flag = 5;
  2322. }
  2323. }
  2324. }
  2326. void CMPEG2Dec::form_prediction(unsigned char *src[], int sfield, unsigned char *dst[],
  2327. int dfield, int lx, int lx2, int w, int h, int x, int y,
  2328. int dx, int dy, int average_flag)
  2329. {
  2330. form_component_prediction(src[0]+(sfield?lx2>>1:0), dst[0]+(dfield?lx2>>1:0),
  2331. lx, lx2, w, h, x, y, dx, dy, average_flag);
  2333. if (chroma_format!=CHROMA444)
  2334. {
  2335. lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;
  2336. }
  2338. if (chroma_format==CHROMA420)
  2339. {
  2340. h>>=1; y>>=1; dy/=2;
  2341. }
  2343. /* Cb */
  2344. form_component_prediction(src[1]+(sfield?lx2>>1:0), dst[1]+(dfield?lx2>>1:0),
  2345. lx, lx2, w, h, x, y, dx, dy, average_flag);
  2347. /* Cr */
  2348. form_component_prediction(src[2]+(sfield?lx2>>1:0), dst[2]+(dfield?lx2>>1:0),
  2349. lx, lx2, w, h, x, y, dx, dy, average_flag);
  2350. }
  2352. /* ISO/IEC 13818-2 section 7.6.4: Forming predictions */
  2353. void CMPEG2Dec::form_component_prediction(unsigned char *src, unsigned char *dst,
  2354.   int lx, int lx2, int w, int h, int x, int y,
  2355.   int dx, int dy, int average_flag)
  2356. {
  2357. static const __int64 mmmask_0001 = 0x0001000100010001;
  2358. static const __int64 mmmask_0002 = 0x0002000200020002;
  2359. static const __int64 mmmask_0003 = 0x0003000300030003;
  2360. static const __int64 mmmask_0006 = 0x0006000600060006;
  2362. unsigned char *s = src + lx * (y + (dy>>1)) + x + (dx>>1);
  2363. unsigned char *d = dst + lx * y + x;
  2364. int flag = (average_flag<<2) + ((dx & 1)<<1) + (dy & 1);
  2366. switch (flag)
  2367. {
  2368. case 0:
  2369. // d[i] = s[i];
  2370. __asm
  2371. {
  2372. mov eax, [s]
  2373. mov ebx, [d]
  2374. mov esi, 0x00
  2375. mov edi, [h]
  2376. mc0:
  2377. movq mm1, [eax+esi]
  2378. add esi, 0x08
  2379. cmp esi, [w]
  2380. movq [ebx+esi-8], mm1
  2381. jl mc0
  2383. add eax, [lx2]
  2384. add ebx, [lx2]
  2385. dec edi
  2386. mov esi, 0x00
  2387. cmp edi, 0x00
  2388. jg mc0
  2389. }
  2390. break;
  2392. case 1:
  2393. // d[i] = (s[i]+s[i+lx]+1)>>1;
  2394. __asm
  2395. {
  2396. pxor mm0, mm0
  2397. movq mm7, [mmmask_0001]
  2398. mov eax, [s]
  2399. mov ebx, [d]
  2400. mov ecx, eax
  2401. add ecx, [lx]
  2402. mov esi, 0x00
  2403. mov edi, [h]
  2404. mc1:
  2405. movq mm1, [eax+esi]
  2406. movq mm2, [ecx+esi]
  2408. movq mm3, mm1
  2409. movq mm4, mm2
  2411. punpcklbw mm1, mm0
  2412. punpckhbw mm3, mm0
  2413. punpcklbw mm2, mm0
  2414. punpckhbw mm4, mm0
  2416. paddsw mm1, mm2
  2417. paddsw mm3, mm4
  2419. paddsw mm1, mm7
  2420. paddsw mm3, mm7
  2422. psrlw mm1, 1
  2423. psrlw mm3, 1
  2425. packuswb mm1, mm0
  2426. packuswb mm3, mm0
  2428. psllq mm3, 32
  2429. por mm1, mm3
  2431. add esi, 0x08
  2432. cmp esi, [w]
  2433. movq [ebx+esi-8], mm1
  2434. jl mc1
  2436. add eax, [lx2]
  2437. add ebx, [lx2]
  2438. add ecx, [lx2]
  2439. dec edi
  2440. mov esi, 0x00
  2441. cmp edi, 0x00
  2442. jg mc1
  2443. }
  2444. break;
  2446. case 2:
  2447. // d[i] = (s[i]+s[i+1]+1)>>1;
  2448. __asm
  2449. {
  2450. pxor mm0, mm0
  2451. movq mm7, [mmmask_0001]
  2452. mov eax, [s]
  2453. mov ebx, [d]
  2454. mov esi, 0x00
  2455. mov edi, [h]
  2456. mc2:
  2457. movq mm1, [eax+esi]
  2458. movq mm2, [eax+esi+1]
  2460. movq mm3, mm1
  2461. movq mm4, mm2
  2463. punpcklbw mm1, mm0
  2464. punpckhbw mm3, mm0
  2466. punpcklbw mm2, mm0
  2467. punpckhbw mm4, mm0
  2469. paddsw mm1, mm2
  2470. paddsw mm3, mm4
  2472. paddsw mm1, mm7
  2473. paddsw mm3, mm7
  2475. psrlw mm1, 1
  2476. psrlw mm3, 1
  2478. packuswb mm1, mm0
  2479. packuswb mm3, mm0
  2481. psllq mm3, 32
  2482. por mm1, mm3
  2484. add esi, 0x08
  2485. cmp esi, [w]
  2486. movq [ebx+esi-8], mm1
  2487. jl mc2
  2489. add eax, [lx2]
  2490. add ebx, [lx2]
  2491. dec edi
  2492. mov esi, 0x00
  2493. cmp edi, 0x00
  2494. jg mc2
  2495. }
  2496. break;
  2498. case 3:
  2499. // d[i] = (s[i]+s[i+1]+s[i+lx]+s[i+lx+1]+2)>>2;
  2500. __asm
  2501. {
  2502. pxor mm0, mm0
  2503. movq mm7, [mmmask_0002]
  2504. mov eax, [s]
  2505. mov ebx, [d]
  2506. mov ecx, eax
  2507. add ecx, [lx]
  2508. mov esi, 0x00
  2509. mov edi, [h]
  2510. mc3:
  2511. movq mm1, [eax+esi]
  2512. movq mm2, [eax+esi+1]
  2513. movq mm3, mm1
  2514. movq mm4, mm2
  2516. punpcklbw mm1, mm0
  2517. punpckhbw mm3, mm0
  2519. punpcklbw mm2, mm0
  2520. punpckhbw mm4, mm0
  2522. paddsw mm1, mm2
  2523. paddsw mm3, mm4
  2525. movq mm5, [ecx+esi]
  2526. paddsw mm1, mm7
  2528. movq mm6, [ecx+esi+1]
  2529. paddsw mm3, mm7
  2531. movq mm2, mm5
  2532. movq mm4, mm6
  2534. punpcklbw mm2, mm0
  2535. punpckhbw mm5, mm0
  2537. punpcklbw mm4, mm0
  2538. punpckhbw mm6, mm0
  2540. paddsw mm2, mm4
  2541. paddsw mm5, mm6
  2543. paddsw mm1, mm2
  2544. paddsw mm3, mm5
  2546. psrlw mm1, 2
  2547. psrlw mm3, 2
  2549. packuswb mm1, mm0
  2550. packuswb mm3, mm0
  2552. psllq mm3, 32
  2553. por mm1, mm3
  2555. add esi, 0x08
  2556. cmp esi, [w]
  2557. movq [ebx+esi-8], mm1
  2558. jl mc3
  2560. add eax, [lx2]
  2561. add ebx, [lx2]
  2562. add ecx, [lx2]
  2563. dec edi
  2564. mov esi, 0x00
  2565. cmp edi, 0x00
  2566. jg mc3
  2567. }
  2568. break;
  2570. case 4:
  2571. // d[i] = (s[i]+d[i]+1)>>1;
  2572. __asm
  2573. {
  2574. pxor mm0, mm0
  2575. movq mm7, [mmmask_0001]
  2576. mov eax, [s]
  2577. mov ebx, [d]
  2578. mov esi, 0x00
  2579. mov edi, [h]
  2580. mc4:
  2581. movq mm1, [eax+esi]
  2582. movq mm2, [ebx+esi]
  2583. movq mm3, mm1
  2584. movq mm4, mm2
  2586. punpcklbw mm1, mm0
  2587. punpckhbw mm3, mm0
  2589. punpcklbw mm2, mm0
  2590. punpckhbw mm4, mm0
  2592. paddsw mm1, mm2
  2593. paddsw mm3, mm4
  2595. paddsw mm1, mm7
  2596. paddsw mm3, mm7
  2598. psrlw mm1, 1
  2599. psrlw mm3, 1
  2601. packuswb mm1, mm0
  2602. packuswb mm3, mm0
  2604. psllq mm3, 32
  2605. por mm1, mm3
  2607. add esi, 0x08
  2608. cmp esi, [w]
  2609. movq [ebx+esi-8], mm1
  2610. jl mc4
  2612. add eax, [lx2]
  2613. add ebx, [lx2]
  2614. dec edi
  2615. mov esi, 0x00
  2616. cmp edi, 0x00
  2617. jg mc4
  2618. }
  2619. break;
  2621. case 5:
  2622. // d[i] = ((d[i]<<1) + s[i]+s[i+lx] + 3)>>2;
  2623. __asm
  2624. {
  2625. pxor mm0, mm0
  2626. movq mm7, [mmmask_0003]
  2627. mov eax, [s]
  2628. mov ebx, [d]
  2629. mov ecx, eax
  2630. add ecx, [lx]
  2631. mov esi, 0x00
  2632. mov edi, [h]
  2633. mc5:
  2634. movq mm1, [eax+esi]
  2635. movq mm2, [ecx+esi]
  2636. movq mm3, mm1
  2637. movq mm4, mm2
  2639. punpcklbw mm1, mm0
  2640. punpckhbw mm3, mm0
  2642. punpcklbw mm2, mm0
  2643. punpckhbw mm4, mm0
  2645. paddsw mm1, mm2
  2646. paddsw mm3, mm4
  2648. movq mm5, [ebx+esi]
  2650. paddsw mm1, mm7
  2651. paddsw mm3, mm7
  2653. movq mm6, mm5
  2654. punpcklbw mm5, mm0
  2655. punpckhbw mm6, mm0
  2657. psllw mm5, 1
  2658. psllw mm6, 1
  2660. paddsw mm1, mm5
  2661. paddsw mm3, mm6
  2663. psrlw mm1, 2
  2664. psrlw mm3, 2
  2666. packuswb mm1, mm0
  2667. packuswb mm3, mm0
  2669. psllq mm3, 32
  2670. por mm1, mm3
  2672. add esi, 0x08
  2673. cmp esi, [w]
  2674. movq [ebx+esi-8], mm1
  2675. jl mc5
  2677. add eax, [lx2]
  2678. add ebx, [lx2]
  2679. add ecx, [lx2]
  2680. dec edi
  2681. mov esi, 0x00
  2682. cmp edi, 0x00
  2683. jg mc5
  2684. }
  2685. break;
  2687. case 6:
  2688. // d[i] = ((d[i]<<1) + s[i]+s[i+1] + 3) >> 2;
  2689. __asm
  2690. {
  2691. pxor mm0, mm0
  2692. movq mm7, [mmmask_0003]
  2693. mov eax, [s]
  2694. mov ebx, [d]
  2695. mov esi, 0x00
  2696. mov edi, [h]
  2697. mc6:
  2698. movq mm1, [eax+esi]
  2699. movq mm2, [eax+esi+1]
  2700. movq mm3, mm1
  2701. movq mm4, mm2
  2703. punpcklbw mm1, mm0
  2704. punpckhbw mm3, mm0
  2706. punpcklbw mm2, mm0
  2707. punpckhbw mm4, mm0
  2709. paddsw mm1, mm2
  2710. paddsw mm3, mm4
  2712. movq mm5, [ebx+esi]
  2714. paddsw mm1, mm7
  2715. paddsw mm3, mm7
  2717. movq mm6, mm5
  2718. punpcklbw mm5, mm0
  2719. punpckhbw mm6, mm0
  2721. psllw mm5, 1
  2722. psllw mm6, 1
  2724. paddsw mm1, mm5
  2725. paddsw mm3, mm6
  2727. psrlw mm1, 2
  2728. psrlw mm3, 2
  2730. packuswb mm1, mm0
  2731. packuswb mm3, mm0
  2733. psllq mm3, 32
  2734. por mm1, mm3
  2736. add esi, 0x08
  2737. cmp esi, [w]
  2738. movq [ebx+esi-8], mm1
  2739. jl mc6
  2741. add eax, [lx2]
  2742. add ebx, [lx2]
  2743. dec edi
  2744. mov esi, 0x00
  2745. cmp edi, 0x00
  2746. jg mc6
  2747. }
  2748. break;
  2750. case 7:
  2751. // d[i] = ((d[i]<<2) + s[i]+s[i+1]+s[i+lx]+s[i+lx+1] + 6)>>3;
  2752. __asm
  2753. {
  2754. pxor mm0, mm0
  2755. movq mm7, [mmmask_0006]
  2756. mov eax, [s]
  2757. mov ebx, [d]
  2758. mov ecx, eax
  2759. add ecx, [lx]
  2760. mov esi, 0x00
  2761. mov edi, [h]
  2762. mc7:
  2763. movq mm1, [eax+esi]
  2764. movq mm2, [eax+esi+1]
  2765. movq mm3, mm1
  2766. movq mm4, mm2
  2768. punpcklbw mm1, mm0
  2769. punpckhbw mm3, mm0
  2771. punpcklbw mm2, mm0
  2772. punpckhbw mm4, mm0
  2774. paddsw mm1, mm2
  2775. paddsw mm3, mm4
  2777. movq mm5, [ecx+esi]
  2778. paddsw mm1, mm7
  2780. movq mm6, [ecx+esi+1]
  2781. paddsw mm3, mm7
  2783. movq mm2, mm5
  2784. movq mm4, mm6
  2786. punpcklbw mm2, mm0
  2787. punpckhbw mm5, mm0
  2789. punpcklbw mm4, mm0
  2790. punpckhbw mm6, mm0
  2792. paddsw mm2, mm4
  2793. paddsw mm5, mm6
  2795. paddsw mm1, mm2
  2796. paddsw mm3, mm5
  2798. movq mm6, [ebx+esi]
  2800. movq mm4, mm6
  2801. punpcklbw mm4, mm0
  2802. punpckhbw mm6, mm0
  2804. psllw mm4, 2
  2805. psllw mm6, 2
  2807. paddsw mm1, mm4
  2808. paddsw mm3, mm6
  2810. psrlw mm1, 3
  2811. psrlw mm3, 3
  2813. packuswb mm1, mm0
  2814. packuswb mm3, mm0
  2816. psllq mm3, 32
  2817. por mm1, mm3
  2819. add esi, 0x08
  2820. cmp esi, [w]
  2821. movq [ebx+esi-8], mm1
  2822. jl mc7
  2824. add eax, [lx2]
  2825. add ebx, [lx2]
  2826. add ecx, [lx2]
  2827. dec edi
  2828. mov esi, 0x00
  2829. cmp edi, 0x00
  2830. jg mc7
  2831. }
  2832. break;
  2833. }
  2834. }
  2836. //
  2837. // motion
  2838. //
  2840. /* ISO/IEC 13818-2 sections 6.2.5.2, 6.3.17.2, and 7.6.3: Motion vectors */
  2841. void CMPEG2Dec::motion_vectors(int PMV[2][2][2],int dmvector[2],
  2842. int motion_vertical_field_select[2][2], int s,
  2843. int motion_vector_count, int mv_format, int h_r_size,
  2844. int v_r_size, int dmv, int mvscale)
  2845. {
  2846. if (motion_vector_count==1)
  2847. {
  2848. if (mv_format==MV_FIELD && !dmv)
  2849. motion_vertical_field_select[1][s] =
  2850. motion_vertical_field_select[0][s] = Get_Bits(1);
  2852. motion_vector(PMV[0][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);
  2854. /* update other motion vector predictors */
  2855. PMV[1][s][0] = PMV[0][s][0];
  2856. PMV[1][s][1] = PMV[0][s][1];
  2857. }
  2858. else
  2859. {
  2860. motion_vertical_field_select[0][s] = Get_Bits(1);
  2861. motion_vector(PMV[0][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);
  2862. motion_vertical_field_select[1][s] = Get_Bits(1);
  2863. motion_vector(PMV[1][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);
  2864. }
  2865. }
  2868. /* ISO/IEC 13818-2 section 7.6.3.6: Dual prime additional arithmetic */
  2869. void CMPEG2Dec::Dual_Prime_Arithmetic(int DMV[][2],int *dmvector, int mvx,int mvy)
  2870. {
  2871. if (picture_structure==FRAME_PICTURE)
  2872. {
  2873. if (top_field_first)
  2874. {
  2875. /* vector for prediction of top field from bottom field */
  2876. DMV[0][0] = ((mvx  +(mvx>0))>>1) + dmvector[0];
  2877. DMV[0][1] = ((mvy  +(mvy>0))>>1) + dmvector[1] - 1;
  2879. /* vector for prediction of bottom field from top field */
  2880. DMV[1][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];
  2881. DMV[1][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] + 1;
  2882. }
  2883. else
  2884. {
  2885. /* vector for prediction of top field from bottom field */
  2886. DMV[0][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];
  2887. DMV[0][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] - 1;
  2889. /* vector for prediction of bottom field from top field */
  2890. DMV[1][0] = ((mvx  +(mvx>0))>>1) + dmvector[0];
  2891. DMV[1][1] = ((mvy  +(mvy>0))>>1) + dmvector[1] + 1;
  2892. }
  2893. }
  2894. else
  2895. {
  2896. /* vector for prediction from field of opposite 'parity' */
  2897. DMV[0][0] = ((mvx+(mvx>0))>>1) + dmvector[0];
  2898. DMV[0][1] = ((mvy+(mvy>0))>>1) + dmvector[1];
  2900. /* correct for vertical field shift */
  2901. if (picture_structure==TOP_FIELD)
  2902. DMV[0][1]--;
  2903. else
  2904. DMV[0][1]++;
  2905. }
  2906. }
  2908. /* get and decode motion vector and differential motion vector for one prediction */
  2909. void CMPEG2Dec::motion_vector(int *PMV, int *dmvector, int h_r_size, int v_r_size,
  2910.    int dmv, int mvscale, int full_pel_vector)
  2911. {
  2912. int motion_code, motion_residual;
  2914. /* horizontal component */
  2915. /* ISO/IEC 13818-2 Table B-10 */
  2916. motion_code = Get_motion_code();
  2918. motion_residual = (h_r_size!=0 && motion_code!=0) ? Get_Bits(h_r_size) : 0;
  2920. decode_motion_vector(&PMV[0],h_r_size,motion_code,motion_residual,full_pel_vector);
  2922. if (dmv)
  2923. dmvector[0] = Get_dmvector();
  2925. /* vertical component */
  2926. motion_code     = Get_motion_code();
  2927. motion_residual = (v_r_size!=0 && motion_code!=0) ? Get_Bits(v_r_size) : 0;
  2929. if (mvscale)
  2930. PMV[1] >>= 1; /* DIV 2 */
  2932. decode_motion_vector(&PMV[1],v_r_size,motion_code,motion_residual,full_pel_vector);
  2934. if (mvscale)
  2935. PMV[1] <<= 1;
  2937. if (dmv)
  2938. dmvector[1] = Get_dmvector();
  2939. }
  2941. /* calculate motion vector component */
  2942. /* ISO/IEC 13818-2 section 7.6.3.1: Decoding the motion vectors */
  2943. /* Note: the arithmetic here is more elegant than that which is shown 
  2944.    in 7.6.3.1.  The end results (PMV[][][]) should, however, be the same.  */
  2945. void CMPEG2Dec::decode_motion_vector(int *pred, int r_size, int motion_code,
  2946.  int motion_residual, int full_pel_vector)
  2947. {
  2948. int lim, vec;
  2950. lim = 16<<r_size;
  2951. vec = full_pel_vector ? (*pred >> 1) : (*pred);
  2953. if (motion_code>0)
  2954. {
  2955. vec+= ((motion_code-1)<<r_size) + motion_residual + 1;
  2956. if (vec>=lim)
  2957. vec-= lim + lim;
  2958. }
  2959. else if (motion_code<0)
  2960. {
  2961. vec-= ((-motion_code-1)<<r_size) + motion_residual + 1;
  2962. if (vec<-lim)
  2963. vec+= lim + lim;
  2964. }
  2966. *pred = full_pel_vector ? (vec<<1) : vec;
  2967. }
  2969. int CMPEG2Dec::Get_motion_code()
  2970. {
  2971. int code;
  2973. if (Get_Bits(1))
  2974. return 0;
  2976. if ((code = Show_Bits(9))>=64)
  2977. {
  2978. code >>= 6;
  2979. Flush_Buffer(MVtab0[code].len);
  2981. return Get_Bits(1)?-MVtab0[code].val:MVtab0[code].val;
  2982. }
  2984. if (code>=24)
  2985. {
  2986. code >>= 3;
  2987. Flush_Buffer(MVtab1[code].len);
  2989. return Get_Bits(1)?-MVtab1[code].val:MVtab1[code].val;
  2990. }
  2992. if ((code-=12)<0)
  2993. {
  2994. Fault_Flag = 10;
  2995. return 0;
  2996. }
  2998. Flush_Buffer(MVtab2[code].len);
  3000. return Get_Bits(1) ? -MVtab2[code].val : MVtab2[code].val;
  3001. }
  3003. /* get differential motion vector (for dual prime prediction) */
  3004. int CMPEG2Dec::Get_dmvector()
  3005. {
  3006. if (Get_Bits(1))
  3007. return Get_Bits(1) ? -1 : 1;
  3008. else
  3009. return 0;
  3010. }
  3012. //
  3013. // store
  3014. //
  3016. static const __int64 mmmask_0001 = 0x0001000100010001;
  3017. static const __int64 mmmask_0002 = 0x0002000200020002;
  3018. static const __int64 mmmask_0003 = 0x0003000300030003;
  3019. static const __int64 mmmask_0004 = 0x0004000400040004;
  3020. static const __int64 mmmask_0005 = 0x0005000500050005;
  3021. static const __int64 mmmask_0007 = 0x0007000700070007;
  3022. static const __int64 mmmask_0016 = 0x0010001000100010;
  3023. static const __int64 mmmask_0040 = 0x0040004000400040;
  3024. static const __int64 mmmask_0128 = 0x0080008000800080;
  3026. void CMPEG2Dec::assembleFrame(unsigned char *src[], int pf, unsigned char *dst, int pitch)
  3027. {
  3028. unsigned char *y444;
  3030. if (Fault_Flag)
  3031. Fault_Flag = 0;
  3033. if (Luminance_Flag)
  3034. {
  3035. Luminance_Filter(src[0], lum);
  3036. y444 = lum;
  3037. }
  3038. else
  3039. y444 = src[0];
  3041. if (chroma_format==CHROMA420)
  3042. {
  3043. conv420to422(src[1], u422, pf);
  3044. conv420to422(src[2], v422, pf);
  3046. if (!dstYUY2())
  3047. {
  3048. conv422to444(u422, u444);
  3049. conv422to444(v422, v444);
  3050. }
  3051. }
  3052. else if (!dstYUY2())
  3053. {
  3054. conv422to444(src[1], u444);
  3055. conv422to444(src[2], v444);
  3056. }
  3058. if (dstYUY2())
  3059. conv422toYUY2(y444, u422, v422, dst, pitch);
  3060. else
  3061.   conv444toRGB24(y444, u444, v444, dst, pitch);
  3062. }
  3064. void CMPEG2Dec::Luminance_Filter(unsigned char *src, unsigned char *dst)
  3065. {
  3066. src += CLIP_AREA;
  3067. dst += CLIP_AREA;
  3069. __asm
  3070. {
  3071. mov edx, this
  3072. mov eax, [src]
  3073. mov ebx, [dst]
  3074. mov esi, 0x00
  3075. mov edi, [edx].LUM_AREA
  3076. pxor mm0, mm0
  3077. movq mm5, [edx].LumOffsetMask
  3078. movq mm6, [edx].LumGainMask
  3079. movq mm7, mmmask_0040
  3081. lumconv:
  3082. movq mm1, [eax+esi]
  3083. movq mm2, mm1
  3085. punpcklbw mm1, mm0
  3086. punpckhbw mm2, mm0
  3088. pmullw mm1, mm6
  3089. pmullw mm2, mm6
  3091. paddw mm1, mm7
  3092. paddw mm2, mm7
  3094. psrlw mm1, 7
  3095. psrlw mm2, 7
  3097. paddw mm1, mm5
  3098. paddw mm2, mm5
  3100. packuswb mm1, mm0
  3101. packuswb mm2, mm0
  3103. add esi, 0x08
  3104. cmp esi, edi
  3105. movq [ebx+esi-8], mm1
  3106. movq [ebx+esi-4], mm2
  3107. jl lumconv
  3108. }
  3109. }
  3111. void CMPEG2Dec::conv422to444(unsigned char *src, unsigned char *dst)
  3112. {
  3113. src += HALF_CLIP_AREA;
  3114. dst += CLIP_AREA;
  3116. __asm
  3117. {
  3118. mov edx, this
  3119. mov eax, [src]
  3120. mov ebx, [dst]
  3121. mov edi, [edx].Clip_Height
  3123. movq mm1, [mmmask_0001]
  3124. pxor mm0, mm0
  3126. convyuv444init:
  3127. movq mm7, [eax]
  3128. mov esi, 0x00
  3130. convyuv444:
  3131. movq mm2, mm7
  3132. movq mm7, [eax+esi+8]
  3133. movq mm3, mm2
  3134. movq mm4, mm7
  3136. psrlq mm3, 8
  3137. psllq mm4, 56
  3138. por mm3, mm4
  3140. movq mm4, mm2
  3141. movq mm5, mm3
  3143. punpcklbw mm4, mm0
  3144. punpcklbw mm5, mm0
  3146. movq mm6, mm4
  3147. paddusw mm4, mm1
  3148. paddusw mm4, mm5
  3149. psrlw mm4, 1
  3150. psllq mm4, 8
  3151. por mm4, mm6
  3153. punpckhbw mm2, mm0
  3154. punpckhbw mm3, mm0
  3156. movq mm6, mm2
  3157. paddusw mm2, mm1
  3158. paddusw mm2, mm3
  3160. movq [ebx+esi*2], mm4
  3162. psrlw mm2, 1
  3163. psllq mm2, 8
  3164. por mm2, mm6
  3166. add esi, 0x08
  3167. cmp esi, [edx].HALF_WIDTH_D8
  3168. movq [ebx+esi*2-8], mm2
  3169. jl convyuv444
  3171. movq mm2, mm7
  3172. punpcklbw mm2, mm0
  3173. movq mm3, mm2
  3175. psllq mm2, 8
  3176. por mm2, mm3
  3178. movq [ebx+esi*2], mm2
  3180. punpckhbw mm7, mm0
  3181. movq mm6, mm7
  3183. psllq mm6, 8
  3184. por mm6, mm7
  3186. movq [ebx+esi*2+8], mm6
  3188. add eax, [edx].HALF_WIDTH
  3189. add ebx, [edx].Coded_Picture_Width
  3190. dec edi
  3191. cmp edi, 0x00
  3192. jg convyuv444init
  3193. }
  3194. }
  3196. void CMPEG2Dec::conv420to422(unsigned char *src, unsigned char *dst, int frame_type)
  3197. {
  3198. if (frame_type)
  3199. {
  3200. __asm
  3201. {
  3202. push ebp
  3203. mov eax, [src]
  3204. mov ebx, [dst]
  3205. mov ebp, this
  3206. mov ecx, ebx
  3207. add ecx, ds:[ebp].HALF_WIDTH
  3208. mov esi, 0x00
  3209. movq mm3, [mmmask_0003]
  3210. pxor mm0, mm0
  3211. movq mm4, [mmmask_0002]
  3213. mov edx, eax
  3214. add edx, ds:[ebp].HALF_WIDTH
  3215. convyuv422topp:
  3216. movd mm1, [eax+esi]
  3217. movd mm2, [edx+esi]
  3218. movd [ebx+esi], mm1
  3219. punpcklbw mm1, mm0
  3220. pmullw mm1, mm3
  3221. paddusw mm1, mm4
  3222. punpcklbw mm2, mm0
  3223. paddusw mm2, mm1
  3224. psrlw mm2, 0x02
  3225. packuswb mm2, mm0
  3227. add esi, 0x04
  3228. cmp esi, ds:[ebp].HALF_WIDTH
  3229. movd [ecx+esi-4], mm2
  3230. jl convyuv422topp
  3232. add eax, ds:[ebp].HALF_WIDTH
  3233. add ebx, ds:[ebp].Coded_Picture_Width
  3234. add ecx, ds:[ebp].Coded_Picture_Width
  3235. mov esi, 0x00
  3237. mov edi, ds:[ebp].PROGRESSIVE_HEIGHT
  3238. convyuv422p:
  3239. movd mm1, [eax+esi]
  3241. punpcklbw mm1, mm0
  3242. mov edx, eax
  3244. pmullw mm1, mm3
  3245. sub edx, ds:[ebp].HALF_WIDTH
  3247. movd mm5, [edx+esi]
  3248. movd mm2, [edx+esi]
  3250. punpcklbw mm5, mm0
  3251. punpcklbw mm2, mm0
  3252. paddusw mm5, mm1
  3253. paddusw mm2, mm1
  3254. paddusw mm5, mm4
  3255. paddusw mm2, mm4
  3256. psrlw mm5, 0x02
  3257. psrlw mm2, 0x02
  3258. packuswb mm5, mm0
  3259. packuswb mm2, mm0
  3261. mov edx, eax
  3262. add edx, ds:[ebp].HALF_WIDTH
  3263. add esi, 0x04
  3264. cmp esi, ds:[ebp].HALF_WIDTH
  3265. movd [ebx+esi-4], mm5
  3266. movd [ecx+esi-4], mm2
  3268. jl convyuv422p
  3270. add eax, ds:[ebp].HALF_WIDTH
  3271. add ebx, ds:[ebp].Coded_Picture_Width
  3272. add ecx, ds:[ebp].Coded_Picture_Width
  3273. mov esi, 0x00
  3274. dec edi
  3275. cmp edi, 0x00
  3276. jg convyuv422p
  3278. mov edx, eax
  3279. sub edx, ds:[ebp].HALF_WIDTH
  3280. convyuv422bottomp:
  3281. movd mm1, [eax+esi]
  3282. movd mm5, [edx+esi]
  3283. punpcklbw mm5, mm0
  3284. movd [ecx+esi], mm1
  3286. punpcklbw mm1, mm0
  3287. pmullw mm1, mm3
  3288. paddusw mm5, mm1
  3289. paddusw mm5, mm4
  3290. psrlw mm5, 0x02
  3291. packuswb mm5, mm0
  3293. add esi, 0x04
  3294. cmp esi, ds:[ebp].HALF_WIDTH
  3295. movd [ebx+esi-4], mm5
  3296. jl convyuv422bottomp
  3297. pop ebp
  3298. }
  3299. }
  3300. else
  3301. {
  3302. __asm
  3303. {
  3304. push ebp
  3305. mov eax, [src]
  3306. mov ecx, [dst]
  3307. mov ebp, this
  3308. mov esi, 0x00
  3309. pxor mm0, mm0
  3310. movq mm3, [mmmask_0003]
  3311. movq mm4, [mmmask_0004]
  3312. movq mm5, [mmmask_0005]
  3314. convyuv422topi:
  3315. movd mm1, [eax+esi]
  3316. mov ebx, eax
  3317. add ebx, ds:[ebp].HALF_WIDTH
  3318. movd mm2, [ebx+esi]
  3319. movd [ecx+esi], mm1
  3320. punpcklbw mm1, mm0
  3321. movq mm6, mm1
  3322. pmullw mm1, mm3
  3324. punpcklbw mm2, mm0
  3325. movq mm7, mm2
  3326. pmullw mm2, mm5
  3327. paddusw mm2, mm1
  3328. paddusw mm2, mm4
  3329. psrlw mm2, 0x03
  3330. packuswb mm2, mm0
  3332. mov edx, ecx
  3333. add edx, ds:[ebp].HALF_WIDTH
  3334. pmullw mm6, mm5
  3335. movd [edx+esi], mm2
  3337. add ebx, ds:[ebp].HALF_WIDTH
  3338. movd mm2, [ebx+esi]
  3339. punpcklbw mm2, mm0
  3340. pmullw mm2, mm3
  3341. paddusw mm2, mm6
  3342. paddusw mm2, mm4
  3343. psrlw mm2, 0x03
  3344. packuswb mm2, mm0
  3346. add edx, ds:[ebp].HALF_WIDTH
  3347. add ebx, ds:[ebp].HALF_WIDTH
  3348. pmullw mm7, [mmmask_0007]
  3349. movd [edx+esi], mm2
  3351. movd mm2, [ebx+esi]
  3352. punpcklbw mm2, mm0
  3353. paddusw mm2, mm7
  3354. paddusw mm2, mm4
  3355. psrlw mm2, 0x03
  3356. packuswb mm2, mm0
  3358. add edx, ds:[ebp].HALF_WIDTH
  3359. add esi, 0x04
  3360. cmp esi, ds:[ebp].HALF_WIDTH
  3361. movd [edx+esi-4], mm2
  3363. jl convyuv422topi
  3365. add eax, ds:[ebp].Coded_Picture_Width
  3366. add ecx, ds:[ebp].DOUBLE_WIDTH
  3367. mov esi, 0x00
  3369. mov edi, ds:[ebp].INTERLACED_HEIGHT
  3370. convyuv422i:
  3371. movd mm1, [eax+esi]
  3372. punpcklbw mm1, mm0
  3373. movq mm6, mm1
  3374. mov ebx, eax
  3375. sub ebx, ds:[ebp].Coded_Picture_Width
  3376. movd mm3, [ebx+esi]
  3377. pmullw mm1, [mmmask_0007]
  3378. punpcklbw mm3, mm0
  3379. paddusw mm3, mm1
  3380. paddusw mm3, mm4
  3381. psrlw mm3, 0x03
  3382. packuswb mm3, mm0
  3384. add ebx, ds:[ebp].HALF_WIDTH
  3385. movq mm1, [ebx+esi]
  3386. add ebx, ds:[ebp].Coded_Picture_Width
  3387. movd [ecx+esi], mm3
  3389. movq mm3, [mmmask_0003]
  3390. movd mm2, [ebx+esi]
  3392. punpcklbw mm1, mm0
  3393. pmullw mm1, mm3
  3394. punpcklbw mm2, mm0
  3395. movq mm7, mm2
  3396. pmullw mm2, mm5
  3397. paddusw mm2, mm1
  3398. paddusw mm2, mm4
  3399. psrlw mm2, 0x03
  3400. packuswb mm2, mm0
  3402. pmullw mm6, mm5
  3403. mov edx, ecx
  3404. add edx, ds:[ebp].HALF_WIDTH
  3405. movd [edx+esi], mm2
  3407. add ebx, ds:[ebp].HALF_WIDTH
  3408. movd mm2, [ebx+esi]
  3409. punpcklbw mm2, mm0
  3410. pmullw mm2, mm3
  3411. paddusw mm2, mm6
  3412. paddusw mm2, mm4
  3413. psrlw mm2, 0x03
  3414. packuswb mm2, mm0
  3416. pmullw mm7, [mmmask_0007]
  3417. add edx, ds:[ebp].HALF_WIDTH
  3418. add ebx, ds:[ebp].HALF_WIDTH
  3419.   movd [edx+esi], mm2
  3421. movd mm2, [ebx+esi]
  3422. punpcklbw mm2, mm0
  3423. paddusw mm2, mm7
  3424. paddusw mm2, mm4
  3425. psrlw mm2, 0x03
  3426. packuswb mm2, mm0
  3428. add edx, ds:[ebp].HALF_WIDTH
  3429. add esi, 0x04
  3430. cmp esi, ds:[ebp].HALF_WIDTH
  3431. movd [edx+esi-4], mm2
  3433. jl convyuv422i
  3434. add eax, ds:[ebp].Coded_Picture_Width
  3435. add ecx, ds:[ebp].DOUBLE_WIDTH
  3436. mov esi, 0x00
  3437. dec edi
  3438. cmp edi, 0x00
  3439. jg convyuv422i
  3441. convyuv422bottomi:
  3442. movd mm1, [eax+esi]
  3443. movq mm6, mm1
  3444. punpcklbw mm1, mm0
  3445. mov ebx, eax
  3446. sub ebx, ds:[ebp].Coded_Picture_Width
  3447. movd mm3, [ebx+esi]
  3448. punpcklbw mm3, mm0
  3449. pmullw mm1, [mmmask_0007]
  3450. paddusw mm3, mm1
  3451. paddusw mm3, mm4
  3452. psrlw mm3, 0x03
  3453. packuswb mm3, mm0
  3455. add ebx, ds:[ebp].HALF_WIDTH
  3456. movq mm1, [ebx+esi]
  3457. punpcklbw mm1, mm0
  3458. movd [ecx+esi], mm3
  3460. pmullw mm1, [mmmask_0003]
  3461. add ebx, ds:[ebp].Coded_Picture_Width
  3462. movd mm2, [ebx+esi]
  3463. punpcklbw mm2, mm0
  3464. movq mm7, mm2
  3465. pmullw mm2, mm5
  3466. paddusw mm2, mm1
  3467. paddusw mm2, mm4
  3468. psrlw mm2, 0x03
  3469. packuswb mm2, mm0
  3471. mov edx, ecx
  3472. add edx, ds:[ebp].HALF_WIDTH
  3473. pmullw mm7, [mmmask_0007]
  3474. movd [edx+esi], mm2
  3476. add edx, ds:[ebp].HALF_WIDTH
  3477.   movd [edx+esi], mm6
  3479. punpcklbw mm6, mm0
  3480. paddusw mm6, mm7
  3481. paddusw mm6, mm4
  3482. psrlw mm6, 0x03
  3483. packuswb mm6, mm0
  3485. add edx, ds:[ebp].HALF_WIDTH
  3486. add esi, 0x04
  3487. cmp esi, ds:[ebp].HALF_WIDTH
  3488. movd [edx+esi-4], mm6
  3490. jl convyuv422bottomi
  3491. pop ebp
  3492. }
  3493. }
  3494. }
  3496. void CMPEG2Dec::conv444toRGB24(unsigned char *py, unsigned char *pu, unsigned char *pv, unsigned char *dst, int pitch)
  3497. {
  3498. int PWIDTH = pitch - DSTBYTES;
  3500. py += CLIP_STEP;
  3501. pu += CLIP_STEP;
  3502. pv += CLIP_STEP;
  3504. int Clip_Height = this->Clip_Height;
  3505. __int64 RGB_Offset = this->RGB_Offset;
  3506. __int64 RGB_Scale = this->RGB_Scale;
  3507. __int64 RGB_CBU = this->RGB_CBU;
  3508. __int64 RGB_CRV = this->RGB_CRV;
  3509. __int64 RGB_CGX = this->RGB_CGX;
  3510. int Clip_Width = this->Clip_Width;
  3511. int Coded_Picture_Width = this->Coded_Picture_Width;
  3513. __asm
  3514. {
  3515. mov eax, [py]
  3516. mov ebx, [pu]
  3517. mov ecx, [pv]
  3518. mov edx, [dst]
  3519. mov edi, Clip_Height
  3520. mov esi, 0x00
  3521. pxor mm0, mm0
  3523. convRGB24:
  3524. movd mm1, [eax+esi]
  3525. movd mm3, [ebx+esi]
  3526. punpcklbw mm1, mm0
  3527. punpcklbw mm3, mm0
  3528. movd mm5, [ecx+esi]
  3529. punpcklbw mm5, mm0
  3530. movq mm7, [mmmask_0128]
  3531. psubw mm3, mm7
  3532. psubw mm5, mm7
  3534. psubw mm1, RGB_Offset
  3535. movq mm2, mm1
  3536. movq mm7, [mmmask_0001]
  3537. punpcklwd mm1, mm7
  3538. punpckhwd mm2, mm7
  3539. movq mm7, RGB_Scale
  3540. pmaddwd mm1, mm7
  3541. pmaddwd mm2, mm7
  3543. movq mm4, mm3
  3544. punpcklwd mm3, mm0
  3545. punpckhwd mm4, mm0
  3546. movq mm7, RGB_CBU
  3547. pmaddwd mm3, mm7
  3548. pmaddwd mm4, mm7
  3549. paddd mm3, mm1
  3550. paddd mm4, mm2
  3551. psrld mm3, 13
  3552. psrld mm4, 13
  3553. packuswb mm3, mm0
  3554. packuswb mm4, mm0
  3556. movq mm6, mm5
  3557. punpcklwd mm5, mm0
  3558. punpckhwd mm6, mm0
  3559. movq mm7, RGB_CRV
  3560. pmaddwd mm5, mm7
  3561. pmaddwd mm6, mm7
  3562. paddd mm5, mm1
  3563. paddd mm6, mm2
  3564. psrld mm5, 13
  3565. psrld mm6, 13
  3566. packuswb mm5, mm0
  3567. packuswb mm6, mm0
  3569. punpcklbw mm3, mm5
  3570. punpcklbw mm4, mm6
  3571. movq mm5, mm3
  3572. movq mm6, mm4
  3573. psrlq mm5, 16
  3574. psrlq mm6, 16
  3575. por mm3, mm5
  3576. por mm4, mm6
  3578. movd mm5, [ebx+esi]
  3579. movd mm6, [ecx+esi]
  3580. punpcklbw mm5, mm0
  3581. punpcklbw mm6, mm0
  3582. movq mm7, [mmmask_0128]
  3583. psubw mm5, mm7
  3584. psubw mm6, mm7
  3586. movq mm7, mm6
  3587. punpcklwd mm6, mm5
  3588. punpckhwd mm7, mm5
  3589. movq mm5, RGB_CGX
  3590. pmaddwd mm6, mm5
  3591. pmaddwd mm7, mm5
  3592. paddd mm6, mm1
  3593. paddd mm7, mm2
  3595. psrld mm6, 13
  3596. psrld mm7, 13
  3597. packuswb mm6, mm0
  3598. packuswb mm7, mm0
  3600. punpcklbw mm3, mm6
  3601. punpcklbw mm4, mm7
  3603. movq mm1, mm3
  3604. movq mm5, mm4
  3605. movq mm6, mm4
  3607. psrlq mm1, 32
  3608. psllq mm1, 24
  3609. por mm1, mm3
  3611. psrlq mm3, 40
  3612. psllq mm6, 16
  3613. por mm3, mm6
  3614. movd [edx], mm1
  3616. psrld mm4, 16
  3617. psrlq mm5, 24
  3618. por mm5, mm4
  3619. movd [edx+4], mm3
  3621. add edx, 0x0c
  3622. add esi, 0x04
  3623. cmp esi, Clip_Width
  3624. movd [edx-4], mm5
  3626. jl convRGB24
  3628. add eax, Coded_Picture_Width
  3629. add ebx, Coded_Picture_Width
  3630. add ecx, Coded_Picture_Width
  3631. add edx, PWIDTH
  3632. mov esi, 0x00
  3633. dec edi
  3634. cmp edi, 0x00
  3635. jg convRGB24
  3637. emms
  3638. }
  3639. }
  3641. // YUV 4:2:2 Format:
  3642. // YUYV YUYV ...
  3643. void CMPEG2Dec::conv422toYUY2(unsigned char *py, unsigned char *pu, unsigned char *pv, unsigned char *dst, int pitch)
  3644. {
  3645. py += CLIP_STEP;
  3646. pu += CLIP_STEP;
  3647. pv += CLIP_STEP;
  3649. int y = this->Clip_Height;
  3650. int Clip_Width_2 = this->Clip_Width / 2;
  3651. int Coded_Picture_Width = this->Coded_Picture_Width;
  3652. int Coded_Picture_Width_2 = this->Coded_Picture_Width / 2;
  3654. __asm
  3655. {
  3656. emms
  3657. mov eax, [py]
  3658. mov ebx, [pu]
  3659. mov ecx, [pv]
  3660. mov edx, [dst]
  3661. mov edi, Clip_Width_2
  3662. yloop:
  3663. xor esi, esi
  3664. xloop:
  3665. movd mm1, [eax+esi*2] ;0000YYYY
  3666. movd mm2, [ebx+esi] ;0000UUUU
  3667. movd mm3, [ecx+esi] ;0000VVVV
  3668. ;interleave this to VYUYVYUY
  3669. punpcklbw mm2, mm3 ;VUVUVUVU
  3670. punpcklbw mm1, mm2 ;VYUYVYUY
  3671. movq [edx+esi*4], mm1
  3672. movd mm1, [eax+esi*2+4] ;0000YYYY
  3673. punpckhdq mm2, mm2 ;xxxxVUVU
  3674. punpcklbw mm1, mm2 ;VYUYVYUY
  3675. movq [edx+esi*4+8], mm1
  3676. add esi, 4
  3677. cmp esi, edi
  3678. jb xloop
  3679. add edx, pitch
  3680. add eax, Coded_Picture_Width
  3681. add ebx, Coded_Picture_Width_2
  3682. add ecx, Coded_Picture_Width_2
  3683. dec y
  3684. jnz yloop
  3685. emms
  3686. }
  3687. }
  3689. //
  3690. // codec
  3691. //
  3693. static const int ChromaFormat[4] = {
  3694. 0, 6, 8, 12
  3695. };
  3697. CMPEG2Dec::CMPEG2Dec()
  3698. {
  3699.   VF_File = 0;
  3700.   VF_FrameLimit = VF_FrameBound = VF_GOPLimit = VF_GOPNow = VF_GOPSize =
  3701. VF_OldFrame = VF_OldRef = 0;
  3702.   VF_FrameSize = VF_FrameRate = 0;
  3703.   memset(Rdbfr, 0, sizeof(Rdbfr));
  3704.   Rdptr = Rdmax = 0;
  3705.   CurrentBfr = NextBfr = BitsLeft = Val = Read = 0;
  3706.   Fault_Flag = File_Flag = File_Limit = FO_Flag = IDCT_Flag = SystemStream_Flag = 0;
  3707.   Luminance_Flag = Resize_Flag = KeyOp_Flag = lfsr0 = lfsr1 = 0;
  3708.   BufferOp = 0;
  3709.   memset(intra_quantizer_matrix, 0, sizeof(intra_quantizer_matrix));
  3710.   memset(non_intra_quantizer_matrix, 0, sizeof(non_intra_quantizer_matrix));
  3711.   memset(chroma_intra_quantizer_matrix, 0, sizeof(chroma_intra_quantizer_matrix));
  3712.   memset(chroma_non_intra_quantizer_matrix, 0, sizeof(chroma_non_intra_quantizer_matrix));
  3713.   load_intra_quantizer_matrix =
  3714.   load_non_intra_quantizer_matrix =
  3715.   load_chroma_intra_quantizer_matrix =
  3716.   load_chroma_non_intra_quantizer_matrix = 0;
  3717.   q_scale_type =
  3718.   alternate_scan =
  3719.   quantizer_scale = 0;
  3721. int i;
  3722. for (i=0; i<MAX_FILE_NUMBER; i++) Infilename[i] = NULL;
  3723. for (i=0; i<8; i++) p_block[i] = block[i] = NULL;
  3724. p_fTempArray = fTempArray = NULL;
  3725. for (i=0; i<3; i++) backward_reference_frame[i] = forward_reference_frame[i] =  auxframe[i] = NULL;
  3726. lum = NULL;
  3727. u422 = v422 = u444 = v444 = dstFrame = NULL;
  3728. hLibrary = NULL;
  3730.   CheckCPU();
  3731. }
  3733. static char* myfgets(char* buff, int len, FILE* file)
  3734. {
  3735. char* ret = buff;
  3737. ret[0] = 0;
  3739. while(ret = fgets(buff, len, file))
  3740. {
  3741. while(isspace(*ret)) ret++;
  3742. if(*ret) break;
  3743. }
  3745. return(ret);
  3746. }
  3748. int CMPEG2Dec::Open(const char *path, DstFormat dstFormat)
  3749. {
  3750. m_dstFormat = dstFormat;
  3751. char ID[19], PASS[19] = "DVD2AVIProjectFile";
  3752. DWORD i, j, size, code, type, tff, rff, film, ntsc, gop, top, bottom, mapping;
  3753. int repeat_on, repeat_off, repeat_init;
  3754. int Clip_Top, Clip_Bottom, Clip_Left, Clip_Right, Squeeze_Width, Squeeze_Height;
  3756. HKEY key; DWORD value = REG_SZ; DWORD length = 256;
  3757. char *ext, buffer[256];
  3759. CMPEG2Dec* out = this;
  3761. out->VF_File = fopen(path, "r");
  3762. if (out->VF_File==NULL)
  3763. return 0;
  3764. if (fgets(ID, 19, out->VF_File)==NULL)
  3765. return 0;
  3766. if (strcmp(ID, PASS))
  3767. return 0;
  3769. // load DLL
  3770. if (RegOpenKeyExA(HKEY_CURRENT_USER, "Software\VFPlugin", 0, KEY_ALL_ACCESS, &key)==ERROR_SUCCESS)
  3771. {
  3772. RegQueryValueExA(key, "DVD2AVI", NULL, &value, (unsigned char*)buffer, &length);
  3774. ext = strrchr(buffer, '\');
  3775. sprintf(buffer + (int)(ext-buffer) + 1, "OpenDVD.dll");
  3776. RegCloseKey(key);
  3777. }
  3779. if ((hLibrary = LoadLibraryA(buffer)) != NULL)
  3780. BufferOp = (PBufferOp) GetProcAddress(hLibrary, "BufferOp");
  3782. for (i=0; i<MAX_FILE_NUMBER; i++)
  3783. Infilename[i] = new char[_MAX_PATH];
  3785. if(1 != fscanf(out->VF_File, "%d", &File_Limit))
  3786. return 0;
  3788. i = File_Limit;
  3789. while (i)
  3790. {
  3791. if(1 != fscanf(out->VF_File, "%d ", &j))
  3792. return 0;
  3793. fgets(Infilename[File_Limit-i], j+1, out->VF_File);
  3794. if ((Infile[File_Limit-i] = _open(Infilename[File_Limit-i], _O_RDONLY | _O_BINARY))==-1)
  3795. return 0;
  3796. i--;
  3797. }
  3799. if(3 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "nStream_Type=%d,%X,%Xn", &SystemStream_Flag, &lfsr0, &lfsr1))
  3800. return 0;
  3801. if (lfsr0 || lfsr1)
  3802. KeyOp_Flag = 1;
  3803. else
  3804. KeyOp_Flag = 0;
  3806. if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "iDCT_Algorithm=%dn", &IDCT_Flag))
  3807. return 0;
  3809. switch (IDCT_Flag)
  3810. {
  3811. case IDCT_SSEMMX:
  3812. if (!cpu.ssemmx)
  3813. IDCT_Flag = IDCT_MMX;
  3814. break;
  3816. case IDCT_FPU:
  3817. Initialize_FPU_IDCT();
  3818. break;
  3820. case IDCT_REF:
  3821. Initialize_REF_IDCT();
  3822. break;
  3823. }
  3825. File_Flag = 0;
  3826. _lseeki64(Infile[0], 0, SEEK_SET);
  3827. Initialize_Buffer();
  3829. do
  3830. {
  3831. next_start_code();
  3832. code = Get_Bits(32);
  3833. }
  3834. while (code!=SEQUENCE_HEADER_CODE);
  3836. sequence_header();
  3838. mb_width = (horizontal_size+15)/16;
  3839. mb_height = progressive_sequence ? (vertical_size+15)/16 : 2*((vertical_size+31)/32);
  3841. Coded_Picture_Width = 16 * mb_width;
  3842. Coded_Picture_Height = 16 * mb_height;
  3844. Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width : Coded_Picture_Width>>1;
  3845. Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height : Coded_Picture_Height>>1;
  3847. block_count = ChromaFormat[chroma_format];
  3849. for (i=0; i<8; i++)
  3850. {
  3851. p_block[i] = (short *)new BYTE[sizeof(short)*64 + 64];
  3852. block[i]   = (short *)((long)p_block[i] + 64 - (long)p_block[i]%64);
  3853. }
  3855. p_fTempArray = (void *)new BYTE[sizeof(float)*128 + 64];
  3856. fTempArray = (void *)((long)p_fTempArray + 64 - (long)p_fTempArray%64);
  3858. for (i=0; i<3; i++)
  3859. {
  3860. if (i==0)
  3861. size = Coded_Picture_Width * Coded_Picture_Height;
  3862. else
  3863. size = Chroma_Width * Chroma_Height;
  3865. backward_reference_frame[i] = new unsigned char[size];
  3866. forward_reference_frame[i] = new unsigned char[size];
  3867. auxframe[i] = new unsigned char[size];
  3868. }
  3870. if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "YUVRGB_Scale=%dn", &i))
  3871. return 0;
  3873. if (i)
  3874. {
  3875. RGB_Scale = 0x1000254310002543;
  3876. RGB_Offset = 0x0010001000100010;
  3877. RGB_CBU = 0x0000408D0000408D;
  3878. RGB_CGX = 0xF377E5FCF377E5FC;
  3879. RGB_CRV = 0x0000331300003313;
  3880. }
  3881. else
  3882. {
  3883. RGB_Scale = 0x1000200010002000;
  3884. RGB_Offset = 0x0000000000000000;
  3885. RGB_CBU = 0x000038B4000038B4;
  3886. RGB_CGX = 0xF4FDE926F4FDE926;
  3887. RGB_CRV = 0x00002CDD00002CDD;
  3888. }
  3890. char* tmp = myfgets(buffer, sizeof(buffer), out->VF_File);
  3891. if(2 != sscanf(tmp, "Luminance=%d,%dn", &i, &j))
  3892. {
  3893. if(2 != sscanf(tmp, "Luminance_Filter=%d,%dn", &i, &j))
  3894. return 0;
  3895. i=128; j=0;
  3896. }
  3898. if (i==128 && j==0)
  3899. Luminance_Flag = 0;
  3900. else
  3901. {
  3902. Luminance_Flag = 1;
  3903. LumGainMask = ((__int64)i<<48) + ((__int64)i<<32) + ((__int64)i<<16) + (__int64)i;
  3904. LumOffsetMask = ((__int64)j<<48) + ((__int64)j<<32) + ((__int64)j<<16) + (__int64)j;
  3906. lum = new unsigned char[Coded_Picture_Width * Coded_Picture_Height];
  3907. }
  3909. if(6 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Picture_Size=%d,%d,%d,%d,%d,%dn", 
  3910. &Clip_Top, &Clip_Bottom, &Clip_Left, &Clip_Right, &Squeeze_Width, &Squeeze_Height))
  3911. return 0;
  3913. Resize_Flag = 0;
  3914. Resize_Width = Clip_Width = Coded_Picture_Width;
  3915. Resize_Height = Clip_Height = Coded_Picture_Height;
  3916. CLIP_AREA = HALF_CLIP_AREA = CLIP_STEP = 0;
  3918. if (Clip_Top || Clip_Bottom || Clip_Left || Clip_Right)
  3919. {
  3920. Clip_Width -= Clip_Left+Clip_Right;
  3921. Clip_Height -= Clip_Top+Clip_Bottom;
  3922. Resize_Width = Clip_Width;
  3923. Resize_Height = Clip_Height;
  3925. CLIP_AREA = Coded_Picture_Width * Clip_Top;
  3926. HALF_CLIP_AREA = (Coded_Picture_Width>>1) * Clip_Top;
  3927. CLIP_STEP = Coded_Picture_Width * Clip_Top + Clip_Left;
  3928. }
  3930. if (Squeeze_Width || Squeeze_Height)
  3931. {
  3932. Resize_Flag = 1;
  3933. Resize_Width -= Squeeze_Width;
  3934. Resize_Height -= Squeeze_Height;
  3935. }
  3937. DSTBYTES = Clip_Width * (dstRGB24() ? 3 : 2);
  3938. DSTBYTES2 = DSTBYTES * 2;
  3939. LUM_AREA = Coded_Picture_Width * Clip_Height;
  3940. PROGRESSIVE_HEIGHT = (Coded_Picture_Height>>1) - 2;
  3941. INTERLACED_HEIGHT = (Coded_Picture_Height>>2) - 2;
  3942. HALF_WIDTH = Coded_Picture_Width>>1;
  3943. HALF_WIDTH_D8 = (Coded_Picture_Width>>1) - 8;
  3944. DOUBLE_WIDTH = Coded_Picture_Width<<1;
  3946. u422 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height / 2];
  3947. v422 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height / 2];
  3948. u444 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height];
  3949. v444 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height];
  3950. dstFrame = new unsigned char[Clip_Width * Clip_Height * 4];  // max value (super set)
  3952. if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Field_Operation=%dn", &FO_Flag))
  3953. return 0;
  3954. if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Frame_Rate=%dn", &(out->VF_FrameRate)))
  3955. return 0;
  3956. if(4 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Location=%d,%X,%d,%Xn", &i, &j, &i, &j))
  3957. return 0;
  3959. ntsc = film = top = bottom = gop = mapping = repeat_on = repeat_off = repeat_init = 0;
  3961. while (1 == fscanf(out->VF_File, "%d", &type) && type<9)
  3962. {
  3963. if (type==7) // I frame
  3964. {
  3965. GOPList[gop] = reinterpret_cast<GOPLIST*>(calloc(1, sizeof(GOPLIST)));
  3966. GOPList[gop]->number = film;
  3967. if(2 != fscanf(out->VF_File, "%d %X", &(GOPList[gop]->file), &j))
  3968. break;
  3970. GOPList[gop]->position = (__int64)j*BUFFER_SIZE;
  3971. gop ++;
  3973. if(1 != fscanf(out->VF_File, "%d", &j))
  3974. break;
  3976. tff = j>>1;
  3977. rff = j & 1;
  3978. }
  3979. else // P, B frame
  3980. {
  3981. tff = type>>1;
  3982. rff = type & 1;
  3983. }
  3985. if (!film)
  3986. {
  3987. if (tff)
  3988. Field_Order = 1;
  3989. else
  3990. Field_Order = 0;
  3991. }
  3993. if (FO_Flag==FO_FILM)
  3994. {
  3995. if (rff)
  3996. repeat_on++;
  3997. else
  3998. repeat_off++;
  4000. if (repeat_init)
  4001. {
  4002. if (repeat_off-repeat_on == 5)
  4003. {
  4004. repeat_on = repeat_off = 0;
  4005. }
  4006. else
  4007. {
  4008. FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4009. FrameList[mapping]->top = FrameList[mapping]->bottom = film;
  4010. mapping ++;
  4011. }
  4013. if (repeat_on-repeat_off == 5)
  4014. {
  4015. repeat_on = repeat_off = 0;
  4016. FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4017. FrameList[mapping]->top = FrameList[mapping]->bottom = film;
  4018. mapping ++;
  4019. }
  4020. }
  4021. else
  4022. {
  4023. if (repeat_off-repeat_on == 3)
  4024. {
  4025. repeat_on = repeat_off = 0;
  4026. repeat_init = 1;
  4027. }
  4028. else
  4029. {
  4030. FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4031. FrameList[mapping]->top = FrameList[mapping]->bottom = film;
  4032. mapping ++;
  4033. }
  4035. if (repeat_on-repeat_off == 3)
  4036. {
  4037. repeat_on = repeat_off = 0;
  4038. repeat_init = 1;
  4040. FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4041. FrameList[mapping]->top = FrameList[mapping]->bottom = film;
  4042. mapping ++;
  4043. }
  4044. }
  4045. }
  4046. else
  4047. {
  4048. if (top)
  4049. {
  4050. FrameList[ntsc]->bottom = film;
  4051. ntsc ++;
  4052. FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4053. FrameList[ntsc]->top = film;
  4054. }
  4055. else if (bottom)
  4056. {
  4057. FrameList[ntsc]->top = film;
  4058. ntsc ++;
  4059. FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4060. FrameList[ntsc]->bottom = film;
  4061. }
  4062. else
  4063. {
  4064. FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4065. FrameList[ntsc]->top = film;
  4066. FrameList[ntsc]->bottom = film;
  4067. ntsc ++;
  4068. }
  4070. if (rff)
  4071. {
  4072. if (!top && !bottom)
  4073. FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
  4075. if (tff)
  4076. {
  4077. FrameList[ntsc]->top = film;
  4078. top = 1;
  4079. }
  4080. else
  4081. {
  4082. FrameList[ntsc]->bottom = film;
  4083. bottom = 1;
  4084. }
  4086. if (top && bottom)
  4087. {
  4088. top = bottom = 0;
  4089. ntsc ++;
  4090. }
  4091. }
  4092. }
  4094. film ++;
  4095. }
  4097. out->VF_FrameBound = film;
  4098. film -= 2;
  4100. if (FO_Flag==FO_FILM)
  4101. {
  4102. while (FrameList[mapping-1]->top >= film)
  4103. mapping --;
  4105. out->VF_FrameLimit = mapping;
  4106. }
  4107. else
  4108. {
  4109. if (FO_Flag==FO_SWAP)
  4110. {
  4111. Field_Order = !Field_Order;
  4113. if (Field_Order)
  4114. for (i=0; i<ntsc-1; i++)
  4115. FrameList[i]->bottom = FrameList[i+1]->bottom;
  4116. else
  4117. for (i=0; i<ntsc-1; i++)
  4118. FrameList[i]->top = FrameList[i+1]->top;
  4119. }
  4121. while ((FrameList[ntsc-1]->top >= film) || (FrameList[ntsc-1]->bottom >= film))
  4122. ntsc --;
  4124. out->VF_FrameLimit = ntsc;
  4126. for (i=0; i<out->VF_FrameLimit-1; i++)
  4127. if (FrameList[i]->top==FrameList[i+1]->top || FrameList[i]->top==FrameList[i+1]->bottom ||
  4128. FrameList[i]->bottom==FrameList[i+1]->top || FrameList[i]->bottom==FrameList[i+1]->bottom)
  4129. {
  4130. FrameList[i]->forward = 1;
  4131. FrameList[i+1]->backward = 1;
  4132. }
  4133. }
  4135. Full_Frame = 1;
  4136. for (i=0; i<out->VF_FrameLimit; i++)
  4137. if (FrameList[i]->top!=FrameList[i]->bottom)
  4138. {
  4139. Full_Frame = 0;
  4140. break;
  4141. }
  4143. out->VF_GOPNow = out->VF_GOPLimit = gop;
  4144. out->VF_OldFrame = out->VF_FrameLimit;
  4145. out->VF_FrameSize = Clip_Width * Clip_Height * 3;
  4147. return 1;
  4148. }
  4150. void CMPEG2Dec::Decode(unsigned char *dst, DWORD frame, int pitch)
  4151. {
  4152. DWORD i, now, size, origin, ref, fo;
  4153. int remain;
  4155. CMPEG2Dec* in = this;
  4157. if (FO_Flag==FO_FILM)
  4158. {
  4159. fo = 0;
  4160. frame = FrameList[frame]->top;
  4161. }
  4163. origin = frame;
  4165. if (FO_Flag!=FO_FILM)
  4166. {
  4167. if (FrameList[frame]->top == FrameList[frame]->bottom)
  4168. {
  4169. fo = 0;
  4170. frame = FrameList[frame]->top;
  4171. }
  4172. else if (FrameList[frame]->top < FrameList[frame]->bottom)
  4173. {
  4174. fo = 1;
  4175. frame = FrameList[frame]->top;
  4176. }
  4177. else
  4178. {
  4179. fo = 2;
  4180. frame = FrameList[frame]->bottom;
  4181. }
  4182. }
  4184. ref = frame;
  4186. if (frame >= GOPList[in->VF_GOPLimit-1]->number)
  4187. {
  4188. now = in->VF_GOPLimit-1;
  4189. ref -= GOPList[in->VF_GOPLimit-1]->number;
  4190. size = in->VF_FrameBound - GOPList[in->VF_GOPLimit-1]->number + 1;
  4191. }
  4192. else
  4193. for (now = 0; now < (in->VF_GOPLimit-1); now++)
  4194. {
  4195. if (frame>=GOPList[now]->number && frame<GOPList[now+1]->number)
  4196. {
  4197. ref -= GOPList[now]->number;
  4198. size = GOPList[now+1]->number - GOPList[now]->number + 1;
  4199. break;
  4200. }
  4201. }
  4203. if (fo)
  4204. ref ++;
  4206. if (now != in->VF_GOPNow)
  4207. {
  4208. if ((in->VF_OldFrame + 1)==origin)
  4209. {
  4210. if (Full_Frame)
  4211. {
  4212. Get_Hdr();
  4213. Decode_Picture(1, dst, pitch);
  4215. if (picture_structure!=FRAME_PICTURE)
  4216. {
  4217. Get_Hdr();
  4218. Decode_Picture(1, dst, pitch);
  4219. }
  4220. }
  4221. else
  4222. switch (fo)
  4223. {
  4224. case 0:
  4225. if (!FrameList[origin]->backward)
  4226. {
  4227. Get_Hdr();
  4228. Decode_Picture(1, dst, pitch);
  4230. if (picture_structure!=FRAME_PICTURE)
  4231. {
  4232. Get_Hdr();
  4233. Decode_Picture(1, dst, pitch);
  4234. }
  4236. if (FrameList[origin]->forward)
  4237. {
  4238. if (Field_Order)
  4239. Copyodd(dst, dstFrame, pitch, 1);
  4240. else
  4241. Copyeven(dst, dstFrame, pitch, 1);
  4242. }
  4243. }
  4244. else
  4245. {
  4246. Copyodd(dstFrame, dst, pitch, 0);
  4247. Copyeven(dstFrame, dst, pitch, 0);
  4248. }
  4249. break;
  4251. case 1:
  4252. Copyodd(dstFrame, dst, pitch, 0);
  4254. Get_Hdr();
  4255. Decode_Picture(1, dstFrame, DSTBYTES);
  4257. if (picture_structure!=FRAME_PICTURE)
  4258. {
  4259. Get_Hdr();
  4260. Decode_Picture(1, dstFrame, DSTBYTES);
  4261. }
  4263. Copyeven(dstFrame, dst, pitch, 0);
  4264. break;
  4266. case 2:
  4267. Copyeven(dstFrame, dst, pitch, 0);
  4269. Get_Hdr();
  4270. Decode_Picture(1, dstFrame, DSTBYTES);
  4272. if (picture_structure!=FRAME_PICTURE)
  4273. {
  4274. Get_Hdr();
  4275. Decode_Picture(1, dstFrame, DSTBYTES);
  4276. }
  4278. Copyodd(dstFrame, dst, pitch, 0);
  4279. break;
  4280. }
  4282. if (in->VF_GOPSize)
  4283. {
  4284. for (i=0; i < in->VF_GOPSize; i++)
  4285. free(GOPBuffer[i]);
  4287. in->VF_GOPSize = 0;
  4288. }
  4290. in->VF_GOPNow = in->VF_GOPLimit;
  4291. in->VF_OldFrame = origin;
  4292. return;
  4293. }
  4295. remain = ref;
  4296. in->VF_OldRef = ref;
  4297. in->VF_GOPNow = now;
  4298. Second_Field = 0;
  4300. if (size < in->VF_GOPSize)
  4301. for (i=0; i < (in->VF_GOPSize - size); i++)
  4302. free(GOPBuffer[size+i]);
  4303. else if (size > in->VF_GOPSize)
  4304. for (i=0; i < (size - in->VF_GOPSize); i++)
  4305. GOPBuffer[in->VF_GOPSize+i] = reinterpret_cast<unsigned char*>(malloc(in->VF_FrameSize));
  4307. in->VF_GOPSize = size;
  4309. File_Flag = GOPList[now]->file;
  4310. _lseeki64(Infile[GOPList[now]->file], GOPList[now]->position, SEEK_SET);
  4311. Initialize_Buffer();
  4313. while (Get_Hdr() && picture_coding_type!=I_TYPE);
  4315. Decode_Picture(0, dst, pitch);
  4317. while (Get_Hdr() && picture_coding_type==B_TYPE);
  4319. if (picture_structure!=FRAME_PICTURE)
  4320. {
  4321. Decode_Picture(0, dst, pitch);
  4322. Get_Hdr();
  4323. }
  4325. Decode_Picture(1, dst, pitch);
  4327. if (picture_structure!=FRAME_PICTURE)
  4328. {
  4329. Get_Hdr();
  4330. Decode_Picture(1, dst, pitch);
  4331. }
  4333. Copyodd(dst, GOPBuffer[0], pitch, 1);
  4334. Copyeven(dst, GOPBuffer[0], pitch, 1);
  4336. while (remain && Get_Hdr())
  4337. {
  4338. Decode_Picture(1, dst, pitch);
  4340. if (picture_structure!=FRAME_PICTURE)
  4341. {
  4342. Get_Hdr();
  4343. Decode_Picture(1, dst, pitch);
  4344. }
  4346. Copyodd(dst, GOPBuffer[ref - remain + 1], pitch, 1);
  4347. Copyeven(dst, GOPBuffer[ref - remain + 1], pitch, 1);
  4349. remain--;
  4350. }
  4352. if (!Full_Frame && ref>=(size-2))
  4353. {
  4354. Copyodd(dst, dstFrame, pitch, 1);
  4355. Copyeven(dst, dstFrame, pitch, 1);
  4356. }
  4357. }
  4358. else
  4359. {
  4360. remain = ref - in->VF_OldRef;
  4362. if (remain > 0)
  4363. {
  4364. in->VF_OldRef = ref;
  4366. while (remain && Get_Hdr())
  4367. {
  4368. Decode_Picture(1, dst, pitch);
  4370. if (picture_structure!=FRAME_PICTURE)
  4371. {
  4372. Get_Hdr();
  4373. Decode_Picture(1, dst, pitch);
  4374. }
  4376. Copyodd(dst, GOPBuffer[ref - remain + 1], pitch, 1);
  4377. Copyeven(dst, GOPBuffer[ref - remain + 1], pitch, 1);
  4379. remain--;
  4380. }
  4382. if (!Full_Frame && ref>=(size-2))
  4383. {
  4384. Copyodd(dst, dstFrame, pitch, 1);
  4385. Copyeven(dst, dstFrame, pitch, 1);
  4386. }
  4387. }
  4388. }
  4390. switch (fo)
  4391. {
  4392. case 0:
  4393. Copyodd(GOPBuffer[ref], dst, pitch, 0);
  4394. Copyeven(GOPBuffer[ref], dst, pitch, 0);
  4395. break;
  4397. case 1:
  4398. Copyodd(GOPBuffer[ref-1], dst, pitch, 0);
  4399. Copyeven(GOPBuffer[ref], dst, pitch, 0);
  4400. break;
  4402. case 2:
  4403. Copyodd(GOPBuffer[ref], dst, pitch, 0);
  4404. Copyeven(GOPBuffer[ref-1], dst, pitch, 0);
  4405. break;
  4406. }
  4408. in->VF_OldFrame = origin;
  4409. }
  4411. void CMPEG2Dec::Close()
  4412. {
  4413. int i;
  4415. for(i = 0; i < VF_GOPLimit; i++) free(GOPList[i]);
  4416. for(i = 0; i < VF_FrameLimit; i++) free(FrameList[i]);
  4418. if (VF_File != NULL)
  4419. fclose(VF_File);
  4421. while (VF_GOPSize)
  4422. {
  4423. VF_GOPSize--;
  4424. free(GOPBuffer[VF_GOPSize]);
  4425. }
  4427. while (File_Limit)
  4428. {
  4429. File_Limit--;
  4430. _close(Infile[File_Limit]);
  4431. }
  4433. for (i=0; i<MAX_FILE_NUMBER; i++)
  4434. delete [] Infilename[i];
  4436. for (i=0; i<3; i++)
  4437. {
  4438. delete [] backward_reference_frame[i];
  4439. delete [] forward_reference_frame[i];
  4440. delete [] auxframe[i];
  4441. }
  4443. delete [] u422;
  4444. delete [] v422;
  4445. delete [] u444;
  4446. delete [] v444;
  4447. delete [] dstFrame;
  4449. if(Luminance_Flag)
  4450. delete [] lum;
  4452. for (i=0; i<8; i++)
  4453. delete [] p_block[i];
  4455. delete [] p_fTempArray;
  4457. if (hLibrary)
  4458. FreeLibrary(hLibrary);
  4459. }
  4461. void CMPEG2Dec::Copyodd(unsigned char *src, unsigned char *dst, int pitch, int forward)
  4462. {
  4463. int i;
  4464. int PWIDTH = forward ? (pitch<<1) : DSTBYTES2;
  4465. int QWIDTH = forward ? DSTBYTES2 : (pitch<<1);
  4467. for (i=0; i<(Clip_Height>>1); i++)
  4468. {
  4469. memcpy (dst, src, DSTBYTES);
  4470. src += PWIDTH;
  4471. dst += QWIDTH;
  4472. }
  4473. }
  4475. void CMPEG2Dec::Copyeven(unsigned char *src, unsigned char *dst, int pitch, int forward)
  4476. {
  4477. int i;
  4478. int PWIDTH = forward ? (pitch<<1) : DSTBYTES2;
  4479. int QWIDTH = forward ? DSTBYTES2 : (pitch<<1);
  4480. src += forward ? pitch : DSTBYTES;
  4481. dst += forward ? DSTBYTES : pitch;
  4483. for (i=0; i<(Clip_Height>>1); i++)
  4484. {
  4485. memcpy (dst, src, DSTBYTES);
  4486. src += PWIDTH;
  4487. dst += QWIDTH;
  4488. }
  4489. }