mpegvideoparser

mpegvideoparser — Convenience library for mpeg1 and 2 video bitstream parsing.

Synopsis

#include <gst/codecparsers/gstmpegvideoparser.h>

enum                GstMpegVideoPacketTypeCode;
enum                GstMpegVideoPacketExtensionCode;
enum                GstMpegVideoLevel;
enum                GstMpegVideoProfile;
enum                GstMpegVideoPictureType;
enum                GstMpegVideoPictureStructure;
struct              GstMpegVideoSequenceHdr;
struct              GstMpegVideoSequenceExt;
struct              GstMpegVideoPictureHdr;
struct              GstMpegVideoGop;
struct              GstMpegVideoPictureExt;
struct              GstMpegVideoQuantMatrixExt;
struct              GstMpegVideoTypeOffsetSize;
GList *             gst_mpeg_video_parse                (const guint8 *data,
                                                         gsize size,
                                                         guint offset);
gboolean            gst_mpeg_video_parse_sequence_header
                                                        (GstMpegVideoSequenceHdr *params,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);
gboolean            gst_mpeg_video_parse_picture_header (GstMpegVideoPictureHdr *hdr,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);
gboolean            gst_mpeg_video_parse_picture_extension
                                                        (GstMpegVideoPictureExt *ext,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);
gboolean            gst_mpeg_video_parse_gop            (GstMpegVideoGop *gop,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);
gboolean            gst_mpeg_video_parse_sequence_extension
                                                        (GstMpegVideoSequenceExt *seqext,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);
gboolean            gst_mpeg_video_parse_quant_matrix_extension
                                                        (GstMpegVideoQuantMatrixExt *quant,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Description

Provides useful functions for mpeg videos bitstream parsing.

Details

enum GstMpegVideoPacketTypeCode

typedef enum {
  GST_MPEG_VIDEO_PACKET_PICTURE      = 0x00,
  GST_MPEG_VIDEO_PACKET_SLICE_MIN    = 0x01,
  GST_MPEG_VIDEO_PACKET_SLICE_MAX    = 0xaf,
  GST_MPEG_VIDEO_PACKET_USER_DATA    = 0xb2,
  GST_MPEG_VIDEO_PACKET_SEQUENCE     = 0xb3,
  GST_MPEG_VIDEO_PACKET_EXTENSION    = 0xb5,
  GST_MPEG_VIDEO_PACKET_SEQUENCE_END = 0xb7,
  GST_MPEG_VIDEO_PACKET_GOP          = 0xb8,
  GST_MPEG_VIDEO_PACKET_NONE         = 0xff
} GstMpegVideoPacketTypeCode;

Indicates the type of MPEG packet

`GST_MPEG_VIDEO_PACKET_PICTURE`	Picture packet starting code
`GST_MPEG_VIDEO_PACKET_SLICE_MIN`	Slice min packet starting code
`GST_MPEG_VIDEO_PACKET_SLICE_MAX`	Slice max packet starting code
`GST_MPEG_VIDEO_PACKET_USER_DATA`	User data packet starting code
`GST_MPEG_VIDEO_PACKET_SEQUENCE`	Sequence packet starting code
`GST_MPEG_VIDEO_PACKET_EXTENSION`	Extension packet starting code
`GST_MPEG_VIDEO_PACKET_SEQUENCE_END`	Sequence end packet code
`GST_MPEG_VIDEO_PACKET_GOP`	Group of Picture packet starting code
`GST_MPEG_VIDEO_PACKET_NONE`	None packet code

enum GstMpegVideoPacketExtensionCode

typedef enum {
  GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE         = 0x01,
  GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE_DISPLAY = 0x02,
  GST_MPEG_VIDEO_PACKET_EXT_QUANT_MATRIX     = 0x03,
  GST_MPEG_VIDEO_PACKET_EXT_PICTURE          = 0x08
} GstMpegVideoPacketExtensionCode;

Indicates what type of packets are in this block, some are mutually exclusive though - ie, sequence packs are accumulated separately. GOP & Picture may occur together or separately.

`GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE`	Sequence extension code
`GST_MPEG_VIDEO_PACKET_EXT_SEQUENCE_DISPLAY`	Sequence Display extension code
`GST_MPEG_VIDEO_PACKET_EXT_QUANT_MATRIX`	Quantization Matrix extension code
`GST_MPEG_VIDEO_PACKET_EXT_PICTURE`	Picture coding extension

enum GstMpegVideoLevel

typedef enum {
 GST_MPEG_VIDEO_LEVEL_HIGH      = 0x04,
 GST_MPEG_VIDEO_LEVEL_HIGH_1440 = 0x06,
 GST_MPEG_VIDEO_LEVEL_MAIN      = 0x08,
 GST_MPEG_VIDEO_LEVEL_LOW       = 0x0a
} GstMpegVideoLevel;

Mpeg-2 Levels.

`GST_MPEG_VIDEO_LEVEL_HIGH`	High level (HL)
`GST_MPEG_VIDEO_LEVEL_HIGH_1440`	High 1440 level (H-14)
`GST_MPEG_VIDEO_LEVEL_MAIN`	Main level (ML)
`GST_MPEG_VIDEO_LEVEL_LOW`	Low level (LL)

enum GstMpegVideoProfile

typedef enum {
  GST_MPEG_VIDEO_PROFILE_422                 = 0x00,
  GST_MPEG_VIDEO_PROFILE_HIGH                = 0x01,
  GST_MPEG_VIDEO_PROFILE_SPATIALLY_SCALABLE  = 0x02,
  GST_MPEG_VIDEO_PROFILE_SNR_SCALABLE        = 0x03,
  GST_MPEG_VIDEO_PROFILE_MAIN                = 0x04,
  GST_MPEG_VIDEO_PROFILE_SIMPLE              = 0x05
} GstMpegVideoProfile;

Mpeg-2 Profiles.

`GST_MPEG_VIDEO_PROFILE_422`	4:2:2 profile (422)
`GST_MPEG_VIDEO_PROFILE_HIGH`	High profile (HP)
`GST_MPEG_VIDEO_PROFILE_SPATIALLY_SCALABLE`	Spatially Scalable profile (Spatial)
`GST_MPEG_VIDEO_PROFILE_SNR_SCALABLE`	SNR Scalable profile (SNR)
`GST_MPEG_VIDEO_PROFILE_MAIN`	Main profile (MP)
`GST_MPEG_VIDEO_PROFILE_SIMPLE`	Simple profile (SP)

enum GstMpegVideoPictureType

typedef enum {
  GST_MPEG_VIDEO_PICTURE_TYPE_I = 0x01,
  GST_MPEG_VIDEO_PICTURE_TYPE_P = 0x02,
  GST_MPEG_VIDEO_PICTURE_TYPE_B = 0x03,
  GST_MPEG_VIDEO_PICTURE_TYPE_D = 0x04
} GstMpegVideoPictureType;

Picture type.

`GST_MPEG_VIDEO_PICTURE_TYPE_I`	Intra-coded (I) frame
`GST_MPEG_VIDEO_PICTURE_TYPE_P`	Predictive-codec (P) frame
`GST_MPEG_VIDEO_PICTURE_TYPE_B`	Bidirectionally predictive-coded (B) frame
`GST_MPEG_VIDEO_PICTURE_TYPE_D`	D frame

enum GstMpegVideoPictureStructure

typedef enum {
    GST_MPEG_VIDEO_PICTURE_STRUCTURE_TOP_FIELD    = 0x01,
    GST_MPEG_VIDEO_PICTURE_STRUCTURE_BOTTOM_FIELD = 0x02,
    GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME        = 0x03
} GstMpegVideoPictureStructure;

Picture structure type.

`GST_MPEG_VIDEO_PICTURE_STRUCTURE_TOP_FIELD`	Top field
`GST_MPEG_VIDEO_PICTURE_STRUCTURE_BOTTOM_FIELD`	Bottom field
`GST_MPEG_VIDEO_PICTURE_STRUCTURE_FRAME`	Frame picture

struct GstMpegVideoSequenceHdr

struct GstMpegVideoSequenceHdr {
  guint16 width, height;
  guint8  aspect_ratio_info;
  guint8  frame_rate_code;
  guint32 bitrate_value;
  guint16 vbv_buffer_size_value;

  guint8  constrained_parameters_flag;

  guint8  intra_quantizer_matrix[64];
  guint8  non_intra_quantizer_matrix[64];

  /* Calculated values */
  guint   par_w, par_h;
  guint   fps_n, fps_d;
  guint   bitrate;
};

The Mpeg2 Video Sequence Header structure.

guint16 `width`;	Width of each frame
guint16 `height`;	Height of each frame
guint8 `aspect_ratio_info`;
guint8 `frame_rate_code`;
guint32 `bitrate_value`;	Value of the bitrate as is in the stream (400bps unit)
guint16 `vbv_buffer_size_value`;
guint8 `constrained_parameters_flag`;	`TRUE` if this stream uses contrained parameters.
guint8 `intra_quantizer_matrix`[64];	intra-quantization table
guint8 `non_intra_quantizer_matrix`[64];	non-intra quantization table
guint `par_w`;	Calculated Pixel Aspect Ratio width
guint `par_h`;	Calculated Pixel Aspect Ratio height
guint `fps_n`;	Calculated Framrate nominator
guint `fps_d`;	Calculated Framerate denominator
guint `bitrate`;	the real bitrate of the Mpeg video stream in bits per second, 0 if VBR stream

struct GstMpegVideoSequenceExt

struct GstMpegVideoSequenceExt {
  /* mpeg2 decoder profile */
  guint8 profile;
  /* mpeg2 decoder level */
  guint8 level;

  guint8 progressive;
  guint8 chroma_format;

  guint8 horiz_size_ext, vert_size_ext;

  guint16 bitrate_ext;
  guint8 vbv_buffer_size_extension;
  guint8 low_delay;
  guint8 fps_n_ext, fps_d_ext;
};

The Mpeg2 Video Sequence Extension structure.

guint8 `profile`;	mpeg2 decoder profil
guint8 `level`;	mpeg2 decoder level
guint8 `progressive`;	`TRUE` if the frames are progressive `FALSE` otherwize
guint8 `chroma_format`;	indicates the chrominance format
guint8 `horiz_size_ext`;	Horizontal size
guint8 `vert_size_ext`;	Vertical size
guint16 `bitrate_ext`;	The bitrate
guint8 `vbv_buffer_size_extension`;	Vbv vuffer size
guint8 `low_delay`;	`TRUE` if the sequence doesn't contain any B-pictures, `FALSE` otherwize
guint8 `fps_n_ext`;	Framerate nominator code
guint8 `fps_d_ext`;	Framerate denominator code

struct GstMpegVideoPictureHdr

struct GstMpegVideoPictureHdr {
  guint16 tsn;
  guint8 pic_type;

  guint8 full_pel_forward_vector, full_pel_backward_vector;

  guint8 f_code[2][2];
};

The Mpeg2 Video Picture Header structure.

guint16 `tsn`;	Temporal Sequence Number
guint8 `pic_type`;	Type of the frame
guint8 `full_pel_forward_vector`;	the full pel forward flag of the frame: 0 or 1.
guint8 `full_pel_backward_vector`;	the full pel backward flag of the frame: 0 or 1.
guint8 `f_code`[2][2];	F code

struct GstMpegVideoGop

struct GstMpegVideoGop {
  guint8 drop_frame_flag;

  guint8 hour, minute, second, frame;

  guint8 closed_gop;
  guint8 broken_link;
};

The Mpeg Video Group of Picture structure.

guint8 `drop_frame_flag`;	Drop Frame Flag
guint8 `hour`;	Hour (0-23)
guint8 `minute`;	Minute (O-59)
guint8 `second`;	Second (0-59)
guint8 `frame`;	Frame (0-59)
guint8 `closed_gop`;	Closed Gop
guint8 `broken_link`;	Broken link

struct GstMpegVideoPictureExt

struct GstMpegVideoPictureExt {
  guint8 f_code[2][2];

  guint8 intra_dc_precision;
  guint8 picture_structure;
  guint8 top_field_first;
  guint8 frame_pred_frame_dct;
  guint8 concealment_motion_vectors;
  guint8 q_scale_type;
  guint8 intra_vlc_format;
  guint8 alternate_scan;
  guint8 repeat_first_field;
  guint8 chroma_420_type;
  guint8 progressive_frame;
  guint8 composite_display;
  guint8 v_axis;
  guint8 field_sequence;
  guint8 sub_carrier;
  guint8 burst_amplitude;
  guint8 sub_carrier_phase;
};

The Mpeg2 Video Picture Extension structure.

guint8 `f_code`[2][2];
guint8 `intra_dc_precision`;	Intra DC precision
guint8 `picture_structure`;	Structure of the picture
guint8 `top_field_first`;	Top field first
guint8 `frame_pred_frame_dct`;	Frame
guint8 `concealment_motion_vectors`;	Concealment Motion Vectors
guint8 `q_scale_type`;	Q Scale Type
guint8 `intra_vlc_format`;	Intra Vlc Format
guint8 `alternate_scan`;	Alternate Scan
guint8 `repeat_first_field`;	Repeat First Field
guint8 `chroma_420_type`;	Chroma 420 Type
guint8 `progressive_frame`;	`TRUE` if the frame is progressive `FALSE` otherwize
guint8 `composite_display`;
guint8 `v_axis`;
guint8 `field_sequence`;
guint8 `sub_carrier`;
guint8 `burst_amplitude`;
guint8 `sub_carrier_phase`;

struct GstMpegVideoQuantMatrixExt

struct GstMpegVideoQuantMatrixExt {
 guint8 load_intra_quantiser_matrix;
 guint8 intra_quantiser_matrix[64];
 guint8 load_non_intra_quantiser_matrix;
 guint8 non_intra_quantiser_matrix[64];
 guint8 load_chroma_intra_quantiser_matrix;
 guint8 chroma_intra_quantiser_matrix[64];
 guint8 load_chroma_non_intra_quantiser_matrix;
 guint8 chroma_non_intra_quantiser_matrix[64];
};

The Quant Matrix Extension structure

struct GstMpegVideoTypeOffsetSize

struct GstMpegVideoTypeOffsetSize {
  guint8 type;
  guint  offset;
  gint   size;
};

A structure that contains the type of a packet, its offset and its size

guint8 `type`;	the type of the packet that start at `offset`
guint `offset`;	the offset of the packet start in bytes, it is the exact, start of the packet, no sync code included
gint `size`;	The size in bytes of the packet or -1 if the end wasn't found. It is the exact size of the packet, no sync code included

gst_mpeg_video_parse ()

GList *             gst_mpeg_video_parse                (const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Parses the MPEG 1/2 video bitstream contained in data , and returns the detect packets as a list of GstMpegVideoTypeOffsetSize.

`data` :	The data to parse
`size` :	The size of `data`
`offset` :	The offset from which to start parsing
Returns :	a GList of GstMpegVideoTypeOffsetSize

gst_mpeg_video_parse_sequence_header ()

gboolean            gst_mpeg_video_parse_sequence_header
                                                        (GstMpegVideoSequenceHdr *params,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Parses the seqhdr Mpeg Video Sequence Header structure members from data

`seqhdr` :	The GstMpegVideoSequenceHdr structure to fill. [out]
`data` :	The data from which to parse the sequence header
`size` :	The size of `data`
`offset` :	The offset in byte from which to start parsing `data`
Returns :	`TRUE` if the seqhdr could be parsed correctly, `FALSE` otherwize.

gst_mpeg_video_parse_picture_header ()

gboolean            gst_mpeg_video_parse_picture_header (GstMpegVideoPictureHdr *hdr,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Parsers the hdr Mpeg Video Picture Header structure members from data

`hdr` :	The GstMpegVideoPictureHdr structure to fill. [out]
`data` :	The data from which to parse the picture header
`size` :	The size of `data`
`offset` :	The offset in byte from which to start the parsing
Returns :	`TRUE` if the picture sequence could be parsed correctly, `FALSE` otherwize.

gst_mpeg_video_parse_picture_extension ()

gboolean            gst_mpeg_video_parse_picture_extension
                                                        (GstMpegVideoPictureExt *ext,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Parse the ext Mpeg Video Picture Extension structure members from data

`ext` :	The GstMpegVideoPictureExt structure to fill. [out]
`data` :	The data from which to parse the picture extension
`size` :	The size of `data`
`offset` :	The offset in byte from which to start the parsing
Returns :	`TRUE` if the picture extension could be parsed correctly, `FALSE` otherwize.

gst_mpeg_video_parse_gop ()

gboolean            gst_mpeg_video_parse_gop            (GstMpegVideoGop *gop,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Parses the gop Mpeg Video Group of Picture structure members from data

`gop` :	The GstMpegVideoGop structure to fill. [out]
`data` :	The data from which to parse the gop
`size` :	The size of `data`
`offset` :	The offset in byte from which to start the parsing
Returns :	`TRUE` if the gop could be parsed correctly, `FALSE` otherwize.

gst_mpeg_video_parse_sequence_extension ()

gboolean            gst_mpeg_video_parse_sequence_extension
                                                        (GstMpegVideoSequenceExt *seqext,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Parses the seqext Mpeg Video Sequence Extension structure members from data

`seqext` :	The GstMpegVideoSequenceExt structure to fill. [out]
`data` :	The data from which to parse the sequence extension
`size` :	The size of `data`
`offset` :	The offset in byte from which to start parsing `data`
Returns :	`TRUE` if the seqext could be parsed correctly, `FALSE` otherwize.

gst_mpeg_video_parse_quant_matrix_extension ()

gboolean            gst_mpeg_video_parse_quant_matrix_extension
                                                        (GstMpegVideoQuantMatrixExt *quant,
                                                         const guint8 *data,
                                                         gsize size,
                                                         guint offset);

Parses the quant Mpeg Video Quant Matrix Extension structure members from data

`quant` :	The GstMpegVideoQuantMatrixExt structure to fill. [out]
`data` :	The data from which to parse the Quantization Matrix extension
`size` :	The size of `data`
`offset` :	The offset in byte from which to start the parsing
Returns :	`TRUE` if the quant matrix extension could be parsed correctly, `FALSE` otherwize.

			GStreamer Bad Plugins 0.11 Library Reference Manual
Top \| Description