From Shaun J

Dissectors for MPEG streams



git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@21114 f5534014-38df-0310-8fa8-9805f1628bb7

1 files changed, 1102 insertions, 0 deletions

diff --git a/epan/dissectors/packet-mpeg-pes.c b/epan/dissectors/packet-mpeg-pes.c
new file mode 100644
index 0000000000..752f7eea35
--- /dev/null
+++ b/epan/dissectors/packet-mpeg-pes.c
@@ -0,0 +1,1102 @@
+/* Do not modify this file.                                                   */
+/* It is created automatically by the ASN.1 to Wireshark dissector compiler   */
+/* ./packet-mpeg-pes.c                                                        */
+/* ../../tools/asn2wrs.py -e -p mpeg-pes -c mpeg-pes.cnf -s packet-mpeg-pes-template mpeg-pes.asn */
+
+/* Input file: packet-mpeg-pes-template.c */
+
+#line 1 "packet-mpeg-pes-template.c"
+/* MPEG Packetized Elementary Stream (PES) packet decoder.
+ * Written by Shaun Jackman <sjackman@gmail.com>.
+ * Copyright 2007 Shaun Jackman
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include <epan/packet.h>
+#include <epan/prefs.h>
+
+#include "packet-per.h"
+
+
+/*--- Included file: packet-mpeg-pes-hf.c ---*/
+#line 1 "packet-mpeg-pes-hf.c"
+static int hf_mpeg_pes_prefix = -1;               /* OCTET_STRING_SIZE_3 */
+static int hf_mpeg_pes_stream = -1;               /* T_stream */
+static int hf_mpeg_pes_must_be_zero = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_must_be_one0 = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_scr30 = -1;                /* BIT_STRING_SIZE_3 */
+static int hf_mpeg_pes_must_be_one1 = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_scr15 = -1;                /* BIT_STRING_SIZE_15 */
+static int hf_mpeg_pes_must_be_one2 = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_scr0 = -1;                 /* BIT_STRING_SIZE_15 */
+static int hf_mpeg_pes_must_be_one3 = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_scr_ext = -1;              /* BIT_STRING_SIZE_9 */
+static int hf_mpeg_pes_must_be_one4 = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_program_mux_rate = -1;     /* BIT_STRING_SIZE_22 */
+static int hf_mpeg_pes_must_be_one5 = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_must_be_one6 = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_reserved = -1;             /* BIT_STRING_SIZE_5 */
+static int hf_mpeg_pes_stuffing_length = -1;      /* INTEGER_0_7 */
+static int hf_mpeg_pes_length = -1;               /* INTEGER_0_65535 */
+static int hf_mpeg_pes_must_be_one = -1;          /* BOOLEAN */
+static int hf_mpeg_pes_scrambling_control = -1;   /* T_scrambling_control */
+static int hf_mpeg_pes_priority = -1;             /* BOOLEAN */
+static int hf_mpeg_pes_data_alignment = -1;       /* BOOLEAN */
+static int hf_mpeg_pes_copyright = -1;            /* BOOLEAN */
+static int hf_mpeg_pes_original = -1;             /* BOOLEAN */
+static int hf_mpeg_pes_pts_flag = -1;             /* BOOLEAN */
+static int hf_mpeg_pes_dts_flag = -1;             /* BOOLEAN */
+static int hf_mpeg_pes_escr_flag = -1;            /* BOOLEAN */
+static int hf_mpeg_pes_es_rate_flag = -1;         /* BOOLEAN */
+static int hf_mpeg_pes_dsm_trick_mode_flag = -1;  /* BOOLEAN */
+static int hf_mpeg_pes_additional_copy_info_flag = -1;  /* BOOLEAN */
+static int hf_mpeg_pes_crc_flag = -1;             /* BOOLEAN */
+static int hf_mpeg_pes_extension_flag = -1;       /* BOOLEAN */
+static int hf_mpeg_pes_header_data_length = -1;   /* INTEGER_0_255 */
+static int hf_mpeg_pes_horizontal_size = -1;      /* BIT_STRING_SIZE_12 */
+static int hf_mpeg_pes_vertical_size = -1;        /* BIT_STRING_SIZE_12 */
+static int hf_mpeg_pes_aspect_ratio = -1;         /* T_aspect_ratio */
+static int hf_mpeg_pes_frame_rate = -1;           /* T_frame_rate */
+static int hf_mpeg_pes_bit_rate = -1;             /* BIT_STRING_SIZE_18 */
+static int hf_mpeg_pes_vbv_buffer_size = -1;      /* BIT_STRING_SIZE_10 */
+static int hf_mpeg_pes_constrained_parameters_flag = -1;  /* BOOLEAN */
+static int hf_mpeg_pes_load_intra_quantiser_matrix = -1;  /* BOOLEAN */
+static int hf_mpeg_pes_load_non_intra_quantiser_matrix = -1;  /* BOOLEAN */
+static int hf_mpeg_pes_must_be_0001 = -1;         /* BIT_STRING_SIZE_4 */
+static int hf_mpeg_pes_profile_and_level = -1;    /* INTEGER_0_255 */
+static int hf_mpeg_pes_progressive_sequence = -1;  /* BOOLEAN */
+static int hf_mpeg_pes_chroma_format = -1;        /* INTEGER_0_3 */
+static int hf_mpeg_pes_horizontal_size_extension = -1;  /* INTEGER_0_3 */
+static int hf_mpeg_pes_vertical_size_extension = -1;  /* INTEGER_0_3 */
+static int hf_mpeg_pes_bit_rate_extension = -1;   /* BIT_STRING_SIZE_12 */
+static int hf_mpeg_pes_vbv_buffer_size_extension = -1;  /* INTEGER_0_255 */
+static int hf_mpeg_pes_low_delay = -1;            /* BOOLEAN */
+static int hf_mpeg_pes_frame_rate_extension_n = -1;  /* INTEGER_0_3 */
+static int hf_mpeg_pes_frame_rate_extension_d = -1;  /* INTEGER_0_3 */
+static int hf_mpeg_pes_drop_frame_flag = -1;      /* BOOLEAN */
+static int hf_mpeg_pes_hour = -1;                 /* INTEGER_0_32 */
+static int hf_mpeg_pes_minute = -1;               /* INTEGER_0_64 */
+static int hf_mpeg_pes_second = -1;               /* INTEGER_0_64 */
+static int hf_mpeg_pes_frame = -1;                /* INTEGER_0_64 */
+static int hf_mpeg_pes_closed_gop = -1;           /* BOOLEAN */
+static int hf_mpeg_pes_broken_gop = -1;           /* BOOLEAN */
+static int hf_mpeg_pes_must_be_zero1 = -1;        /* BIT_STRING_SIZE_5 */
+static int hf_mpeg_pes_temporal_sequence_number = -1;  /* BIT_STRING_SIZE_10 */
+static int hf_mpeg_pes_frame_type = -1;           /* T_frame_type */
+static int hf_mpeg_pes_vbv_delay = -1;            /* BIT_STRING_SIZE_16 */
+
+/*--- End of included file: packet-mpeg-pes-hf.c ---*/
+#line 40 "packet-mpeg-pes-template.c"
+
+/*--- Included file: packet-mpeg-pes-ett.c ---*/
+#line 1 "packet-mpeg-pes-ett.c"
+static gint ett_mpeg_pes_PES = -1;
+static gint ett_mpeg_pes_Pack = -1;
+static gint ett_mpeg_pes_Stream = -1;
+static gint ett_mpeg_pes_Sequence_header = -1;
+static gint ett_mpeg_pes_Sequence_extension = -1;
+static gint ett_mpeg_pes_Group_of_pictures = -1;
+static gint ett_mpeg_pes_Picture = -1;
+
+/*--- End of included file: packet-mpeg-pes-ett.c ---*/
+#line 41 "packet-mpeg-pes-template.c"
+
+/*--- Included file: packet-mpeg-pes-fn.c ---*/
+#line 1 "packet-mpeg-pes-fn.c"
+
+
+static int
+dissect_mpeg_pes_OCTET_STRING_SIZE_3(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_octet_string(tvb, offset, actx, tree, hf_index,
+                                       3, 3, NULL);
+
+  return offset;
+}
+
+
+static const value_string mpeg_pes_T_stream_vals[] = {
+  {   0, "picture" },
+  { 179, "sequence-header" },
+  { 181, "sequence-header-extension" },
+  { 184, "group-of-pictures" },
+  { 185, "program-end" },
+  { 186, "pack-header" },
+  { 187, "system-header" },
+  { 188, "program-stream-map" },
+  { 189, "private-stream-1" },
+  { 190, "padding-stream" },
+  { 191, "private-stream-2" },
+  { 192, "audio-stream" },
+  { 224, "video-stream" },
+  { 0, NULL }
+};
+
+
+static int
+dissect_mpeg_pes_T_stream(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 255U, NULL, FALSE);
+
+  return offset;
+}
+
+
+static const per_sequence_t PES_sequence[] = {
+  { &hf_mpeg_pes_prefix     , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_OCTET_STRING_SIZE_3 },
+  { &hf_mpeg_pes_stream     , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_T_stream },
+  { NULL, 0, 0, NULL }
+};
+
+static int
+dissect_mpeg_pes_PES(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_sequence(tvb, offset, actx, tree, hf_index,
+                                   ett_mpeg_pes_PES, PES_sequence);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BOOLEAN(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_boolean(tvb, offset, actx, tree, hf_index, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_3(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     3, 3, FALSE, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_15(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     15, 15, FALSE, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_9(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     9, 9, FALSE, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_22(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     22, 22, FALSE, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_5(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     5, 5, FALSE, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_INTEGER_0_7(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 7U, NULL, FALSE);
+
+  return offset;
+}
+
+
+static const per_sequence_t Pack_sequence[] = {
+  { &hf_mpeg_pes_must_be_zero, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_must_be_one0, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_scr30      , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_3 },
+  { &hf_mpeg_pes_must_be_one1, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_scr15      , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_15 },
+  { &hf_mpeg_pes_must_be_one2, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_scr0       , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_15 },
+  { &hf_mpeg_pes_must_be_one3, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_scr_ext    , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_9 },
+  { &hf_mpeg_pes_must_be_one4, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_program_mux_rate, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_22 },
+  { &hf_mpeg_pes_must_be_one5, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_must_be_one6, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_reserved   , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_5 },
+  { &hf_mpeg_pes_stuffing_length, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_7 },
+  { NULL, 0, 0, NULL }
+};
+
+static int
+dissect_mpeg_pes_Pack(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_sequence(tvb, offset, actx, tree, hf_index,
+                                   ett_mpeg_pes_Pack, Pack_sequence);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_INTEGER_0_65535(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 65535U, NULL, FALSE);
+
+  return offset;
+}
+
+
+static const value_string mpeg_pes_T_scrambling_control_vals[] = {
+  {   0, "not-scrambled" },
+  { 0, NULL }
+};
+
+
+static int
+dissect_mpeg_pes_T_scrambling_control(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 3U, NULL, FALSE);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_INTEGER_0_255(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 255U, NULL, FALSE);
+
+  return offset;
+}
+
+
+static const per_sequence_t Stream_sequence[] = {
+  { &hf_mpeg_pes_length     , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_65535 },
+  { &hf_mpeg_pes_must_be_one, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_must_be_zero, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_scrambling_control, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_T_scrambling_control },
+  { &hf_mpeg_pes_priority   , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_data_alignment, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_copyright  , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_original   , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_pts_flag   , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_dts_flag   , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_escr_flag  , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_es_rate_flag, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_dsm_trick_mode_flag, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_additional_copy_info_flag, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_crc_flag   , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_extension_flag, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_header_data_length, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_255 },
+  { NULL, 0, 0, NULL }
+};
+
+static int
+dissect_mpeg_pes_Stream(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_sequence(tvb, offset, actx, tree, hf_index,
+                                   ett_mpeg_pes_Stream, Stream_sequence);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_12(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     12, 12, FALSE, NULL);
+
+  return offset;
+}
+
+
+static const value_string mpeg_pes_T_aspect_ratio_vals[] = {
+  {   1, "aspect-1to1" },
+  {   2, "aspect-4to3" },
+  {   3, "aspect-16to9" },
+  {   4, "aspect-2-21to1" },
+  { 0, NULL }
+};
+
+
+static int
+dissect_mpeg_pes_T_aspect_ratio(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 15U, NULL, FALSE);
+
+  return offset;
+}
+
+
+static const value_string mpeg_pes_T_frame_rate_vals[] = {
+  {   0, "reserved" },
+  { 23976, "fr" },
+  { 24000, "fr" },
+  { 25000, "fr" },
+  { 29970, "fr" },
+  { 30000, "fr" },
+  { 50000, "fr" },
+  { 59940, "fr" },
+  { 60000, "fr" },
+  { 0, NULL }
+};
+
+static guint32 T_frame_rate_value_map[9+0] = {0, 23976, 24000, 25000, 29970, 30000, 50000, 59940, 60000};
+
+static int
+dissect_mpeg_pes_T_frame_rate(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_enumerated(tvb, offset, actx, tree, hf_index,
+                                     9, NULL, FALSE, 0, T_frame_rate_value_map);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_18(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     18, 18, FALSE, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_10(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     10, 10, FALSE, NULL);
+
+  return offset;
+}
+
+
+static const per_sequence_t Sequence_header_sequence[] = {
+  { &hf_mpeg_pes_horizontal_size, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_12 },
+  { &hf_mpeg_pes_vertical_size, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_12 },
+  { &hf_mpeg_pes_aspect_ratio, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_T_aspect_ratio },
+  { &hf_mpeg_pes_frame_rate , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_T_frame_rate },
+  { &hf_mpeg_pes_bit_rate   , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_18 },
+  { &hf_mpeg_pes_must_be_one, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_vbv_buffer_size, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_10 },
+  { &hf_mpeg_pes_constrained_parameters_flag, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_load_intra_quantiser_matrix, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_load_non_intra_quantiser_matrix, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { NULL, 0, 0, NULL }
+};
+
+static int
+dissect_mpeg_pes_Sequence_header(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_sequence(tvb, offset, actx, tree, hf_index,
+                                   ett_mpeg_pes_Sequence_header, Sequence_header_sequence);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_4(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     4, 4, FALSE, NULL);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_INTEGER_0_3(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 3U, NULL, FALSE);
+
+  return offset;
+}
+
+
+static const per_sequence_t Sequence_extension_sequence[] = {
+  { &hf_mpeg_pes_must_be_0001, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_4 },
+  { &hf_mpeg_pes_profile_and_level, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_255 },
+  { &hf_mpeg_pes_progressive_sequence, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_chroma_format, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_3 },
+  { &hf_mpeg_pes_horizontal_size_extension, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_3 },
+  { &hf_mpeg_pes_vertical_size_extension, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_3 },
+  { &hf_mpeg_pes_bit_rate_extension, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_12 },
+  { &hf_mpeg_pes_must_be_one, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_vbv_buffer_size_extension, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_255 },
+  { &hf_mpeg_pes_low_delay  , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_frame_rate_extension_n, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_3 },
+  { &hf_mpeg_pes_frame_rate_extension_d, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_3 },
+  { NULL, 0, 0, NULL }
+};
+
+static int
+dissect_mpeg_pes_Sequence_extension(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_sequence(tvb, offset, actx, tree, hf_index,
+                                   ett_mpeg_pes_Sequence_extension, Sequence_extension_sequence);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_INTEGER_0_32(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 32U, NULL, FALSE);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_INTEGER_0_64(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 64U, NULL, FALSE);
+
+  return offset;
+}
+
+
+static const per_sequence_t Group_of_pictures_sequence[] = {
+  { &hf_mpeg_pes_drop_frame_flag, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_hour       , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_32 },
+  { &hf_mpeg_pes_minute     , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_64 },
+  { &hf_mpeg_pes_must_be_one, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_second     , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_64 },
+  { &hf_mpeg_pes_frame      , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_INTEGER_0_64 },
+  { &hf_mpeg_pes_closed_gop , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_broken_gop , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BOOLEAN },
+  { &hf_mpeg_pes_must_be_zero1, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_5 },
+  { NULL, 0, 0, NULL }
+};
+
+static int
+dissect_mpeg_pes_Group_of_pictures(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_sequence(tvb, offset, actx, tree, hf_index,
+                                   ett_mpeg_pes_Group_of_pictures, Group_of_pictures_sequence);
+
+  return offset;
+}
+
+
+static const value_string mpeg_pes_T_frame_type_vals[] = {
+  {   1, "i-frame" },
+  {   2, "p-frame" },
+  {   3, "b-frame" },
+  {   4, "d-frame" },
+  { 0, NULL }
+};
+
+
+static int
+dissect_mpeg_pes_T_frame_type(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_constrained_integer(tvb, offset, actx, tree, hf_index,
+                                              0U, 7U, NULL, FALSE);
+
+  return offset;
+}
+
+
+
+static int
+dissect_mpeg_pes_BIT_STRING_SIZE_16(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index,
+                                     16, 16, FALSE, NULL);
+
+  return offset;
+}
+
+
+static const per_sequence_t Picture_sequence[] = {
+  { &hf_mpeg_pes_temporal_sequence_number, ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_10 },
+  { &hf_mpeg_pes_frame_type , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_T_frame_type },
+  { &hf_mpeg_pes_vbv_delay  , ASN1_NO_EXTENSIONS     , ASN1_NOT_OPTIONAL, dissect_mpeg_pes_BIT_STRING_SIZE_16 },
+  { NULL, 0, 0, NULL }
+};
+
+static int
+dissect_mpeg_pes_Picture(tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
+  offset = dissect_per_sequence(tvb, offset, actx, tree, hf_index,
+                                   ett_mpeg_pes_Picture, Picture_sequence);
+
+  return offset;
+}
+
+
+/*--- End of included file: packet-mpeg-pes-fn.c ---*/
+#line 42 "packet-mpeg-pes-template.c"
+
+static int proto_mpeg = -1;
+static int proto_mpeg_pes = -1;
+static int hf_mpeg_pes_pack_header = -1;
+static int hf_mpeg_pes_stuffing = -1;
+static int hf_mpeg_pes_extension = -1;
+static int hf_mpeg_pes_header_data = -1;
+static int hf_mpeg_pes_padding = -1;
+
+static int hf_mpeg_pes_data = -1;
+
+static int hf_mpeg_video_sequence_header = -1;
+static int hf_mpeg_video_sequence_extension = -1;
+static int hf_mpeg_video_group_of_pictures = -1;
+static int hf_mpeg_video_picture = -1;
+static int hf_mpeg_video_quantization_matrix = -1;
+static int hf_mpeg_video_data = -1;
+
+enum { PES_PREFIX = 1 };
+enum {
+	STREAM_PICTURE = 0x00,
+	STREAM_SEQUENCE = 0xb3,
+	STREAM_SEQUENCE_EXTENSION = 0xb5,
+	STREAM_GOP = 0xb8,
+	STREAM_END = 0xb9,
+	STREAM_PACK = 0xba,
+	STREAM_SYSTEM = 0xbb,
+	STREAM_PROGRAM = 0xbc,
+	STREAM_PRIVATE1 = 0xbd,
+	STREAM_PADDING = 0xbe,
+	STREAM_PRIVATE2 = 0xbf,
+	STREAM_AUDIO = 0xc0,
+	STREAM_VIDEO = 0xe0,
+};
+
+void
+dissect_mpeg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
+
+static gboolean
+dissect_mpeg_pes(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+	int prefix;
+	int stream;
+	asn1_ctx_t asn1_ctx;
+	int offset = 0;
+
+	prefix = tvb_get_ntoh24(tvb, 0);
+	if (prefix != PES_PREFIX)
+		return FALSE;
+	if (check_col(pinfo->cinfo, COL_PROTOCOL))
+		col_set_str(pinfo->cinfo, COL_PROTOCOL, "MPEG PES");
+
+	stream = tvb_get_guint8(tvb, 3);
+	if (check_col(pinfo->cinfo, COL_INFO)) {
+		const char *s = match_strval(stream, mpeg_pes_T_stream_vals);
+		if (s != NULL)
+			col_set_str(pinfo->cinfo, COL_INFO, s);
+	}
+
+#if 0
+	if (tree == NULL)
+		return TRUE;
+#endif
+	asn1_ctx_init(&asn1_ctx, ASN1_ENC_PER, TRUE, pinfo);
+	offset = dissect_mpeg_pes_PES(tvb, offset, &asn1_ctx,
+			tree, proto_mpeg_pes);
+
+	if (stream == STREAM_PICTURE) {
+		int frame_type;
+
+		frame_type = tvb_get_guint8(tvb, 5) >> 3 & 0x07;
+		if (check_col(pinfo->cinfo, COL_INFO)) {
+			const char *s = match_strval(frame_type,
+					mpeg_pes_T_frame_type_vals);
+			if (s != NULL)
+				col_set_str(pinfo->cinfo, COL_INFO, s);
+		}
+
+		offset = dissect_mpeg_pes_Picture(tvb, offset, &asn1_ctx,
+				tree, hf_mpeg_video_picture);
+		proto_tree_add_item(tree, hf_mpeg_video_data, tvb,
+				offset / 8, -1, FALSE);
+	} else if (stream == STREAM_SEQUENCE) {
+		tvbuff_t *es;
+
+		offset = dissect_mpeg_pes_Sequence_header(tvb, offset, &asn1_ctx,
+				tree, hf_mpeg_video_sequence_header);
+
+		proto_tree_add_item(tree, hf_mpeg_video_quantization_matrix, tvb,
+				offset / 8, 64, FALSE);
+		offset += 64 * 8;
+
+		es = tvb_new_subset(tvb, offset / 8, -1, -1);
+		dissect_mpeg_pes(es, pinfo, tree);
+	} else if (stream == STREAM_SEQUENCE_EXTENSION) {
+		tvbuff_t *es;
+
+		offset = dissect_mpeg_pes_Sequence_extension(tvb, offset, &asn1_ctx,
+				tree, hf_mpeg_video_sequence_extension);
+
+		es = tvb_new_subset(tvb, offset / 8, -1, -1);
+		dissect_mpeg_pes(es, pinfo, tree);
+	} else if (stream == STREAM_GOP) {
+		tvbuff_t *es;
+
+		offset = dissect_mpeg_pes_Group_of_pictures(tvb, offset, &asn1_ctx,
+				tree, hf_mpeg_video_group_of_pictures);
+
+		es = tvb_new_subset(tvb, offset / 8, -1, -1);
+		dissect_mpeg_pes(es, pinfo, tree);
+	} else if (stream == STREAM_PACK) {
+		int length;
+		switch (tvb_get_guint8(tvb, 4) >> 6) {
+			case 1:
+				length = tvb_get_guint8(tvb, 13) & 0x07;
+				offset = dissect_mpeg_pes_Pack(tvb, offset, &asn1_ctx,
+						tree, hf_mpeg_pes_pack_header);
+				if (length > 0)
+					proto_tree_add_item(tree, hf_mpeg_pes_stuffing, tvb,
+							offset / 8, length, FALSE);
+				break;
+			default:
+				length = 8;
+				proto_tree_add_item(tree, hf_mpeg_pes_data, tvb,
+						offset / 8, length, FALSE);
+		}
+		offset += length * 8;
+	} else if (stream == STREAM_SYSTEM) {
+		offset = dissect_mpeg_pes_Stream(tvb, offset, &asn1_ctx,
+				tree, hf_mpeg_pes_extension);
+		proto_tree_add_item(tree, hf_mpeg_pes_data, tvb,
+				offset / 8, -1, FALSE);
+	} else if (stream == STREAM_PADDING) {
+		int padding_length;
+
+		padding_length = tvb_get_ntohs(tvb, 4);
+		proto_tree_add_item(tree, hf_mpeg_pes_length, tvb,
+				offset / 8, 2, FALSE);
+		offset += 2 * 8;
+
+		proto_tree_add_item(tree, hf_mpeg_pes_padding, tvb,
+				offset / 8, padding_length, FALSE);
+	} else if (stream == STREAM_PRIVATE1
+			|| stream >= STREAM_AUDIO) {
+		int length;
+		int header_length;
+		tvbuff_t *es;
+
+		length = tvb_get_ntohs(tvb, 4);
+
+		offset = dissect_mpeg_pes_Stream(tvb, offset, &asn1_ctx,
+				tree, hf_mpeg_pes_extension);
+		length -= 5 * 8;
+
+		header_length = tvb_get_guint8(tvb, 8);
+		if (header_length > 0) {
+			proto_tree_add_item(tree, hf_mpeg_pes_header_data, tvb,
+					offset / 8, header_length, FALSE);
+			offset += header_length * 8;
+			length -= header_length * 8;
+		}
+
+		es = tvb_new_subset(tvb, offset / 8, -1, length / 8);
+		if (tvb_get_ntoh24(es, 0) == PES_PREFIX)
+			dissect_mpeg_pes(es, pinfo, tree);
+		else if (tvb_get_guint8(es, 0) == 0xff)
+			dissect_mpeg(es, pinfo, tree);
+		else
+			proto_tree_add_item(tree, hf_mpeg_pes_data, es,
+					0, -1, FALSE);
+	} else {
+		proto_tree_add_item(tree, hf_mpeg_pes_data, tvb,
+				offset / 8, -1, FALSE);
+	}
+	return TRUE;
+}
+
+static heur_dissector_list_t heur_subdissector_list;
+
+void
+dissect_mpeg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+    dissector_try_heuristic(heur_subdissector_list, tvb, pinfo, tree);
+}
+
+void
+proto_register_mpeg_pes(void)
+{
+	static hf_register_info hf[] = {
+
+/*--- Included file: packet-mpeg-pes-hfarr.c ---*/
+#line 1 "packet-mpeg-pes-hfarr.c"
+    { &hf_mpeg_pes_prefix,
+      { "prefix", "mpeg-pes.prefix",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.OCTET_STRING_SIZE_3", HFILL }},
+    { &hf_mpeg_pes_stream,
+      { "stream", "mpeg-pes.stream",
+        FT_UINT8, BASE_HEX, VALS(mpeg_pes_T_stream_vals), 0,
+        "mpeg_pes.T_stream", HFILL }},
+    { &hf_mpeg_pes_must_be_zero,
+      { "must-be-zero", "mpeg-pes.must_be_zero",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_must_be_one0,
+      { "must-be-one0", "mpeg-pes.must_be_one0",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_scr30,
+      { "scr30", "mpeg-pes.scr30",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_3", HFILL }},
+    { &hf_mpeg_pes_must_be_one1,
+      { "must-be-one1", "mpeg-pes.must_be_one1",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_scr15,
+      { "scr15", "mpeg-pes.scr15",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_15", HFILL }},
+    { &hf_mpeg_pes_must_be_one2,
+      { "must-be-one2", "mpeg-pes.must_be_one2",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_scr0,
+      { "scr0", "mpeg-pes.scr0",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_15", HFILL }},
+    { &hf_mpeg_pes_must_be_one3,
+      { "must-be-one3", "mpeg-pes.must_be_one3",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_scr_ext,
+      { "scr-ext", "mpeg-pes.scr_ext",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_9", HFILL }},
+    { &hf_mpeg_pes_must_be_one4,
+      { "must-be-one4", "mpeg-pes.must_be_one4",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_program_mux_rate,
+      { "program-mux-rate", "mpeg-pes.program_mux_rate",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_22", HFILL }},
+    { &hf_mpeg_pes_must_be_one5,
+      { "must-be-one5", "mpeg-pes.must_be_one5",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_must_be_one6,
+      { "must-be-one6", "mpeg-pes.must_be_one6",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_reserved,
+      { "reserved", "mpeg-pes.reserved",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_5", HFILL }},
+    { &hf_mpeg_pes_stuffing_length,
+      { "stuffing-length", "mpeg-pes.stuffing_length",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_7", HFILL }},
+    { &hf_mpeg_pes_length,
+      { "length", "mpeg-pes.length",
+        FT_UINT16, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_65535", HFILL }},
+    { &hf_mpeg_pes_must_be_one,
+      { "must-be-one", "mpeg-pes.must_be_one",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_scrambling_control,
+      { "scrambling-control", "mpeg-pes.scrambling_control",
+        FT_UINT32, BASE_DEC, VALS(mpeg_pes_T_scrambling_control_vals), 0,
+        "mpeg_pes.T_scrambling_control", HFILL }},
+    { &hf_mpeg_pes_priority,
+      { "priority", "mpeg-pes.priority",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_data_alignment,
+      { "data-alignment", "mpeg-pes.data_alignment",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_copyright,
+      { "copyright", "mpeg-pes.copyright",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_original,
+      { "original", "mpeg-pes.original",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_pts_flag,
+      { "pts-flag", "mpeg-pes.pts_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_dts_flag,
+      { "dts-flag", "mpeg-pes.dts_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_escr_flag,
+      { "escr-flag", "mpeg-pes.escr_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_es_rate_flag,
+      { "es-rate-flag", "mpeg-pes.es_rate_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_dsm_trick_mode_flag,
+      { "dsm-trick-mode-flag", "mpeg-pes.dsm_trick_mode_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_additional_copy_info_flag,
+      { "additional-copy-info-flag", "mpeg-pes.additional_copy_info_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_crc_flag,
+      { "crc-flag", "mpeg-pes.crc_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_extension_flag,
+      { "extension-flag", "mpeg-pes.extension_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_header_data_length,
+      { "header-data-length", "mpeg-pes.header_data_length",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_255", HFILL }},
+    { &hf_mpeg_pes_horizontal_size,
+      { "horizontal-size", "mpeg-pes.horizontal_size",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_12", HFILL }},
+    { &hf_mpeg_pes_vertical_size,
+      { "vertical-size", "mpeg-pes.vertical_size",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_12", HFILL }},
+    { &hf_mpeg_pes_aspect_ratio,
+      { "aspect-ratio", "mpeg-pes.aspect_ratio",
+        FT_UINT32, BASE_DEC, VALS(mpeg_pes_T_aspect_ratio_vals), 0,
+        "mpeg_pes.T_aspect_ratio", HFILL }},
+    { &hf_mpeg_pes_frame_rate,
+      { "frame-rate", "mpeg-pes.frame_rate",
+        FT_UINT32, BASE_DEC, VALS(mpeg_pes_T_frame_rate_vals), 0,
+        "mpeg_pes.T_frame_rate", HFILL }},
+    { &hf_mpeg_pes_bit_rate,
+      { "bit-rate", "mpeg-pes.bit_rate",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_18", HFILL }},
+    { &hf_mpeg_pes_vbv_buffer_size,
+      { "vbv-buffer-size", "mpeg-pes.vbv_buffer_size",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_10", HFILL }},
+    { &hf_mpeg_pes_constrained_parameters_flag,
+      { "constrained-parameters-flag", "mpeg-pes.constrained_parameters_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_load_intra_quantiser_matrix,
+      { "load-intra-quantiser-matrix", "mpeg-pes.load_intra_quantiser_matrix",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_load_non_intra_quantiser_matrix,
+      { "load-non-intra-quantiser-matrix", "mpeg-pes.load_non_intra_quantiser_matrix",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_must_be_0001,
+      { "must-be-0001", "mpeg-pes.must_be_0001",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_4", HFILL }},
+    { &hf_mpeg_pes_profile_and_level,
+      { "profile-and-level", "mpeg-pes.profile_and_level",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_255", HFILL }},
+    { &hf_mpeg_pes_progressive_sequence,
+      { "progressive-sequence", "mpeg-pes.progressive_sequence",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_chroma_format,
+      { "chroma-format", "mpeg-pes.chroma_format",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_3", HFILL }},
+    { &hf_mpeg_pes_horizontal_size_extension,
+      { "horizontal-size-extension", "mpeg-pes.horizontal_size_extension",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_3", HFILL }},
+    { &hf_mpeg_pes_vertical_size_extension,
+      { "vertical-size-extension", "mpeg-pes.vertical_size_extension",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_3", HFILL }},
+    { &hf_mpeg_pes_bit_rate_extension,
+      { "bit-rate-extension", "mpeg-pes.bit_rate_extension",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_12", HFILL }},
+    { &hf_mpeg_pes_vbv_buffer_size_extension,
+      { "vbv-buffer-size-extension", "mpeg-pes.vbv_buffer_size_extension",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_255", HFILL }},
+    { &hf_mpeg_pes_low_delay,
+      { "low-delay", "mpeg-pes.low_delay",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_frame_rate_extension_n,
+      { "frame-rate-extension-n", "mpeg-pes.frame_rate_extension_n",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_3", HFILL }},
+    { &hf_mpeg_pes_frame_rate_extension_d,
+      { "frame-rate-extension-d", "mpeg-pes.frame_rate_extension_d",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_3", HFILL }},
+    { &hf_mpeg_pes_drop_frame_flag,
+      { "drop-frame-flag", "mpeg-pes.drop_frame_flag",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_hour,
+      { "hour", "mpeg-pes.hour",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_32", HFILL }},
+    { &hf_mpeg_pes_minute,
+      { "minute", "mpeg-pes.minute",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_64", HFILL }},
+    { &hf_mpeg_pes_second,
+      { "second", "mpeg-pes.second",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_64", HFILL }},
+    { &hf_mpeg_pes_frame,
+      { "frame", "mpeg-pes.frame",
+        FT_UINT32, BASE_DEC, NULL, 0,
+        "mpeg_pes.INTEGER_0_64", HFILL }},
+    { &hf_mpeg_pes_closed_gop,
+      { "closed-gop", "mpeg-pes.closed_gop",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_broken_gop,
+      { "broken-gop", "mpeg-pes.broken_gop",
+        FT_BOOLEAN, 8, NULL, 0,
+        "mpeg_pes.BOOLEAN", HFILL }},
+    { &hf_mpeg_pes_must_be_zero1,
+      { "must-be-zero", "mpeg-pes.must_be_zero",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_5", HFILL }},
+    { &hf_mpeg_pes_temporal_sequence_number,
+      { "temporal-sequence-number", "mpeg-pes.temporal_sequence_number",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_10", HFILL }},
+    { &hf_mpeg_pes_frame_type,
+      { "frame-type", "mpeg-pes.frame_type",
+        FT_UINT32, BASE_DEC, VALS(mpeg_pes_T_frame_type_vals), 0,
+        "mpeg_pes.T_frame_type", HFILL }},
+    { &hf_mpeg_pes_vbv_delay,
+      { "vbv-delay", "mpeg-pes.vbv_delay",
+        FT_BYTES, BASE_HEX, NULL, 0,
+        "mpeg_pes.BIT_STRING_SIZE_16", HFILL }},
+
+/*--- End of included file: packet-mpeg-pes-hfarr.c ---*/
+#line 232 "packet-mpeg-pes-template.c"
+		{ &hf_mpeg_pes_pack_header,
+			{ "Pack header", "mpeg-pes.pack",
+				FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_pes_stuffing,
+			{ "PES stuffing bytes", "mpeg-pes.stuffing",
+				FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_pes_extension,
+			{ "PES extension", "mpeg-pes.extension",
+				FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_pes_header_data,
+			{ "PES header data", "mpeg-pes.header-data",
+				FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_pes_padding,
+			{ "PES padding", "mpeg-pes.padding",
+				FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_pes_data,
+			{ "PES data", "mpeg-pes.data",
+				FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_video_sequence_header,
+			{ "MPEG sequence header", "mpeg-video.sequence",
+				FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_video_sequence_extension,
+			{ "MPEG sequence extension", "mpeg-video.sequence-ext",
+				FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_video_group_of_pictures,
+			{ "MPEG group of pictures", "mpeg-video.gop",
+				FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_video_picture,
+			{ "MPEG picture", "mpeg-video.picture",
+				FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_video_quantization_matrix,
+			{ "MPEG quantization matrix", "mpeg-video.quant",
+				FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
+		{ &hf_mpeg_video_data,
+			{ "MPEG picture data", "mpeg-video.data",
+				FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
+	};
+
+	static gint *ett[] = {
+
+/*--- Included file: packet-mpeg-pes-ettarr.c ---*/
+#line 1 "packet-mpeg-pes-ettarr.c"
+    &ett_mpeg_pes_PES,
+    &ett_mpeg_pes_Pack,
+    &ett_mpeg_pes_Stream,
+    &ett_mpeg_pes_Sequence_header,
+    &ett_mpeg_pes_Sequence_extension,
+    &ett_mpeg_pes_Group_of_pictures,
+    &ett_mpeg_pes_Picture,
+
+/*--- End of included file: packet-mpeg-pes-ettarr.c ---*/
+#line 272 "packet-mpeg-pes-template.c"
+	};
+
+	proto_mpeg = proto_register_protocol(
+			"Moving Picture Experts Group", "MPEG", "mpeg");
+	register_heur_dissector_list("mpeg", &heur_subdissector_list);
+
+	if (proto_mpeg_pes != -1)
+		return;
+
+	proto_mpeg_pes = proto_register_protocol(
+			"Packetized Elementary Stream", "MPEG PES", "mpeg-pes");
+	proto_register_field_array(proto_mpeg_pes, hf, array_length(hf));
+	proto_register_subtree_array(ett, array_length(ett));
+}
+
+void
+proto_reg_handoff_mpeg_pes(void)
+{
+	dissector_handle_t mpeg_handle = create_dissector_handle(
+			dissect_mpeg, proto_mpeg);
+	dissector_add("wtap_encap", WTAP_ENCAP_MPEG, mpeg_handle);
+
+	heur_dissector_add("mpeg", dissect_mpeg_pes, proto_mpeg_pes);
+}