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

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

多媒体编程

开发平台：

Visual C++

libmpeg2.h：源码内容
  1. /*
  2.  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
  3.  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  4.  *
  5.  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
  6.  * See http://libmpeg2.sourceforge.net/ for updates.
  7.  *
  8.  * mpeg2dec is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * mpeg2dec is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  */
  23. #pragma once
  25. typedef signed char int8_t;
  26. typedef signed short int16_t;
  27. typedef signed int int32_t;
  29. typedef unsigned char uint8_t;
  30. typedef unsigned short uint16_t;
  31. typedef unsigned int uint32_t;
  33. #define MPEG2_VERSION(a,b,c) (((a)<<16)|((b)<<8)|(c))
  34. #define MPEG2_RELEASE MPEG2_VERSION (0, 3, 2) /* 0.3.2 */
  36. #define SEQ_FLAG_MPEG2 1
  37. #define SEQ_FLAG_CONSTRAINED_PARAMETERS 2
  38. #define SEQ_FLAG_PROGRESSIVE_SEQUENCE 4
  39. #define SEQ_FLAG_LOW_DELAY 8
  40. #define SEQ_FLAG_COLOUR_DESCRIPTION 16
  42. #define SEQ_MASK_VIDEO_FORMAT 0xe0
  43. #define SEQ_VIDEO_FORMAT_COMPONENT 0
  44. #define SEQ_VIDEO_FORMAT_PAL 0x20
  45. #define SEQ_VIDEO_FORMAT_NTSC 0x40
  46. #define SEQ_VIDEO_FORMAT_SECAM 0x60
  47. #define SEQ_VIDEO_FORMAT_MAC 0x80
  48. #define SEQ_VIDEO_FORMAT_UNSPECIFIED 0xa0
  50. typedef struct {
  51.     unsigned int width, height;
  52.     unsigned int chroma_width, chroma_height;
  53.     unsigned int byte_rate;
  54.     unsigned int vbv_buffer_size;
  55.     uint32_t flags;
  57.     unsigned int picture_width, picture_height;
  58.     unsigned int display_width, display_height;
  59.     unsigned int pixel_width, pixel_height;
  60.     unsigned int frame_period;
  62.     uint8_t profile_level_id;
  63.     uint8_t colour_primaries;
  64.     uint8_t transfer_characteristics;
  65.     uint8_t matrix_coefficients;
  67. void finalize();
  68. } mpeg2_sequence_t;
  70. #define GOP_FLAG_DROP_FRAME 1
  71. #define GOP_FLAG_BROKEN_LINK 2
  72. #define GOP_FLAG_CLOSED_GOP 4
  74. typedef struct {
  75.     uint8_t hours;
  76.     uint8_t minutes;
  77.     uint8_t seconds;
  78.     uint8_t pictures;
  79.     uint32_t flags;
  80. } mpeg2_gop_t;
  82. #define PIC_MASK_CODING_TYPE 7
  83. #define PIC_FLAG_CODING_TYPE_I 1
  84. #define PIC_FLAG_CODING_TYPE_P 2
  85. #define PIC_FLAG_CODING_TYPE_B 3
  86. #define PIC_FLAG_CODING_TYPE_D 4
  88. #define PIC_FLAG_TOP_FIELD_FIRST 8
  89. #define PIC_FLAG_PROGRESSIVE_FRAME 16
  90. #define PIC_FLAG_COMPOSITE_DISPLAY 32
  91. #define PIC_FLAG_SKIP 64
  92. #define PIC_FLAG_PTS 128
  93. #define PIC_FLAG_REPEAT_FIRST_FIELD 256
  94. #define PIC_MASK_COMPOSITE_DISPLAY 0xfffff000
  96. typedef struct {
  97.     unsigned int temporal_reference;
  98.     unsigned int nb_fields;
  99.     uint32_t pts;
  100.     uint32_t flags;
  101.     struct {
  102. int x, y;
  103.     } display_offset[3];
  104. __int64 rtStart, rtStop;
  105. bool fDiscontinuity, fDelivered;
  106. } mpeg2_picture_t;
  108. typedef struct {
  109.     uint8_t* buf[3];
  110.     void* id;
  111. } mpeg2_fbuf_t;
  113. typedef enum {
  114.     STATE_BUFFER = 0,
  115.     STATE_SEQUENCE = 1,
  116.     STATE_SEQUENCE_REPEATED = 2,
  117.     STATE_GOP = 3,
  118.     STATE_PICTURE = 4,
  119.     STATE_SLICE_1ST = 5,
  120.     STATE_PICTURE_2ND = 6,
  121.     STATE_SLICE = 7,
  122.     STATE_END = 8,
  123.     STATE_INVALID = 9,
  124.     STATE_PADDING = 10
  125. } mpeg2_state_t;
  127. ////////////////////////////////////////////////////////////////////////////////////////////////
  128. ////////////////////////////////////////////////////////////////////////////////////////////////
  130. /* macroblock modes */
  131. #define MACROBLOCK_INTRA 1
  132. #define MACROBLOCK_PATTERN 2
  133. #define MACROBLOCK_MOTION_BACKWARD 4
  134. #define MACROBLOCK_MOTION_FORWARD 8
  135. #define MACROBLOCK_QUANT 16
  136. #define DCT_TYPE_INTERLACED 32
  137. /* motion_type */
  138. #define MOTION_TYPE_MASK (3*64)
  139. #define MOTION_TYPE_BASE 64
  140. #define MC_FIELD (1*64)
  141. #define MC_FRAME (2*64)
  142. #define MC_16X8 (2*64)
  143. #define MC_DMV (3*64)
  145. /* picture structure */
  146. #define TOP_FIELD 1
  147. #define BOTTOM_FIELD 2
  148. #define FRAME_PICTURE 3
  150. /* picture coding type */
  151. #define I_TYPE 1
  152. #define P_TYPE 2
  153. #define B_TYPE 3
  154. #define D_TYPE 4
  156. ////////////////////////////////////////////////////////////////////////////////////////////////
  157. ////////////////////////////////////////////////////////////////////////////////////////////////
  159. typedef void mpeg2_mc_fct(uint8_t*, const uint8_t*, int, int);
  160. typedef struct {mpeg2_mc_fct* put[8]; mpeg2_mc_fct* avg[8];} mpeg2_mc_t;
  162. class CMpeg2Decoder
  163. {
  164. public:
  165.     /* Motion vectors */
  166.     /* The f_ and b_ correspond to the forward and backward motion */
  167.     /* predictors */
  169. struct motion_t {
  170. uint8_t* ref[2][3];
  171. uint8_t** ref2[2];
  172. int pmv[2][2];
  173. int f_code[2];
  174. } m_b_motion, m_f_motion;
  176. private:
  177. int get_macroblock_modes();
  178. int get_quantizer_scale();
  179. int get_motion_delta(const int f_code);
  180. int bound_motion_vector(const int vector, const int f_code);
  181. int get_dmv();
  182. int get_coded_block_pattern();
  183. int get_luma_dc_dct_diff();
  184. int get_chroma_dc_dct_diff();
  186. void get_intra_block_B14();
  187. void get_intra_block_B15();
  188. int get_non_intra_block();
  189. void get_mpeg1_intra_block();
  190. int get_mpeg1_non_intra_block();
  191. void slice_intra_DCT(const int cc, uint8_t* dest, int stride);
  192. void slice_non_intra_DCT(uint8_t* dest, int stride);
  194. void motion_mp1(motion_t* motion, mpeg2_mc_fct * const * const table);
  195. void motion_fr_frame(motion_t* motion, mpeg2_mc_fct * const * const table);
  196. void motion_fr_field(motion_t* motion, mpeg2_mc_fct * const * const table);
  197. void motion_fr_dmv(motion_t* motion, mpeg2_mc_fct * const * const table);
  198. void motion_reuse(motion_t* motion, mpeg2_mc_fct * const * const table);
  199. void motion_zero(motion_t* motion, mpeg2_mc_fct * const * const table);
  200. void motion_fr_conceal();
  201. void motion_fi_field(motion_t * motion, mpeg2_mc_fct * const * const table);
  202. void motion_fi_16x8(motion_t* motion, mpeg2_mc_fct * const * const table);
  203. void motion_fi_dmv(motion_t* motion, mpeg2_mc_fct * const * const table);
  204. void motion_fi_conceal();
  206. int slice_init(int code);
  208. static bool m_idct_initialized;
  209. void (*m_idct_init)();
  210. void (*m_idct_copy)(int16_t* block, uint8_t* dest, const int stride);
  211. void (*m_idct_add)(const int last, int16_t* block, uint8_t* dest, const int stride);
  212. mpeg2_mc_t* m_mc;
  214. public:
  215. CMpeg2Decoder();
  216. virtual ~CMpeg2Decoder();
  218. void mpeg2_init_fbuf(uint8_t* current_fbuf[3], uint8_t* forward_fbuf[3], uint8_t* backward_fbuf[3]);
  219. void mpeg2_slice(int code, const uint8_t* buffer);
  221. int16_t* m_DCTblock;
  223.     /* bit parsing stuff */
  224.     uint32_t m_bitstream_buf; /* current 32 bit working set */
  225.     int m_bitstream_bits; /* used bits in working set */
  226.     const uint8_t* m_bitstream_ptr; /* buffer with stream data */
  228.     uint8_t* m_dest[3];
  229.     uint8_t* m_picture_dest[3];
  231.     int m_offset, m_stride, m_uv_stride;
  232.     unsigned int m_limit_x, m_limit_y_16, m_limit_y_8, m_limit_y;
  234.     /* predictor for DC coefficients in intra blocks */
  235.     int16_t m_dc_dct_pred[3];
  237.     int m_quantizer_scale; /* remove */
  238.     int m_dmv_offset; /* remove */
  239.     unsigned int m_v_offset; /* remove */
  241.     /* now non-slice-specific information */
  243.     /* sequence header stuff */
  244.     uint8_t m_intra_quantizer_matrix[64];
  245.     uint8_t m_non_intra_quantizer_matrix[64];
  247.     /* The width and height of the picture snapped to macroblock units */
  248.     int m_width, m_height;
  249.     int m_vertical_position_extension;
  251.     /* picture header stuff */
  253.     /* what type of picture this is (I, P, B, D) */
  254.     int m_coding_type;
  256.     /* picture coding extension stuff */
  258.     /* quantization factor for intra dc coefficients */
  259.     int m_intra_dc_precision;
  260.     /* top/bottom/both fields */
  261.     int m_picture_structure;
  262.     /* bool to indicate all predictions are frame based */
  263.     int m_frame_pred_frame_dct;
  264.     /* bool to indicate whether intra blocks have motion vectors */
  265.     /* (for concealment) */
  266.     int m_concealment_motion_vectors;
  267.     /* bit to indicate which quantization table to use */
  268.     int m_q_scale_type;
  269.     /* bool to use different vlc tables */
  270.     int m_intra_vlc_format;
  271.     /* used for DMV MC */
  272.     int m_top_field_first;
  274.     /* stuff derived from bitstream */
  276.     /* pointer to the zigzag scan we're supposed to be using */
  277.     const uint8_t* m_scan;
  279.     int m_second_field;
  281.     int m_mpeg1;
  282. };
  284. class CMpeg2Info
  285. {
  286. public:
  287. CMpeg2Info();
  288. virtual ~CMpeg2Info();
  290. void Reset();
  292. mpeg2_sequence_t* m_sequence;
  293.     mpeg2_gop_t* m_gop;
  294.     mpeg2_picture_t* m_current_picture;
  295.     mpeg2_picture_t* m_current_picture_2nd;
  296.     mpeg2_fbuf_t* m_current_fbuf;
  297.     mpeg2_picture_t* m_display_picture;
  298.     mpeg2_picture_t* m_display_picture_2nd;
  299.     mpeg2_fbuf_t* m_display_fbuf;
  300.     mpeg2_fbuf_t* m_discard_fbuf;
  301.     const uint8_t* m_user_data;
  302.     int m_user_data_len;
  303. };
  305. class CMpeg2Dec
  306. {
  307. int skip_chunk(int bytes);
  308. int copy_chunk(int bytes);
  309. mpeg2_state_t seek_chunk(), seek_header(), seek_sequence();
  311. int sequence_ext();
  312. int sequence_display_ext();
  313. int quant_matrix_ext();
  314. int copyright_ext();
  315. int picture_display_ext();
  316. int picture_coding_ext();
  318. public:
  319. CMpeg2Dec();
  320. virtual ~CMpeg2Dec();
  322. void mpeg2_init();
  323. void mpeg2_close();
  325. void mpeg2_buffer(uint8_t* start, uint8_t* end);
  326. int mpeg2_getpos();
  327. mpeg2_state_t mpeg2_parse();
  329. void mpeg2_skip(int skip);
  330. void mpeg2_slice_region(int start, int end);
  332. void mpeg2_pts(uint32_t pts);
  334. /* decode.c */
  335. mpeg2_state_t mpeg2_seek_sequence();
  336. mpeg2_state_t mpeg2_parse_header();
  338. /* header.c */
  339. void mpeg2_header_state_init();
  340. int mpeg2_header_sequence();
  341. int mpeg2_header_gop();
  342. mpeg2_state_t mpeg2_header_picture_start();
  343. int mpeg2_header_picture();
  344. int mpeg2_header_extension();
  345. int mpeg2_header_user_data();
  346. void mpeg2_header_matrix_finalize();
  347. void mpeg2_header_sequence_finalize();
  348. mpeg2_state_t mpeg2_header_slice_start();
  349. mpeg2_state_t mpeg2_header_end();
  350. void mpeg2_set_fbuf(int coding_type);
  352. enum {BUFFER_SIZE = 1194 * 1024};
  355. CMpeg2Decoder m_decoder;
  356.     CMpeg2Info m_info;
  358.     uint32_t m_shift;
  359.     int m_is_display_initialized;
  360. mpeg2_state_t (CMpeg2Dec::* m_action)();
  361.     mpeg2_state_t m_state;
  362.     uint32_t m_ext_state;
  364.     /* allocated in init - gcc has problems allocating such big structures */
  365.     uint8_t* m_chunk_buffer;
  366.     /* pointer to start of the current chunk */
  367.     uint8_t* m_chunk_start;
  368.     /* pointer to current position in chunk_buffer */
  369.     uint8_t* m_chunk_ptr;
  370.     /* last start code ? */
  371.     uint8_t m_code;
  373.     /* PTS */
  374.     uint32_t m_pts_current, m_pts_previous;
  375.     int m_num_pts;
  376.     int m_bytes_since_pts;
  378.     bool m_first;
  379.     int m_alloc_index;
  380.     uint8_t m_first_decode_slice;
  381.     uint8_t m_nb_decode_slices;
  383.     mpeg2_sequence_t m_new_sequence;
  384.     mpeg2_sequence_t m_sequence;
  385.     mpeg2_gop_t m_gop;
  386.     mpeg2_picture_t m_pictures[4];
  387.     mpeg2_picture_t* m_picture;
  388.     /*const*/ mpeg2_fbuf_t* m_fbuf[3]; /* 0: current fbuf, 1-2: prediction fbufs */
  390. mpeg2_fbuf_t m_fbuf_alloc[3];
  392.     uint8_t* m_buf_start;
  393.     uint8_t* m_buf_end;
  395.     int16_t m_display_offset_x, m_display_offset_y;
  397.     int m_copy_matrix;
  398.     uint8_t m_intra_quantizer_matrix[64];
  399.     uint8_t m_non_intra_quantizer_matrix[64];
  400. };