mpeg2dec.c
上传用户:hhs829
上传日期:2022-06-17
资源大小:586k
文件大小:6k
源码类别:

DirextX编程

开发平台:

Visual C++

  1. /* 
  2.  * Copyright (C) Chia-chen Kuo - Jan 2001
  3.  *
  4.  *  This file is part of DVD2AVI, a free MPEG-2 decoder
  5.  *
  6.  *  DVD2AVI is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2, or (at your option)
  9.  *  any later version.
  10.  *   
  11.  *  DVD2AVI is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14.  *  GNU General Public License for more details.
  15.  *   
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with GNU Make; see the file COPYING.  If not, write to
  18.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  19.  *
  20.  */
  21. #include "global.h"
  22. #include "getbit.h"
  23. static int ChromaFormat[4] = {
  24. 0, 6, 8, 12
  25. };
  26. void InitialDecoder(void);
  27. void InitSystem(void);
  28. void UninitSystem(void);
  29. void ResetSystem(void);
  30. void CheckSequenceHeader(void);
  31. void InitialDecoder()
  32. {
  33. int i, size;
  34. mb_width = (horizontal_size+15)/16;
  35. mb_height = progressive_sequence ? (vertical_size+15)/16 : 2*((vertical_size+31)/32);
  36. Coded_Picture_Width = 16 * mb_width;
  37. Coded_Picture_Height = 16 * mb_height;
  38. Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width : Coded_Picture_Width>>1;
  39. Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height : Coded_Picture_Height>>1;
  40. block_count = ChromaFormat[chroma_format];
  41. hheightd2 = Coded_Picture_Height / 2 - 2;
  42. qheightd2 = Coded_Picture_Height / 4 - 2;
  43. hwidth = Coded_Picture_Width / 2;
  44. hwidthd8 = Coded_Picture_Width / 2 - 8;
  45. dwidth = Coded_Picture_Width * 2;
  46. qwidth = Coded_Picture_Width * 4;
  47. nwidth = Coded_Picture_Width * 9;
  48. for (i=0; i<3; i++)
  49. {
  50. if (i==0)
  51. size = Coded_Picture_Width * Coded_Picture_Height;
  52. else
  53. size = Chroma_Width * Chroma_Height;
  54. backward_reference_frame[i] = (unsigned char*)malloc(size);
  55. forward_reference_frame[i] = (unsigned char*)malloc(size);
  56. auxframe[i] = (unsigned char*)malloc(size);
  57. }
  58. u422 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height/2);
  59. v422 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height/2);
  60. u444 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height);
  61. v444 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height);
  62. rgb24 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height*3);
  63. yuy2 = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height*2);
  64. lum = (unsigned char*)malloc(Coded_Picture_Width*Coded_Picture_Height);
  65. ZeroMemory(&birgb, sizeof(BITMAPINFOHEADER));
  66. birgb.biSize = sizeof(BITMAPINFOHEADER);
  67. birgb.biWidth = Coded_Picture_Width;
  68. birgb.biHeight = Coded_Picture_Height;
  69. birgb.biPlanes = 1;
  70. birgb.biBitCount = 24;
  71. birgb.biCompression = BI_RGB;
  72. birgb.biSizeImage = Coded_Picture_Width * Coded_Picture_Height * 3;
  73. biyuv = birgb;
  74. biyuv.biBitCount = 16;
  75. biyuv.biCompression = mmioFOURCC('Y','U','Y','2');
  76. biyuv.biSizeImage = Coded_Picture_Width * Coded_Picture_Height * 2;
  77. }
  78. void CheckSequenceHeader(void)
  79. {
  80. if (!Check_Flag)
  81. {
  82. SetCacheChecking();
  83. Initialize_Buffer();
  84. while (!Check_Flag)
  85. {
  86. next_start_code();
  87. switch (Get_Bits(32))
  88. {
  89. case PACK_START_CODE:
  90. SystemStream_Flag = 1;
  91. break;
  92. case SEQUENCE_HEADER_CODE:
  93. sequence_header();
  94. InitialDecoder();
  95. Check_Flag = 1;
  96. break;
  97. }
  98. }
  99. Frame_Rate = (FO_Flag==FO_FILM) ? frame_rate*4/5 : frame_rate;
  100. ResetCacheChecking();   // Reuse the cache header
  101. Initialize_Buffer();
  102. }
  103. }
  104. void InitSystem(void)
  105. {
  106. int  i;
  107. Stop_Flag = Rip_Flag = Fault_Flag = 0;
  108. Frame_Number = Second_Field = 0;
  109. VOB_ID = CELL_ID = 0;
  110. Bitrate_Meter = 0;
  111. SystemStream_Flag = 0;
  112. for (i = 0; i < 8; i++)
  113. {
  114. p_block[i] = (short *)malloc(sizeof(short)*64 + 64);
  115. block[i]   = (short *)((long)p_block[i] + 64 - (long)p_block[i]%64);
  116. }
  117. Initialize_REF_IDCT();
  118. Initialize_FPU_IDCT();
  119. iDCT_Flag  = IDCT_MMX;
  120. FO_Flag    = FO_NONE;
  121. Scale_Flag = TRUE;
  122. if (Scale_Flag)
  123. {
  124. YUVRGB_Scale  = 0x1000254310002543;
  125. YUVRGB_Offset = 0x0010001000100010;
  126. }
  127. else
  128. {
  129. YUVRGB_Scale  = 0x1000200010002000;
  130. YUVRGB_Offset = 0x0000000000000000;
  131. }
  132. Luminance_Flag     = 0;
  133. gIsPictureDecoding = FALSE;
  134. gIsEOS = FALSE; 
  135. }
  136. void UninitSystem(void)
  137. {
  138. int i;
  139. if (Check_Flag)
  140. {
  141. for (i=0; i<3; i++)
  142. {
  143. free(backward_reference_frame[i]);
  144. free(forward_reference_frame[i]);
  145. free(auxframe[i]);
  146. }
  147. free(u422);
  148. free(v422);
  149. free(u444);
  150. free(v444);
  151. free(rgb24);
  152. free(yuy2);
  153. free(lum);
  154. }
  155. Check_Flag = 0;
  156. // Added by luqiming
  157. for (i = 0; i < 8; i++)
  158. {
  159. if (p_block[i])
  160. {
  161. free(p_block[i]);
  162. p_block[i] = 0;
  163. }
  164. }
  165. }
  166. void ResetSystem(void)
  167. {
  168. int  i, size;
  169. Stop_Flag = Rip_Flag = Fault_Flag = 0;
  170. Frame_Number = Second_Field = 0;
  171. VOB_ID = CELL_ID = 0;
  172. Bitrate_Meter = 0;
  173. // Reset all buffers
  174. if (Check_Flag)
  175. {
  176. for (i = 0; i < 3; i++)
  177. {
  178. if (i==0)
  179. size = Coded_Picture_Width * Coded_Picture_Height;
  180. else
  181. size = Chroma_Width * Chroma_Height;
  182. ZeroMemory(backward_reference_frame[i], size);
  183. ZeroMemory(forward_reference_frame[i], size);
  184. ZeroMemory(auxframe[i], size);
  185. }
  186. size = Coded_Picture_Width*Coded_Picture_Height;
  187. ZeroMemory(u422, size/2);
  188. ZeroMemory(v422, size/2);
  189. ZeroMemory(u444, size);
  190. ZeroMemory(v444, size);
  191. ZeroMemory(rgb24, size*3);
  192. ZeroMemory(yuy2, size*2);
  193. ZeroMemory(lum, size);
  194. }
  195. for (i = 0; i < 8; i++)
  196. {
  197. ZeroMemory(p_block[i], sizeof(short)*64 + 64);
  198. }
  199. Initialize_REF_IDCT();
  200. Initialize_FPU_IDCT();
  201. }