From e6c86a500d6e09439a54a82e2cfa2af9f13c5228 Mon Sep 17 00:00:00 2001 From: Zaheer Abbas Merali Date: Mon, 20 Aug 2007 14:23:45 +0000 Subject: Add mpeg transport stream parser written by: Original commit message from CVS: * configure.ac: * gst/mpegtsparse/Makefile.am: * gst/mpegtsparse/flutspatinfo.c: * gst/mpegtsparse/flutspatinfo.h: * gst/mpegtsparse/flutspmtinfo.c: * gst/mpegtsparse/flutspmtinfo.h: * gst/mpegtsparse/flutspmtstreaminfo.c: * gst/mpegtsparse/flutspmtstreaminfo.h: * gst/mpegtsparse/mpegtspacketizer.c: * gst/mpegtsparse/mpegtspacketizer.h: * gst/mpegtsparse/mpegtsparse.c: * gst/mpegtsparse/mpegtsparse.h: * gst/mpegtsparse/mpegtsparsemarshal.list: Add mpeg transport stream parser written by: Alessandro Decina. Includes a couple of files from the Fluendo transport stream demuxer that Fluendo have kindly allowed to be licenced under LGPL also. --- ChangeLog | 20 + common | 2 +- configure.ac | 2 + gst/mpegtsparse/Makefile.am | 38 ++ gst/mpegtsparse/flutspatinfo.c | 116 ++++ gst/mpegtsparse/flutspatinfo.h | 49 ++ gst/mpegtsparse/flutspmtinfo.c | 197 +++++++ gst/mpegtsparse/flutspmtinfo.h | 58 ++ gst/mpegtsparse/flutspmtstreaminfo.c | 181 ++++++ gst/mpegtsparse/flutspmtstreaminfo.h | 55 ++ gst/mpegtsparse/mpegtspacketizer.c | 619 ++++++++++++++++++++ gst/mpegtsparse/mpegtspacketizer.h | 107 ++++ gst/mpegtsparse/mpegtsparse.c | 970 ++++++++++++++++++++++++++++++++ gst/mpegtsparse/mpegtsparse.h | 77 +++ gst/mpegtsparse/mpegtsparsemarshal.list | 1 + 15 files changed, 2491 insertions(+), 1 deletion(-) create mode 100644 gst/mpegtsparse/Makefile.am create mode 100644 gst/mpegtsparse/flutspatinfo.c create mode 100644 gst/mpegtsparse/flutspatinfo.h create mode 100644 gst/mpegtsparse/flutspmtinfo.c create mode 100644 gst/mpegtsparse/flutspmtinfo.h create mode 100644 gst/mpegtsparse/flutspmtstreaminfo.c create mode 100644 gst/mpegtsparse/flutspmtstreaminfo.h create mode 100644 gst/mpegtsparse/mpegtspacketizer.c create mode 100644 gst/mpegtsparse/mpegtspacketizer.h create mode 100644 gst/mpegtsparse/mpegtsparse.c create mode 100644 gst/mpegtsparse/mpegtsparse.h create mode 100644 gst/mpegtsparse/mpegtsparsemarshal.list diff --git a/ChangeLog b/ChangeLog index 1d425ee7..d3051ec5 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,23 @@ +2007-08-20 Zaheer Abbas Merali + + * configure.ac: + * gst/mpegtsparse/Makefile.am: + * gst/mpegtsparse/flutspatinfo.c: + * gst/mpegtsparse/flutspatinfo.h: + * gst/mpegtsparse/flutspmtinfo.c: + * gst/mpegtsparse/flutspmtinfo.h: + * gst/mpegtsparse/flutspmtstreaminfo.c: + * gst/mpegtsparse/flutspmtstreaminfo.h: + * gst/mpegtsparse/mpegtspacketizer.c: + * gst/mpegtsparse/mpegtspacketizer.h: + * gst/mpegtsparse/mpegtsparse.c: + * gst/mpegtsparse/mpegtsparse.h: + * gst/mpegtsparse/mpegtsparsemarshal.list: + Add mpeg transport stream parser written by: + Alessandro Decina. Includes a couple of files from the + Fluendo transport stream demuxer that Fluendo have + kindly allowed to be licenced under LGPL also. + 2007-08-20 Tim-Philipp Müller Patch by: Bastien Nocera diff --git a/common b/common index b3fe2a25..9c7f1a63 160000 --- a/common +++ b/common @@ -1 +1 @@ -Subproject commit b3fe2a25c1cd0f4b021795d0db7330aeb338da7c +Subproject commit 9c7f1a63dfed1b2770b5fdaa16e0ae114b2177cf diff --git a/configure.ac b/configure.ac index a0f3bbc3..1005371e 100644 --- a/configure.ac +++ b/configure.ac @@ -91,6 +91,7 @@ GST_PLUGINS_ALL="\ interleave \ librfb \ modplug \ + mpegtsparse \ mpegvideoparse \ multifile \ mve \ @@ -989,6 +990,7 @@ gst/interleave/Makefile gst/librfb/Makefile gst/modplug/Makefile gst/modplug/libmodplug/Makefile +gst/mpegtsparse/Makefile gst/mpegvideoparse/Makefile gst/multifile/Makefile gst/mve/Makefile diff --git a/gst/mpegtsparse/Makefile.am b/gst/mpegtsparse/Makefile.am new file mode 100644 index 00000000..3324a32b --- /dev/null +++ b/gst/mpegtsparse/Makefile.am @@ -0,0 +1,38 @@ +plugin_LTLIBRARIES = libgstmpegtsparse.la + +libgstmpegtsparse_la_SOURCES = \ + mpegtsparse.c \ + mpegtspacketizer.c\ + mpegtsparsemarshal.c \ + flutspatinfo.c \ + flutspmtinfo.c \ + flutspmtstreaminfo.c + +BUILT_SOURCES = \ + mpegtsparsemarshal.h \ + mpegtsparsemarshal.c +CLEANFILES = $(BUILT_SOURCES) + +EXTRA_libgstmpegtsparse_la_SOURCES = \ + mpegtsparsemarshal.list + +mpegtsparsemarshal.h: mpegtsparsemarshal.list + glib-genmarshal --header --prefix=mpegts_parse_marshal $(srcdir)/mpegtsparsemarshal.list > mpegtsparsemarshal.h.tmp + mv mpegtsparsemarshal.h.tmp mpegtsparsemarshal.h + +mpegtsparsemarshal.c: mpegtsparsemarshal.list mpegtsparsemarshal.h + echo "#include \"mpegtsparsemarshal.h\"" >> mpegtsparsemarshal.c.tmp + glib-genmarshal --body --prefix=mpegts_parse_marshal $(srcdir)/mpegtsparsemarshal.list >> mpegtsparsemarshal.c.tmp + mv mpegtsparsemarshal.c.tmp mpegtsparsemarshal.c + +libgstmpegtsparse_la_CFLAGS = $(GST_CFLAGS) +libgstmpegtsparse_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS) +libgstmpegtsparse_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + +noinst_HEADERS = \ + mpegtsparse.h \ + mpegtsparsemarshal.h \ + mpegtspacketizer.h \ + flutspatinfo.h \ + flutspmtinfo.h \ + flutspmtstreaminfo.h diff --git a/gst/mpegtsparse/flutspatinfo.c b/gst/mpegtsparse/flutspatinfo.c new file mode 100644 index 00000000..47da4315 --- /dev/null +++ b/gst/mpegtsparse/flutspatinfo.c @@ -0,0 +1,116 @@ +/* + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the + * License for the specific language governing rights and limitations + * under the License. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "flutspatinfo.h" + +enum +{ + PROP_0, + PROP_PROGRAM_NO, + PROP_PID +}; + +static void mpegts_pat_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec); +static void mpegts_pat_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec); + +GST_BOILERPLATE (MpegTSPatInfo, mpegts_pat_info, GObject, G_TYPE_OBJECT); + +MpegTSPatInfo * +mpegts_pat_info_new (guint16 program_no, guint16 pid) +{ + MpegTSPatInfo *info; + + info = g_object_new (MPEGTS_TYPE_PAT_INFO, NULL); + + info->program_no = program_no; + info->pid = pid; + + return info; +} + +static void +mpegts_pat_info_base_init (gpointer klass) +{ +} + +static void +mpegts_pat_info_class_init (MpegTSPatInfoClass * klass) +{ + GObjectClass *gobject_klass = (GObjectClass *) klass; + + gobject_klass->set_property = mpegts_pat_info_set_property; + gobject_klass->get_property = mpegts_pat_info_get_property; + + g_object_class_install_property (gobject_klass, PROP_PROGRAM_NO, + g_param_spec_uint ("program-number", "Program Number", + "Program Number for this program", 0, G_MAXUINT16, 1, + G_PARAM_READABLE)); + + g_object_class_install_property (gobject_klass, PROP_PID, + g_param_spec_uint ("pid", "PID carrying PMT", + "PID which carries the PMT for this program", 1, G_MAXUINT16, 1, + G_PARAM_READABLE)); +} + +static void +mpegts_pat_info_init (MpegTSPatInfo * pat_info, MpegTSPatInfoClass * klass) +{ +} + +static void +mpegts_pat_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec) +{ + g_return_if_fail (MPEGTS_IS_PAT_INFO (object)); + + /* No settable properties */ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); +} + +static void +mpegts_pat_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec) +{ + MpegTSPatInfo *pat_info; + + g_return_if_fail (MPEGTS_IS_PAT_INFO (object)); + + pat_info = MPEGTS_PAT_INFO (object); + + switch (prop_id) { + case PROP_PROGRAM_NO: + g_value_set_uint (value, pat_info->program_no); + break; + case PROP_PID: + g_value_set_uint (value, pat_info->pid); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); + break; + } +} diff --git a/gst/mpegtsparse/flutspatinfo.h b/gst/mpegtsparse/flutspatinfo.h new file mode 100644 index 00000000..5f375d4c --- /dev/null +++ b/gst/mpegtsparse/flutspatinfo.h @@ -0,0 +1,49 @@ +/* + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the + * License for the specific language governing rights and limitations + * under the License. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifndef __MPEGTS_PAT_INFO_H__ +#define __MPEGTS_PAT_INFO_H__ + +#include + +G_BEGIN_DECLS + +typedef struct MpegTSPatInfoClass { + GObjectClass parent_class; +} MpegTSPatInfoClass; + +typedef struct MpegTSPatInfo { + GObject parent; + + guint16 pid; + guint16 program_no; +} MpegTSPatInfo; + +#define MPEGTS_TYPE_PAT_INFO (mpegts_pat_info_get_type ()) +#define MPEGTS_IS_PAT_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MPEGTS_TYPE_PAT_INFO)) +#define MPEGTS_PAT_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MPEGTS_TYPE_PAT_INFO, MpegTSPatInfo)) + +GType mpegts_pat_info_get_type (void); + +MpegTSPatInfo *mpegts_pat_info_new (guint16 program_no, guint16 pid); + +G_END_DECLS + +#endif diff --git a/gst/mpegtsparse/flutspmtinfo.c b/gst/mpegtsparse/flutspmtinfo.c new file mode 100644 index 00000000..96df0a2c --- /dev/null +++ b/gst/mpegtsparse/flutspmtinfo.c @@ -0,0 +1,197 @@ +/* + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the + * License for the specific language governing rights and limitations + * under the License. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "flutspmtinfo.h" + +enum +{ + PROP_0, + PROP_PROGRAM_NO, + PROP_VERSION_NO, + PROP_PCR_PID, + PROP_DESCRIPTORS, + PROP_STREAMINFO +}; + +GST_BOILERPLATE (MpegTSPmtInfo, mpegts_pmt_info, GObject, G_TYPE_OBJECT); + +static void mpegts_pmt_info_finalize (GObject * object); +static void mpegts_pmt_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec); +static void mpegts_pmt_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec); + +static void +mpegts_pmt_info_base_init (gpointer klass) +{ +} + +static void +mpegts_pmt_info_class_init (MpegTSPmtInfoClass * klass) +{ + GObjectClass *gobject_klass = (GObjectClass *) klass; + + gobject_klass->finalize = mpegts_pmt_info_finalize; + gobject_klass->set_property = mpegts_pmt_info_set_property; + gobject_klass->get_property = mpegts_pmt_info_get_property; + + g_object_class_install_property (gobject_klass, PROP_PROGRAM_NO, + g_param_spec_uint ("program-number", "Program Number", + "Program Number for this program", 0, G_MAXUINT16, 1, + G_PARAM_READABLE)); + + g_object_class_install_property (gobject_klass, PROP_PCR_PID, + g_param_spec_uint ("pcr-pid", "PID carrying the PCR for this program", + "PID which carries the PCR for this program", 1, G_MAXUINT16, 1, + G_PARAM_READABLE)); + + g_object_class_install_property (gobject_klass, PROP_STREAMINFO, + g_param_spec_value_array ("stream-info", + "GValueArray containing GObjects with properties", + "Array of GObjects containing information about the program streams", + g_param_spec_object ("flu-pmt-streaminfo", "FluPMTStreamInfo", + "Fluendo TS Demuxer PMT Stream info object", + MPEGTS_TYPE_PMT_STREAM_INFO, G_PARAM_READABLE), + G_PARAM_READABLE)); + + g_object_class_install_property (gobject_klass, PROP_VERSION_NO, + g_param_spec_uint ("version-number", "Version Number", + "Version number of this program information", 0, G_MAXUINT8, 1, + G_PARAM_READABLE)); + + g_object_class_install_property (gobject_klass, PROP_DESCRIPTORS, + g_param_spec_value_array ("descriptors", + "Descriptors", + "Value array of strings containing program descriptors", + g_param_spec_boxed ("descriptor", + "descriptor", + "", G_TYPE_GSTRING, G_PARAM_READABLE), G_PARAM_READABLE)); +} + +static void +mpegts_pmt_info_init (MpegTSPmtInfo * pmt_info, MpegTSPmtInfoClass * klass) +{ + pmt_info->streams = g_value_array_new (0); + pmt_info->descriptors = g_value_array_new (0); +} + +MpegTSPmtInfo * +mpegts_pmt_info_new (guint16 program_no, guint16 pcr_pid, guint8 version_no) +{ + MpegTSPmtInfo *info; + + info = g_object_new (MPEGTS_TYPE_PMT_INFO, NULL); + + info->program_no = program_no; + info->pcr_pid = pcr_pid; + info->version_no = version_no; + + return info; +} + +static void +mpegts_pmt_info_finalize (GObject * object) +{ + MpegTSPmtInfo *info = MPEGTS_PMT_INFO (object); + + g_value_array_free (info->streams); + g_value_array_free (info->descriptors); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +mpegts_pmt_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec) +{ + g_return_if_fail (MPEGTS_IS_PMT_INFO (object)); + + /* No settable properties */ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); +} + +static void +mpegts_pmt_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec) +{ + MpegTSPmtInfo *pmt_info; + + g_return_if_fail (MPEGTS_IS_PMT_INFO (object)); + + pmt_info = MPEGTS_PMT_INFO (object); + + switch (prop_id) { + case PROP_PROGRAM_NO: + g_value_set_uint (value, pmt_info->program_no); + break; + case PROP_PCR_PID: + g_value_set_uint (value, pmt_info->pcr_pid); + break; + case PROP_STREAMINFO: + g_value_set_boxed (value, pmt_info->streams); + break; + case PROP_VERSION_NO: + g_value_set_uint (value, pmt_info->version_no); + break; + case PROP_DESCRIPTORS: + g_value_set_boxed (value, pmt_info->descriptors); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); + break; + } +} + +void +mpegts_pmt_info_add_descriptor (MpegTSPmtInfo * pmt_info, + const gchar * descriptor, guint length) +{ + GValue value = { 0 }; + GString *string; + + g_return_if_fail (MPEGTS_IS_PMT_INFO (pmt_info)); + + string = g_string_new_len (descriptor, length); + + g_value_init (&value, G_TYPE_GSTRING); + g_value_take_boxed (&value, string); + g_value_array_append (pmt_info->descriptors, &value); + g_value_unset (&value); +} + +void +mpegts_pmt_info_add_stream (MpegTSPmtInfo * pmt_info, + MpegTSPmtStreamInfo * stream) +{ + GValue v = { 0, }; + + g_return_if_fail (MPEGTS_IS_PMT_INFO (pmt_info)); + g_return_if_fail (MPEGTS_IS_PMT_STREAM_INFO (stream)); + + g_value_init (&v, G_TYPE_OBJECT); + g_value_take_object (&v, stream); + g_value_array_append (pmt_info->streams, &v); +} diff --git a/gst/mpegtsparse/flutspmtinfo.h b/gst/mpegtsparse/flutspmtinfo.h new file mode 100644 index 00000000..56c136de --- /dev/null +++ b/gst/mpegtsparse/flutspmtinfo.h @@ -0,0 +1,58 @@ +/* + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the + * License for the specific language governing rights and limitations + * under the License. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifndef __MPEGTS_PMT_INFO_H__ +#define __MPEGTS_PMT_INFO_H__ + +#include +#include "flutspmtstreaminfo.h" + +G_BEGIN_DECLS + +typedef struct MpegTSPmtInfoClass { + GObjectClass parent_class; +} MpegTSPmtInfoClass; + +typedef struct MpegTSPmtInfo { + GObject parent; + + guint16 program_no; + guint16 pcr_pid; + + guint8 version_no; + + GValueArray *descriptors; + GValueArray *streams; +} MpegTSPmtInfo; + +MpegTSPmtInfo *mpegts_pmt_info_new (guint16 program_no, guint16 pcr_pid, guint8 version); +void mpegts_pmt_info_add_stream (MpegTSPmtInfo *pmt_info, MpegTSPmtStreamInfo *stream); +void mpegts_pmt_info_add_descriptor (MpegTSPmtInfo *pmt_info, + const gchar *descriptor, guint length); + +GType mpegts_pmt_info_get_type (void); + +#define MPEGTS_TYPE_PMT_INFO (mpegts_pmt_info_get_type ()) +#define MPEGTS_IS_PMT_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MPEGTS_TYPE_PMT_INFO)) +#define MPEGTS_PMT_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MPEGTS_TYPE_PMT_INFO, MpegTSPmtInfo)) + +G_END_DECLS + +#endif diff --git a/gst/mpegtsparse/flutspmtstreaminfo.c b/gst/mpegtsparse/flutspmtstreaminfo.c new file mode 100644 index 00000000..862331e7 --- /dev/null +++ b/gst/mpegtsparse/flutspmtstreaminfo.c @@ -0,0 +1,181 @@ +/* + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the + * License for the specific language governing rights and limitations + * under the License. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "flutspmtstreaminfo.h" + +enum +{ + PROP_0, + PROP_PID, + PROP_LANGUAGES, + PROP_STREAM_TYPE, + PROP_DESCRIPTORS, +}; + +GST_BOILERPLATE (MpegTSPmtStreamInfo, mpegts_pmt_stream_info, GObject, + G_TYPE_OBJECT); + +static void mpegts_pmt_stream_info_set_property (GObject * object, + guint prop_id, const GValue * value, GParamSpec * spec); +static void mpegts_pmt_stream_info_get_property (GObject * object, + guint prop_id, GValue * value, GParamSpec * spec); +static void mpegts_pmt_stream_info_finalize (GObject * object); + +static void +mpegts_pmt_stream_info_base_init (gpointer klass) +{ +} + +static void +mpegts_pmt_stream_info_class_init (MpegTSPmtStreamInfoClass * klass) +{ + GObjectClass *gobject_klass = (GObjectClass *) klass; + + gobject_klass->set_property = mpegts_pmt_stream_info_set_property; + gobject_klass->get_property = mpegts_pmt_stream_info_get_property; + gobject_klass->finalize = mpegts_pmt_stream_info_finalize; + + g_object_class_install_property (gobject_klass, PROP_PID, + g_param_spec_uint ("pid", "PID carrying this stream", + "PID which carries this stream", 1, G_MAXUINT16, 1, + G_PARAM_READABLE)); + g_object_class_install_property (gobject_klass, PROP_LANGUAGES, + g_param_spec_value_array ("languages", "Languages of this stream", + "Value array of the languages of this stream", + g_param_spec_string ("language", "language", "language", "", + G_PARAM_READABLE), G_PARAM_READABLE)); + + g_object_class_install_property (gobject_klass, PROP_STREAM_TYPE, + g_param_spec_uint ("stream-type", + "Stream type", "Stream type", 0, G_MAXUINT8, 0, G_PARAM_READABLE)); + + g_object_class_install_property (gobject_klass, PROP_DESCRIPTORS, + g_param_spec_value_array ("descriptors", + "Descriptors", + "Value array of strings containing stream descriptors", + g_param_spec_boxed ("descriptor", + "descriptor", + "", G_TYPE_GSTRING, G_PARAM_READABLE), G_PARAM_READABLE)); +} + +static void +mpegts_pmt_stream_info_init (MpegTSPmtStreamInfo * pmt_stream_info, + MpegTSPmtStreamInfoClass * klass) +{ + pmt_stream_info->languages = g_value_array_new (0); + pmt_stream_info->descriptors = g_value_array_new (0); +} + +static void +mpegts_pmt_stream_info_finalize (GObject * object) +{ + MpegTSPmtStreamInfo *info = MPEGTS_PMT_STREAM_INFO (object); + + g_value_array_free (info->languages); + g_value_array_free (info->descriptors); +} + +MpegTSPmtStreamInfo * +mpegts_pmt_stream_info_new (guint16 pid, guint8 type) +{ + MpegTSPmtStreamInfo *info; + + info = g_object_new (MPEGTS_TYPE_PMT_STREAM_INFO, NULL); + + info->pid = pid; + info->stream_type = type; + return info; +} + +void +mpegts_pmt_stream_info_add_language (MpegTSPmtStreamInfo * pmt_info, + gchar * language) +{ + GValue v = { 0, }; + + g_return_if_fail (MPEGTS_IS_PMT_STREAM_INFO (pmt_info)); + + g_value_init (&v, G_TYPE_STRING); + g_value_take_string (&v, language); + g_value_array_append (pmt_info->languages, &v); + g_value_unset (&v); +} + +void +mpegts_pmt_stream_info_add_descriptor (MpegTSPmtStreamInfo * pmt_info, + const gchar * descriptor, guint length) +{ + GValue value = { 0 }; + GString *string; + + g_return_if_fail (MPEGTS_IS_PMT_STREAM_INFO (pmt_info)); + + string = g_string_new_len (descriptor, length); + + g_value_init (&value, G_TYPE_GSTRING); + g_value_take_boxed (&value, string); + g_value_array_append (pmt_info->descriptors, &value); + g_value_unset (&value); +} + +static void +mpegts_pmt_stream_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec) +{ + g_return_if_fail (MPEGTS_IS_PMT_STREAM_INFO (object)); + + /* No settable properties */ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); +} + +static void +mpegts_pmt_stream_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec) +{ + MpegTSPmtStreamInfo *si; + + g_return_if_fail (MPEGTS_IS_PMT_STREAM_INFO (object)); + + si = MPEGTS_PMT_STREAM_INFO (object); + + switch (prop_id) { + case PROP_STREAM_TYPE: + g_value_set_uint (value, si->stream_type); + break; + case PROP_PID: + g_value_set_uint (value, si->pid); + break; + case PROP_LANGUAGES: + g_value_set_boxed (value, si->languages); + break; + case PROP_DESCRIPTORS: + g_value_set_boxed (value, si->descriptors); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); + break; + } +} diff --git a/gst/mpegtsparse/flutspmtstreaminfo.h b/gst/mpegtsparse/flutspmtstreaminfo.h new file mode 100644 index 00000000..a3d43917 --- /dev/null +++ b/gst/mpegtsparse/flutspmtstreaminfo.h @@ -0,0 +1,55 @@ +/* + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/. + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the + * License for the specific language governing rights and limitations + * under the License. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifndef __MPEGTS_PMT_STREAM_INFO_H__ +#define __MPEGTS_PMT_STREAM_INFO_H__ + +#include + +G_BEGIN_DECLS + + +typedef struct MpegTSPmtStreamInfoClass { + GObjectClass parent_class; +} MpegTSPmtStreamInfoClass; + +typedef struct MpegTSPmtStreamInfo { + GObject parent; + + guint16 pid; + GValueArray *languages; /* null terminated 3 character ISO639 language code */ + guint8 stream_type; + GValueArray *descriptors; +} MpegTSPmtStreamInfo; + +MpegTSPmtStreamInfo *mpegts_pmt_stream_info_new (guint16 pid, guint8 type); +void mpegts_pmt_stream_info_add_language(MpegTSPmtStreamInfo* si, gchar* language); +void mpegts_pmt_stream_info_add_descriptor (MpegTSPmtStreamInfo *si, const gchar *descriptor, guint length); + +GType mpegts_pmt_stream_info_get_type (void); + +#define MPEGTS_TYPE_PMT_STREAM_INFO (mpegts_pmt_stream_info_get_type ()) + +#define MPEGTS_IS_PMT_STREAM_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), MPEGTS_TYPE_PMT_STREAM_INFO)) +#define MPEGTS_PMT_STREAM_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MPEGTS_TYPE_PMT_STREAM_INFO, MpegTSPmtStreamInfo)) + +G_END_DECLS + +#endif diff --git a/gst/mpegtsparse/mpegtspacketizer.c b/gst/mpegtsparse/mpegtspacketizer.c new file mode 100644 index 00000000..7e51f1eb --- /dev/null +++ b/gst/mpegtsparse/mpegtspacketizer.c @@ -0,0 +1,619 @@ +/* + * mpegtspacketizer.c - + * Copyright (C) 2007 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include "mpegtspacketizer.h" +#include "flutspatinfo.h" +#include "flutspmtinfo.h" + +GST_DEBUG_CATEGORY_STATIC (mpegts_packetizer_debug); +#define GST_CAT_DEFAULT mpegts_packetizer_debug + +G_DEFINE_TYPE (MpegTSPacketizer, mpegts_packetizer, G_TYPE_OBJECT); + +static void mpegts_packetizer_dispose (GObject * object); +static void mpegts_packetizer_finalize (GObject * object); + +#define CONTINUITY_UNSET 255 +#define MAX_CONTINUITY 16 + +typedef struct +{ + guint16 pid; + guint continuity_counter; + GstAdapter *section_adapter; + guint section_length; + guint8 section_version_number; +} MpegTSPacketizerStream; + +static MpegTSPacketizerStream * +mpegts_packetizer_stream_new (guint16 pid) +{ + MpegTSPacketizerStream *stream; + + stream = (MpegTSPacketizerStream *) g_new0 (MpegTSPacketizerStream, 1); + stream->section_adapter = gst_adapter_new (); + stream->pid = pid; + stream->continuity_counter = CONTINUITY_UNSET; + return stream; +} + +static void +mpegts_packetizer_stream_free (MpegTSPacketizerStream * stream) +{ + gst_adapter_clear (stream->section_adapter); + g_object_unref (stream->section_adapter); + g_free (stream); +} + +static void +mpegts_packetizer_clear_section (MpegTSPacketizer * packetizer, + MpegTSPacketizerStream * stream) +{ + gst_adapter_clear (stream->section_adapter); + stream->continuity_counter = CONTINUITY_UNSET; + stream->section_length = 0; +} + +static void +mpegts_packetizer_class_init (MpegTSPacketizerClass * klass) +{ + GObjectClass *gobject_class; + + gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->dispose = mpegts_packetizer_dispose; + gobject_class->finalize = mpegts_packetizer_finalize; +} + +static void +mpegts_packetizer_init (MpegTSPacketizer * packetizer) +{ + packetizer->adapter = gst_adapter_new (); + packetizer->streams = g_hash_table_new (g_direct_hash, g_direct_equal); +} + +static void +mpegts_packetizer_dispose (GObject * object) +{ + MpegTSPacketizer *packetizer = GST_MPEGTS_PACKETIZER (object); + + if (!packetizer->disposed) { + gst_adapter_clear (packetizer->adapter); + g_object_unref (packetizer->adapter); + packetizer->disposed = TRUE; + } + + if (G_OBJECT_CLASS (mpegts_packetizer_parent_class)->dispose) + G_OBJECT_CLASS (mpegts_packetizer_parent_class)->dispose (object); +} + +static gboolean +stream_foreach_remove (gpointer key, gpointer value, gpointer data) +{ + MpegTSPacketizerStream *stream; + + stream = (MpegTSPacketizerStream *) value; + mpegts_packetizer_stream_free (stream); + + return TRUE; +} + +static void +mpegts_packetizer_finalize (GObject * object) +{ + MpegTSPacketizer *packetizer = GST_MPEGTS_PACKETIZER (object); + + g_hash_table_foreach_remove (packetizer->streams, + stream_foreach_remove, packetizer); + g_hash_table_destroy (packetizer->streams); + + if (G_OBJECT_CLASS (mpegts_packetizer_parent_class)->finalize) + G_OBJECT_CLASS (mpegts_packetizer_parent_class)->finalize (object); +} + +static gboolean +mpegts_packetizer_parse_adaptation_field_control (MpegTSPacketizer * packetizer, + MpegTSPacketizerPacket * packet) +{ + guint8 length; + + length = *packet->data++; + + if (packet->adaptation_field_control == 0x02) { + /* no payload, adaptation field of 183 bytes */ + if (length != 183) { + GST_WARNING ("PID %d afc == 0x%x and length %d != 183", + packet->pid, packet->adaptation_field_control, length); + } + } else if (length > 182) { + GST_WARNING ("PID %d afc == 0x%01x and length %d > 182", + packet->pid, packet->adaptation_field_control, length); + } + + /* skip the adaptation field body for now */ + if (packet->data + length > packet->data_end) { + GST_ERROR ("PID %d afc length overflows the buffer %d", + packet->pid, length); + return FALSE; + } + *packet->data += length; + + return TRUE; +} + +static gboolean +mpegts_packetizer_parse_packet (MpegTSPacketizer * packetizer, + MpegTSPacketizerPacket * packet) +{ + guint8 *data; + + data = GST_BUFFER_DATA (packet->buffer); + /* skip sync_byte */ + data++; + + packet->payload_unit_start_indicator = (*data >> 6) & 0x01; + packet->pid = GST_READ_UINT16_BE (data) & 0x1FFF; + data += 2; + + packet->adaptation_field_control = *data >> 4 & 0x03; + packet->continuity_counter = *data & 0x0F; + data += 1; + + packet->data = data; + + if (packet->adaptation_field_control & 0x02) + if (!mpegts_packetizer_parse_adaptation_field_control (packetizer, packet)) + return FALSE; + + if (packet->adaptation_field_control & 0x01) + packet->payload = packet->data; + else + packet->payload = NULL; + + return TRUE; +} + +static gboolean +mpegts_packetizer_parse_section_header (MpegTSPacketizer * packetizer, + MpegTSPacketizerStream * stream, MpegTSPacketizerSection * section) +{ + guint8 tmp; + guint8 *data; + + section->complete = TRUE; + /* get the section buffer, pass the ownership to the caller */ + section->buffer = gst_adapter_take_buffer (stream->section_adapter, + 3 + stream->section_length); + data = GST_BUFFER_DATA (section->buffer); + + section->table_id = *data++; + section->section_length = GST_READ_UINT16_BE (data) & 0x0FFF; + data += 2; + + /* skip to the version byte */ + data += 2; + + tmp = *data++; + section->version_number = (tmp >> 1) & 0x1F; + section->current_next_indicator = tmp & 0x01; + + if (!section->current_next_indicator) + goto not_applicable; + + if (section->version_number == stream->section_version_number) + goto not_applicable; + + stream->section_version_number = section->version_number; + + return TRUE; + +not_applicable: + section->complete = FALSE; + gst_buffer_unref (section->buffer); + return TRUE; +} + +GValueArray * +mpegts_packetizer_parse_pat (MpegTSPacketizer * packetizer, + MpegTSPacketizerSection * section) +{ + guint8 *data, *end; + guint16 transport_stream_id; + guint8 tmp; + guint program_number; + guint16 pmt_pid; + MpegTSPatInfo *info; + GValueArray *pat; + GValue value = { 0 }; + + data = GST_BUFFER_DATA (section->buffer); + pat = g_value_array_new (0); + + section->table_id = *data++; + section->section_length = GST_READ_UINT16_BE (data) & 0x0FFF; + data += 2; + + transport_stream_id = GST_READ_UINT16_BE (data); + data += 2; + + tmp = *data++; + section->version_number = (tmp >> 1) & 0x1F; + section->current_next_indicator = tmp & 0x01; + + /* skip section_number and last_section_number */ + data += 2; + + /* stop at the CRC */ + end = GST_BUFFER_DATA (section->buffer) + GST_BUFFER_SIZE (section->buffer); + while (data < end - 4) { + program_number = GST_READ_UINT16_BE (data); + data += 2; + + pmt_pid = GST_READ_UINT16_BE (data) & 0x1FFF; + data += 2; + + info = mpegts_pat_info_new (program_number, pmt_pid); + + g_value_init (&value, G_TYPE_OBJECT); + g_value_take_object (&value, info); + g_value_array_append (pat, &value); + g_value_unset (&value); + } + + g_assert (data == end - 4); + + return pat; +} + +GObject * +mpegts_packetizer_parse_pmt (MpegTSPacketizer * packetizer, + MpegTSPacketizerSection * section) +{ + MpegTSPmtInfo *pmt = NULL; + MpegTSPmtStreamInfo *stream_info; + guint8 *data, *end; + guint16 program_number; + guint8 tmp; + guint16 pcr_pid; + guint program_info_length; + guint8 tag, length; + guint8 stream_type; + guint16 pid; + guint stream_info_length; + + /* fixed header + CRC == 16 */ + if (GST_BUFFER_SIZE (section->buffer) < 16) { + GST_WARNING ("PID %d invalid PMT size %d", + section->pid, section->section_length); + goto error; + } + + data = GST_BUFFER_DATA (section->buffer); + end = data + GST_BUFFER_SIZE (section->buffer); + + section->table_id = *data++; + section->section_length = GST_READ_UINT16_BE (data) & 0x0FFF; + data += 2; + + program_number = GST_READ_UINT16_BE (data); + data += 2; + + tmp = *data++; + section->version_number = (tmp >> 1) & 0x1F; + section->current_next_indicator = tmp & 0x01; + + /* skip section_number and last_section_number */ + data += 2; + + pcr_pid = GST_READ_UINT16_BE (data) & 0x1FFF; + data += 2; + + program_info_length = GST_READ_UINT16_BE (data) & 0x0FFF; + data += 2; + + /* check that the buffer is large enough to contain at least + * program_info_length bytes + CRC */ + if (data + program_info_length + 4 > end) { + GST_WARNING ("PID %d invalid program info length %d " + "left %d", section->pid, program_info_length, end - data); + goto error; + } + + pmt = mpegts_pmt_info_new (program_number, pcr_pid, section->version_number); + + /* parse program level descriptors */ + while (program_info_length > 0) { + tag = *data++; + length = *data++; + program_info_length -= 2; + + if (length > program_info_length) { + GST_WARNING ("PID %d invalid descriptor length %d left %d", + section->pid, length, program_info_length); + goto error; + } + + mpegts_pmt_info_add_descriptor (pmt, (const gchar *) data - 2, 2 + length); + data += length; + program_info_length -= length; + } + + g_assert (program_info_length == 0); + + /* parse entries, cycle until there's space for another entry (at least 5 + * bytes) plus the CRC */ + while (data <= end - 4 - 5) { + stream_type = *data++; + + pid = GST_READ_UINT16_BE (data) & 0x1FFF; + data += 2; + + stream_info_length = GST_READ_UINT16_BE (data) & 0x0FFF; + data += 2; + + if (data + stream_info_length + 4 > end) { + GST_WARNING ("PID %d invalid stream info length %d " + "left %d", section->pid, stream_info_length, end - data); + goto error; + } + + GST_INFO ("PMT PID %d program_number %d pid %d", + section->pid, program_number, pid); + + stream_info = mpegts_pmt_stream_info_new (pid, stream_type); + + /* parse stream level descriptors */ + while (stream_info_length > 0) { + tag = *data++; + length = *data++; + stream_info_length -= 2; + + if (length > stream_info_length) { + GST_WARNING ("PID %d invalid descriptor length %d left %d", + section->pid, length, stream_info_length); + g_object_unref (stream_info); + goto error; + } + + mpegts_pmt_stream_info_add_descriptor (stream_info, + (const gchar *) data - 2, 2 + length); + data += length; + stream_info_length -= length; + } + + /* adds a ref to stream_info */ + mpegts_pmt_info_add_stream (pmt, stream_info); + g_object_unref (stream_info); + } + + g_assert (data == end - 4); + + return G_OBJECT (pmt); + +error: + if (pmt) + g_object_unref (pmt); + return NULL; +} + +static void +foreach_stream_clear (gpointer key, gpointer value, gpointer data) +{ + MpegTSPacketizer *packetizer = (MpegTSPacketizer *) data; + MpegTSPacketizerStream *stream = (MpegTSPacketizerStream *) value; + + mpegts_packetizer_clear_section (packetizer, stream); +} + +void +mpegts_packetizer_clear (MpegTSPacketizer * packetizer) +{ + g_hash_table_foreach (packetizer->streams, foreach_stream_clear, packetizer); + gst_adapter_clear (packetizer->adapter); +} + + +MpegTSPacketizer * +mpegts_packetizer_new () +{ + MpegTSPacketizer *packetizer; + + packetizer = + GST_MPEGTS_PACKETIZER (g_object_new (GST_TYPE_MPEGTS_PACKETIZER, NULL)); + + return packetizer; +} + +void +mpegts_packetizer_push (MpegTSPacketizer * packetizer, GstBuffer * buffer) +{ + g_return_if_fail (GST_IS_MPEGTS_PACKETIZER (packetizer)); + g_return_if_fail (GST_IS_BUFFER (buffer)); + + gst_adapter_push (packetizer->adapter, buffer); +} + +gboolean +mpegts_packetizer_has_packets (MpegTSPacketizer * packetizer) +{ + g_return_val_if_fail (GST_IS_MPEGTS_PACKETIZER (packetizer), FALSE); + + return gst_adapter_available (packetizer->adapter) >= 188; +} + +gboolean +mpegts_packetizer_next_packet (MpegTSPacketizer * packetizer, + MpegTSPacketizerPacket * packet) +{ + guint8 sync_byte; + gboolean ret = FALSE; + + g_return_val_if_fail (GST_IS_MPEGTS_PACKETIZER (packetizer), FALSE); + g_return_val_if_fail (packet != NULL, FALSE); + + packet->buffer = NULL; + while (gst_adapter_available (packetizer->adapter) >= 188) { + sync_byte = *gst_adapter_peek (packetizer->adapter, 1); + if (sync_byte != 0x47) { + GST_DEBUG ("lost sync %02x", sync_byte); + gst_adapter_flush (packetizer->adapter, 1); + continue; + } + + packet->buffer = gst_adapter_take_buffer (packetizer->adapter, 188); + packet->data_start = GST_BUFFER_DATA (packet->buffer); + packet->data_end = + GST_BUFFER_DATA (packet->buffer) + GST_BUFFER_SIZE (packet->buffer); + ret = mpegts_packetizer_parse_packet (packetizer, packet); + break; + } + + return ret; +} + +void +mpegts_packetizer_clear_packet (MpegTSPacketizer * packetizer, + MpegTSPacketizerPacket * packet) +{ + g_return_if_fail (GST_IS_MPEGTS_PACKETIZER (packetizer)); + g_return_if_fail (packet != NULL); + + if (packet->buffer) + gst_buffer_unref (packet->buffer); + packet->buffer = NULL; + packet->continuity_counter = 0; + packet->payload_unit_start_indicator = 0; + packet->payload = NULL; + packet->data_start = NULL; + packet->data_end = NULL; +} + +gboolean +mpegts_packetizer_push_section (MpegTSPacketizer * packetizer, + MpegTSPacketizerPacket * packet, MpegTSPacketizerSection * section) +{ + gboolean res = FALSE; + MpegTSPacketizerStream *stream; + guint8 pointer, table_id; + guint section_length; + GstBuffer *sub_buf; + guint8 *data; + + g_return_val_if_fail (GST_IS_MPEGTS_PACKETIZER (packetizer), FALSE); + g_return_val_if_fail (packet != NULL, FALSE); + g_return_val_if_fail (section != NULL, FALSE); + + data = packet->data; + section->pid = packet->pid; + + stream = (MpegTSPacketizerStream *) g_hash_table_lookup (packetizer->streams, + GINT_TO_POINTER ((gint) packet->pid)); + if (stream == NULL) { + stream = mpegts_packetizer_stream_new (packet->pid); + g_hash_table_insert (packetizer->streams, + GINT_TO_POINTER ((gint) packet->pid), stream); + } + + if (packet->payload_unit_start_indicator == 1) { + pointer = *data++; + if (data + pointer > packet->data_end) { + GST_WARNING ("PID %d PSI section pointer points past the end " + "of the buffer", packet->pid); + goto out; + } + + data += pointer; + } + + table_id = *data++; + + section_length = GST_READ_UINT16_BE (data) & 0x0FFF; + data += 2; + + /* create a sub buffer from the start of the section (table_id and + * section_length included) to the end */ + sub_buf = gst_buffer_create_sub (packet->buffer, + data - 3 - GST_BUFFER_DATA (packet->buffer), packet->data_end - data + 3); + + if (packet->payload_unit_start_indicator) { + if (stream->continuity_counter != CONTINUITY_UNSET) { + GST_WARNING ("PID %d payload_unit_start_indicator set but section " + "not complete (last_continuity: %d continuity: %d sec len %d buffer %d avail %d", + packet->pid, stream->continuity_counter, packet->continuity_counter, + section_length, GST_BUFFER_SIZE (sub_buf), + gst_adapter_available (stream->section_adapter)); + mpegts_packetizer_clear_section (packetizer, stream); + } + + stream->continuity_counter = packet->continuity_counter; + stream->section_length = section_length; + gst_adapter_push (stream->section_adapter, sub_buf); + + res = TRUE; + } else if (packet->continuity_counter == stream->continuity_counter + 1 || + (stream->continuity_counter == MAX_CONTINUITY && + packet->continuity_counter == 0)) { + stream->continuity_counter = packet->continuity_counter; + gst_adapter_push (stream->section_adapter, sub_buf); + + res = TRUE; + } else { + GST_WARNING ("PID %d section discontinuity " + "(last_continuity: %d continuity: %d", packet->pid, + stream->continuity_counter, packet->continuity_counter); + mpegts_packetizer_clear_section (packetizer, stream); + gst_buffer_unref (sub_buf); + } + + if (res) { + /* we pushed some data in the section adapter, see if the section is + * complete now */ + + /* >= as sections can be padded and padding is not included in + * section_length */ + if (gst_adapter_available (stream->section_adapter) >= + stream->section_length + 3) { + res = mpegts_packetizer_parse_section_header (packetizer, + stream, section); + + /* flush stuffing bytes */ + mpegts_packetizer_clear_section (packetizer, stream); + } else { + /* section not complete yet */ + section->complete = FALSE; + } + } else { + section->complete = FALSE; + } + +out: + packet->data = data; + return res; +} + +void +mpegts_packetizer_init_debug () +{ + GST_DEBUG_CATEGORY_INIT (mpegts_packetizer_debug, "mpegtspacketizer", 0, + "MPEG transport stream parser"); +} diff --git a/gst/mpegtsparse/mpegtspacketizer.h b/gst/mpegtsparse/mpegtspacketizer.h new file mode 100644 index 00000000..b617a7aa --- /dev/null +++ b/gst/mpegtsparse/mpegtspacketizer.h @@ -0,0 +1,107 @@ +/* + * mpegtspacketizer.h - + * Copyright (C) 2007 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef GST_MPEGTS_PACKETIZER_H +#define GST_MPEGTS_PACKETIZER_H + +#include +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_MPEGTS_PACKETIZER \ + (mpegts_packetizer_get_type()) +#define GST_MPEGTS_PACKETIZER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MPEGTS_PACKETIZER,MpegTSPacketizer)) +#define GST_MPEGTS_PACKETIZER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MPEGTS_PACKETIZER,MpegTSPacketizerClass)) +#define GST_IS_MPEGTS_PACKETIZER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MPEGTS_PACKETIZER)) +#define GST_IS_MPEGTS_PACKETIZER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MPEGTS_PACKETIZER)) + + +typedef struct _MpegTSPacketizer MpegTSPacketizer; +typedef struct _MpegTSPacketizerClass MpegTSPacketizerClass; + +struct _MpegTSPacketizer { + GObject object; + + GstAdapter *adapter; + GHashTable *streams; + gboolean disposed; +}; + +struct _MpegTSPacketizerClass { + GObjectClass object_class; +}; + +typedef struct +{ + GstBuffer *buffer; + gint16 pid; + guint8 payload_unit_start_indicator; + guint8 adaptation_field_control; + guint8 continuity_counter; + guint8 *payload; + + guint8 *data_start; + guint8 *data_end; + guint8 *data; + +} MpegTSPacketizerPacket; + +typedef struct +{ + gboolean complete; + GstBuffer *buffer; + gint16 pid; + guint8 table_id; + guint section_length; + guint8 version_number; + guint8 current_next_indicator; +} MpegTSPacketizerSection; + +GType gst_mpegts_packetizer_get_type(void); + +void mpegts_packetizer_init_debug (); +MpegTSPacketizer *mpegts_packetizer_new (); +void mpegts_packetizer_clear (MpegTSPacketizer *packetizer); +void mpegts_packetizer_push (MpegTSPacketizer *packetizer, GstBuffer *buffer); +gboolean mpegts_packetizer_has_packets (MpegTSPacketizer *packetizer); +gboolean mpegts_packetizer_next_packet (MpegTSPacketizer *packetizer, + MpegTSPacketizerPacket *packet); +void mpegts_packetizer_clear_packet (MpegTSPacketizer *packetizer, + MpegTSPacketizerPacket *packet); + +gboolean mpegts_packetizer_push_section (MpegTSPacketizer *packetzer, + MpegTSPacketizerPacket *packet, MpegTSPacketizerSection *section); +GValueArray *mpegts_packetizer_parse_pat (MpegTSPacketizer *packetizer, + MpegTSPacketizerSection *section); +GObject *mpegts_packetizer_parse_pmt (MpegTSPacketizer *packetizer, + MpegTSPacketizerSection *section); + +G_END_DECLS + +#endif /* GST_MPEGTS_PACKETIZER_H */ diff --git a/gst/mpegtsparse/mpegtsparse.c b/gst/mpegtsparse/mpegtsparse.c new file mode 100644 index 00000000..9d344c27 --- /dev/null +++ b/gst/mpegtsparse/mpegtsparse.c @@ -0,0 +1,970 @@ +/* + * mpegtsparse.c - + * Copyright (C) 2007 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; 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 "mpegtsparse.h" +#include "mpegtsparsemarshal.h" +#include "flutspatinfo.h" +#include "flutspmtinfo.h" +#include "flutspmtstreaminfo.h" + +GST_DEBUG_CATEGORY_STATIC (mpegts_parse_debug); +#define GST_CAT_DEFAULT mpegts_parse_debug + +typedef struct _MpegTSParsePad MpegTSParsePad; + +typedef struct +{ + guint16 pid; + guint8 stream_type; +} MpegTSParseStream; + +typedef struct +{ + gint program_number; + guint16 pmt_pid; + GObject *pmt_info; + GHashTable *streams; + gint patcount; + gint selected; + gboolean active; + MpegTSParsePad *tspad; +} MpegTSParseProgram; + +struct _MpegTSParsePad +{ + GstPad *pad; + + /* the program number that the peer wants on this pad */ + gint program_number; + MpegTSParseProgram *program; + + /* set to FALSE before a push and TRUE after */ + gboolean pushed; + + /* the return of the latest push */ + GstFlowReturn flow_return; +}; + +static GstElementDetails mpegts_parse_details = +GST_ELEMENT_DETAILS ("MPEG transport stream parser", + "Codec/Parser", + "Parses MPEG2 transport streams", + "Alessandro Decina "); + +static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/mpegts, " "systemstream = (boolean) true ") + ); + +static GstStaticPadTemplate src_template = +GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/mpegts, " "systemstream = (boolean) true ") + ); + +static GstStaticPadTemplate program_template = +GST_STATIC_PAD_TEMPLATE ("program_%d", GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS ("video/mpegts, " "systemstream = (boolean) true ") + ); + +enum +{ + SIGNAL_PMT, + /* FILL ME */ + LAST_SIGNAL +}; + +enum +{ + ARG_0, + PROP_PROGRAM_NUMBERS, + PROP_PAT_INFO + /* FILL ME */ +}; + +static void mpegts_parse_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void mpegts_parse_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); +static void mpegts_parse_dispose (GObject * object); +static void mpegts_parse_finalize (GObject * object); + +static MpegTSParsePad *mpegts_parse_create_tspad (MpegTSParse * parse, + const gchar * name); +static void mpegts_parse_destroy_tspad (MpegTSParse * parse, + MpegTSParsePad * tspad); +static GstPad *mpegts_parse_activate_program (MpegTSParse * parse, + MpegTSParseProgram * program); +static void mpegts_parse_free_program (MpegTSParseProgram * program); +static void mpegts_parse_free_stream (MpegTSParseStream * ptream); +static void mpegts_parse_reset_selected_programs (MpegTSParse * parse, + gchar * programs); + +static void mpegts_parse_pad_removed (GstElement * element, GstPad * pad); +static GstFlowReturn mpegts_parse_chain (GstPad * pad, GstBuffer * buf); +static gboolean mpegts_parse_sink_event (GstPad * pad, GstEvent * event); +static GstStateChangeReturn mpegts_parse_change_state (GstElement * element, + GstStateChange transition); + +static guint signals[LAST_SIGNAL] = { 0 }; + +GST_BOILERPLATE (MpegTSParse, mpegts_parse, GstElement, GST_TYPE_ELEMENT); + +static void +mpegts_parse_base_init (gpointer klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&sink_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&src_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&program_template)); + + gst_element_class_set_details (element_class, &mpegts_parse_details); +} + +static void +mpegts_parse_class_init (MpegTSParseClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *element_class; + + element_class = GST_ELEMENT_CLASS (klass); + element_class->pad_removed = mpegts_parse_pad_removed; + element_class->change_state = mpegts_parse_change_state; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->set_property = mpegts_parse_set_property; + gobject_class->get_property = mpegts_parse_get_property; + gobject_class->dispose = mpegts_parse_dispose; + gobject_class->finalize = mpegts_parse_finalize; + + g_object_class_install_property (gobject_class, PROP_PROGRAM_NUMBERS, + g_param_spec_string ("program-numbers", + "Program Numbers", + "Colon separated list of programs", "", G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, PROP_PAT_INFO, + g_param_spec_value_array ("pat-info", + "GValueArray containing GObjects with properties", + "Array of GObjects containing information from the TS PAT " + "about all programs listed in the current Program Association " + "Table (PAT)", + g_param_spec_object ("flu-pat-streaminfo", "FluPATStreamInfo", + "Fluendo TS Demuxer PAT Stream info object", + MPEGTS_TYPE_PAT_INFO, G_PARAM_READABLE), G_PARAM_READABLE)); + + signals[SIGNAL_PMT] = + g_signal_new ("pmt-info", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (MpegTSParseClass, pmt_info), NULL, NULL, + mpegts_parse_marshal_VOID__INT_OBJECT, G_TYPE_NONE, 2, G_TYPE_INT, + MPEGTS_TYPE_PMT_INFO); +} + +static gboolean +foreach_psi_pid_remove (gpointer key, gpointer value, gpointer data) +{ + return TRUE; +} + +static void +mpegts_parse_reset (MpegTSParse * parse) +{ + mpegts_packetizer_clear (parse->packetizer); + g_hash_table_foreach_remove (parse->psi_pids, foreach_psi_pid_remove, NULL); + + /* PAT */ + g_hash_table_insert (parse->psi_pids, + GINT_TO_POINTER (0), GINT_TO_POINTER (1)); + + /* pmt pids will be added and removed dinamically */ +} + +static void +mpegts_parse_init (MpegTSParse * parse, MpegTSParseClass * klass) +{ + parse->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink"); + gst_pad_set_chain_function (parse->sinkpad, mpegts_parse_chain); + gst_pad_set_event_function (parse->sinkpad, mpegts_parse_sink_event); + gst_element_add_pad (GST_ELEMENT (parse), parse->sinkpad); + + parse->srcpad = mpegts_parse_create_tspad (parse, "src")->pad; + gst_element_add_pad (GST_ELEMENT (parse), parse->srcpad); + + parse->disposed = FALSE; + parse->packetizer = mpegts_packetizer_new (); + parse->program_numbers = g_strdup (""); + parse->pads_to_add = NULL; + parse->programs = g_hash_table_new_full (g_direct_hash, g_direct_equal, + NULL, (GDestroyNotify) mpegts_parse_free_program); + parse->psi_pids = g_hash_table_new (g_direct_hash, g_direct_equal); + mpegts_parse_reset (parse); +} + +static void +mpegts_parse_dispose (GObject * object) +{ + MpegTSParse *parse = GST_MPEGTS_PARSE (object); + + if (!parse->disposed) { + g_object_unref (parse->packetizer); + parse->disposed = TRUE; + } + + if (G_OBJECT_CLASS (parent_class)->dispose) + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static void +mpegts_parse_finalize (GObject * object) +{ + MpegTSParse *parse = GST_MPEGTS_PARSE (object); + + g_free (parse->program_numbers); + if (parse->pat_info) + g_value_array_free (parse->pat_info); + g_hash_table_destroy (parse->programs); + g_hash_table_destroy (parse->psi_pids); + + if (G_OBJECT_CLASS (parent_class)->finalize) + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +mpegts_parse_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + MpegTSParse *parse = GST_MPEGTS_PARSE (object); + + switch (prop_id) { + case PROP_PROGRAM_NUMBERS: + mpegts_parse_reset_selected_programs (parse, g_value_dup_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +mpegts_parse_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + MpegTSParse *parse = GST_MPEGTS_PARSE (object); + + switch (prop_id) { + case PROP_PROGRAM_NUMBERS: + g_value_set_string (value, parse->program_numbers); + break; + case PROP_PAT_INFO: + g_value_set_boxed (value, parse->pat_info); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static MpegTSParseProgram * +mpegts_parse_add_program (MpegTSParse * parse, + gint program_number, guint16 pmt_pid) +{ + MpegTSParseProgram *program; + + program = g_new0 (MpegTSParseProgram, 1); + program->program_number = program_number; + program->pmt_pid = pmt_pid; + program->streams = g_hash_table_new_full (g_direct_hash, g_direct_equal, + NULL, (GDestroyNotify) mpegts_parse_free_stream); + program->patcount = 1; + program->selected = 0; + program->active = FALSE; + + g_hash_table_insert (parse->programs, + GINT_TO_POINTER (program_number), program); + + return program; +} + +static MpegTSParseProgram * +mpegts_parse_get_program (MpegTSParse * parse, gint program_number) +{ + MpegTSParseProgram *program; + + program = (MpegTSParseProgram *) g_hash_table_lookup (parse->programs, + GINT_TO_POINTER ((gint) program_number)); + + return program; +} + +static GstPad * +mpegts_parse_activate_program (MpegTSParse * parse, + MpegTSParseProgram * program) +{ + MpegTSParsePad *tspad; + gchar *pad_name; + + pad_name = g_strdup_printf ("program_%d", program->program_number); + + tspad = mpegts_parse_create_tspad (parse, pad_name); + tspad->program_number = program->program_number; + tspad->program = program; + program->tspad = tspad; + g_free (pad_name); + gst_pad_set_active (tspad->pad, TRUE); + program->active = TRUE; + + return tspad->pad; +} + +static GstPad * +mpegts_parse_deactivate_program (MpegTSParse * parse, + MpegTSParseProgram * program) +{ + MpegTSParsePad *tspad; + + tspad = program->tspad; + gst_pad_set_active (tspad->pad, FALSE); + program->active = FALSE; + + /* tspad will be destroyed in GstElementClass::pad_removed */ + + return tspad->pad; +} + +static void +mpegts_parse_free_program (MpegTSParseProgram * program) +{ + if (program->pmt_info) + g_object_unref (program->pmt_info); + + g_hash_table_destroy (program->streams); + + g_free (program); +} + +static void +mpegts_parse_remove_program (MpegTSParse * parse, gint program_number) +{ + g_hash_table_remove (parse->programs, GINT_TO_POINTER (program_number)); +} + +static void +mpegts_parse_sync_program_pads (MpegTSParse * parse, + GList * to_add, GList * to_remove) +{ + GList *walk; + + for (walk = to_remove; walk; walk = walk->next) + gst_element_remove_pad (GST_ELEMENT (parse), GST_PAD (walk->data)); + + for (walk = to_add; walk; walk = walk->next) + gst_element_add_pad (GST_ELEMENT (parse), GST_PAD (walk->data)); + + if (to_add) + g_list_free (to_add); + + if (to_remove) + g_list_free (to_remove); +} + + +static MpegTSParseStream * +mpegts_parse_program_add_stream (MpegTSParse * parse, + MpegTSParseProgram * program, guint16 pid, guint8 stream_type) +{ + MpegTSParseStream *stream; + + stream = g_new0 (MpegTSParseStream, 1); + stream->pid = pid; + stream->stream_type = stream_type; + + g_hash_table_insert (program->streams, GINT_TO_POINTER ((gint) pid), stream); + + return stream; +} + +static void +foreach_program_activate_or_deactivate (gpointer key, gpointer value, + gpointer data) +{ + MpegTSParse *parse = GST_MPEGTS_PARSE (data); + MpegTSParseProgram *program = (MpegTSParseProgram *) value; + + /* at this point selected programs have program->selected == 2, + * unselected programs thay may have to be deactivated have selected == 1 and + * unselected inactive programs have selected == 0 */ + + switch (--program->selected) { + case 1: + /* selected */ + if (!program->active && program->pmt_pid != G_MAXUINT16) + parse->pads_to_add = g_list_append (parse->pads_to_add, + mpegts_parse_activate_program (parse, program)); + break; + case 0: + /* unselected */ + if (program->active) + parse->pads_to_remove = g_list_append (parse->pads_to_remove, + mpegts_parse_deactivate_program (parse, program)); + break; + case -1: + /* was already unselected */ + program->selected = 0; + break; + default: + g_return_if_reached (); + } +} + +static void +mpegts_parse_reset_selected_programs (MpegTSParse * parse, + gchar * program_numbers) +{ + GList *pads_to_add = NULL; + GList *pads_to_remove = NULL; + + GST_OBJECT_LOCK (parse); + if (parse->program_numbers) + g_free (parse->program_numbers); + + parse->program_numbers = program_numbers; + + if (*parse->program_numbers != '\0') { + gint program_number; + MpegTSParseProgram *program; + gchar **progs, **walk; + + progs = g_strsplit (parse->program_numbers, ":", 0); + + walk = progs; + while (*walk != NULL) { + program_number = strtol (*walk, NULL, 0); + program = mpegts_parse_get_program (parse, program_number); + if (program == NULL) + /* create the program, it will get activated once we get a PMT for it */ + program = mpegts_parse_add_program (parse, program_number, G_MAXUINT16); + + program->selected = 2; + ++walk; + } + g_strfreev (progs); + } + + g_hash_table_foreach (parse->programs, + foreach_program_activate_or_deactivate, parse); + + pads_to_add = parse->pads_to_add; + parse->pads_to_add = NULL; + pads_to_remove = parse->pads_to_remove; + parse->pads_to_remove = NULL; + GST_OBJECT_UNLOCK (parse); + + mpegts_parse_sync_program_pads (parse, pads_to_add, pads_to_remove); +} + +static void +mpegts_parse_free_stream (MpegTSParseStream * stream) +{ + g_free (stream); +} + +static void +mpegts_parse_program_remove_stream (MpegTSParse * parse, + MpegTSParseProgram * program, guint16 pid) +{ + g_hash_table_remove (program->streams, GINT_TO_POINTER ((gint) pid)); +} + +static MpegTSParsePad * +mpegts_parse_create_tspad (MpegTSParse * parse, const gchar * pad_name) +{ + GstPad *pad; + MpegTSParsePad *tspad; + + pad = gst_pad_new_from_static_template (&program_template, pad_name); + + /* create our wrapper */ + tspad = g_new0 (MpegTSParsePad, 1); + tspad->pad = pad; + tspad->program_number = -1; + tspad->program = NULL; + tspad->pushed = FALSE; + tspad->flow_return = GST_FLOW_NOT_LINKED; + gst_pad_set_element_private (pad, tspad); + + return tspad; +} + +static void +mpegts_parse_destroy_tspad (MpegTSParse * parse, MpegTSParsePad * tspad) +{ + /* free the wrapper */ + g_free (tspad); +} + +static void +mpegts_parse_pad_removed (GstElement * element, GstPad * pad) +{ + MpegTSParsePad *tspad; + MpegTSParse *parse = GST_MPEGTS_PARSE (element); + + if (gst_pad_get_direction (pad) == GST_PAD_SINK) + return; + + tspad = (MpegTSParsePad *) gst_pad_get_element_private (pad); + mpegts_parse_destroy_tspad (parse, tspad); +} + +static GstFlowReturn +mpegts_parse_tspad_push (MpegTSParse * parse, MpegTSParsePad * tspad, + guint16 pid, GstBuffer * buffer) +{ + GstFlowReturn ret = GST_FLOW_NOT_LINKED; + GHashTable *pad_pids = NULL; + guint16 pmt_pid = G_MAXUINT16; + + if (tspad->program_number != -1) { + if (tspad->program) { + pad_pids = tspad->program->streams; + pmt_pid = tspad->program->pmt_pid; + } else { + /* there's a program filter on the pad but the PMT for the program has not + * been parsed yet, ignore the pad until we get a PMT */ + gst_buffer_unref (buffer); + ret = GST_FLOW_OK; + goto out; + } + } + + /* FIXME: send all the SI pids not only PAT and PMT */ + if (pad_pids == NULL || pid == 0 || pid == pmt_pid || + g_hash_table_lookup (pad_pids, GINT_TO_POINTER ((gint) pid)) != NULL) { + /* push if there's no filter or if the pid is in the filter */ + ret = gst_pad_push (tspad->pad, buffer); + } else { + gst_buffer_unref (buffer); + /* caps don't include this pid */ + if (gst_pad_is_linked (tspad->pad)) + ret = GST_FLOW_OK; + } + +out: + return ret; +} + +static void +pad_clear_for_push (GstPad * pad, MpegTSParse * parse) +{ + MpegTSParsePad *tspad = (MpegTSParsePad *) gst_pad_get_element_private (pad); + + tspad->flow_return = GST_FLOW_NOT_LINKED; + tspad->pushed = FALSE; +} + +static GstFlowReturn +mpegts_parse_push (MpegTSParse * parse, MpegTSPacketizerPacket * packet) +{ + GstIterator *iterator; + gboolean done = FALSE; + gpointer pad = NULL; + MpegTSParsePad *tspad; + guint16 pid; + GstBuffer *buffer; + GstFlowReturn ret = GST_FLOW_NOT_LINKED; + GstCaps *caps; + + pid = packet->pid; + caps = gst_pad_get_caps (parse->srcpad); + buffer = packet->buffer; + gst_buffer_set_caps (buffer, caps); + gst_caps_unref (caps); + + GST_OBJECT_LOCK (parse); + /* clear tspad->pushed on pads */ + g_list_foreach (GST_ELEMENT_CAST (parse)->srcpads, + (GFunc) pad_clear_for_push, parse); + GST_OBJECT_UNLOCK (parse); + + iterator = gst_element_iterate_src_pads (GST_ELEMENT_CAST (parse)); + while (!done) { + switch (gst_iterator_next (iterator, &pad)) { + case GST_ITERATOR_OK: + tspad = gst_pad_get_element_private (GST_PAD (pad)); + + /* make sure to push only once if the iterator resyncs */ + if (!tspad->pushed) { + /* ref the buffer as gst_pad_push takes a ref but we want to reuse the + * same buffer for next pushes */ + gst_buffer_ref (buffer); + tspad->flow_return = + mpegts_parse_tspad_push (parse, tspad, pid, buffer); + tspad->pushed = TRUE; + + if (GST_FLOW_IS_FATAL (tspad->flow_return)) { + /* return the error upstream */ + ret = tspad->flow_return; + done = TRUE; + } + } + + if (ret == GST_FLOW_NOT_LINKED) + ret = tspad->flow_return; + + /* the iterator refs the pad */ + g_object_unref (GST_PAD (pad)); + break; + case GST_ITERATOR_RESYNC: + gst_iterator_resync (iterator); + break; + case GST_ITERATOR_DONE: + done = TRUE; + break; + default: + g_warning ("this should not be reached"); + } + } + + gst_iterator_free (iterator); + + gst_buffer_unref (buffer); + packet->buffer = NULL; + + return ret; +} + +static gboolean +mpegts_parse_is_psi_pid (MpegTSParse * parse, guint16 pid) +{ + return g_hash_table_lookup (parse->psi_pids, + GINT_TO_POINTER ((gint) pid)) != NULL; +} + +static void +mpegts_parse_apply_pat (MpegTSParse * parse, GValueArray * pat_info) +{ + GValue *value; + GValueArray *old_pat; + GObject *program_info; + gint program_number; + guint pid; + MpegTSParseProgram *program; + gint i; + GList *pads_to_add = NULL; + GList *pads_to_remove = NULL; + + old_pat = parse->pat_info; + parse->pat_info = pat_info; + g_object_notify (G_OBJECT (parse), "pat-info"); + + GST_OBJECT_LOCK (parse); + /* activate the new table */ + for (i = 0; i < pat_info->n_values; ++i) { + value = g_value_array_get_nth (pat_info, i); + + program_info = g_value_get_object (value); + g_object_get (program_info, + "program-number", &program_number, "pid", &pid, NULL); + + program = mpegts_parse_get_program (parse, program_number); + if (program) { + if (program->pmt_pid != pid) { + if (program->pmt_pid != G_MAXUINT16) { + /* pmt pid changed */ + g_hash_table_remove (parse->psi_pids, + GINT_TO_POINTER ((gint) program->pmt_pid)); + } + + program->pmt_pid = pid; + g_hash_table_insert (parse->psi_pids, + GINT_TO_POINTER ((gint) pid), GINT_TO_POINTER (1)); + } + + program->patcount += 1; + } else { + GST_INFO_OBJECT (parse, "PAT adding program %d pmt_pid %d", + program_number, pid); + + g_hash_table_insert (parse->psi_pids, + GINT_TO_POINTER ((gint) pid), GINT_TO_POINTER (1)); + program = mpegts_parse_add_program (parse, program_number, pid); + } + + if (program->selected && !program->active) + parse->pads_to_add = g_list_append (parse->pads_to_add, + mpegts_parse_activate_program (parse, program)); + } + + if (old_pat) { + /* deactivate the old table */ + + for (i = 0; i < old_pat->n_values; ++i) { + value = g_value_array_get_nth (old_pat, i); + + program_info = g_value_get_object (value); + g_object_get (program_info, + "program-number", &program_number, "pid", &pid, NULL); + + program = mpegts_parse_get_program (parse, program_number); + if (program->patcount-- == 1) + /* the program has been referenced by the new pat, keep it */ + continue; + + GST_INFO_OBJECT (parse, "PAT removing program %d pmt_pid %d", + program_number, pid); + + if (program->active) + parse->pads_to_remove = g_list_append (parse->pads_to_remove, + mpegts_parse_deactivate_program (parse, program)); + + mpegts_parse_remove_program (parse, program_number); + g_hash_table_remove (parse->psi_pids, GINT_TO_POINTER ((gint) pid)); + } + + g_value_array_free (old_pat); + } + + pads_to_add = parse->pads_to_add; + parse->pads_to_add = NULL; + pads_to_remove = parse->pads_to_remove; + parse->pads_to_remove = NULL; + GST_OBJECT_UNLOCK (parse); + + mpegts_parse_sync_program_pads (parse, pads_to_add, pads_to_remove); +} + +static void +mpegts_parse_apply_pmt (MpegTSParse * parse, + guint16 pmt_pid, GObject * pmt_info) +{ + MpegTSParseProgram *program; + gint program_number; + guint pcr_pid; + guint pid; + guint stream_type; + GValueArray *old_streams; + GValueArray *new_streams; + GValue *value; + GObject *stream; + gint i; + + g_object_get (pmt_info, "program_number", &program_number, + "pcr-pid", &pcr_pid, "stream-info", &new_streams, NULL); + + GST_OBJECT_LOCK (parse); + program = mpegts_parse_get_program (parse, program_number); + if (program) { + if (program->pmt_info) { + /* deactivate old pmt */ + g_object_get (program->pmt_info, "stream-info", &old_streams, NULL); + + for (i = 0; i < old_streams->n_values; ++i) { + value = g_value_array_get_nth (old_streams, i); + stream = g_value_get_object (value); + + g_object_get (stream, "pid", &pid, "stream-type", &stream_type, NULL); + mpegts_parse_program_remove_stream (parse, program, (guint16) pid); + } + + g_value_array_free (old_streams); + g_object_unref (program->pmt_info); + } + } else { + /* no PAT?? */ + g_hash_table_insert (parse->psi_pids, + GINT_TO_POINTER ((gint) pmt_pid), GINT_TO_POINTER (1)); + program = mpegts_parse_add_program (parse, program_number, pid); + } + + /* activate new pmt */ + program->pmt_info = pmt_info; + program->pmt_pid = pmt_pid; + mpegts_parse_program_add_stream (parse, program, (guint16) pcr_pid, -1); + + for (i = 0; i < new_streams->n_values; ++i) { + value = g_value_array_get_nth (new_streams, i); + stream = g_value_get_object (value); + + g_object_get (stream, "pid", &pid, "stream-type", &stream_type, NULL); + mpegts_parse_program_add_stream (parse, program, (guint16) pid, + (guint8) stream_type); + } + GST_OBJECT_UNLOCK (parse); + + g_value_array_free (new_streams); + + g_signal_emit (parse, signals[SIGNAL_PMT], 0, program_number, pmt_info); +} + +static gboolean +mpegts_parse_handle_psi (MpegTSParse * parse, MpegTSPacketizerSection * section) +{ + gboolean res = TRUE; + + switch (section->table_id) { + case 0x00: + { + /* PAT */ + GValueArray *pat_info; + + pat_info = mpegts_packetizer_parse_pat (parse->packetizer, section); + if (pat_info) + mpegts_parse_apply_pat (parse, pat_info); + else + res = FALSE; + + break; + } + case 0x02: + { + /* PMT */ + GObject *pmt_info; + + pmt_info = mpegts_packetizer_parse_pmt (parse->packetizer, section); + if (pmt_info) + mpegts_parse_apply_pmt (parse, section->pid, pmt_info); + else + res = FALSE; + + break; + } + default: + break; + } + + return res; +} + +static gboolean +mpegts_parse_sink_event (GstPad * pad, GstEvent * event) +{ + gboolean res; + MpegTSParse *parse = + GST_MPEGTS_PARSE (gst_object_get_parent (GST_OBJECT (pad))); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_FLUSH_STOP: + mpegts_packetizer_clear (parse->packetizer); + res = gst_pad_event_default (pad, event); + break; + default: + res = gst_pad_event_default (pad, event); + } + + gst_object_unref (parse); + return res; +} + +static GstFlowReturn +mpegts_parse_chain (GstPad * pad, GstBuffer * buf) +{ + GstFlowReturn res = GST_FLOW_OK; + MpegTSParse *parse; + gboolean parsed; + MpegTSPacketizer *packetizer; + MpegTSPacketizerPacket packet; + + parse = GST_MPEGTS_PARSE (gst_object_get_parent (GST_OBJECT (pad))); + packetizer = parse->packetizer; + + mpegts_packetizer_push (parse->packetizer, buf); + while (mpegts_packetizer_has_packets (parse->packetizer) && + !GST_FLOW_IS_FATAL (res)) { + /* get the next packet */ + parsed = mpegts_packetizer_next_packet (packetizer, &packet); + if (!parsed) + /* bad header, skip the packet */ + goto next; + + /* parse PSI data */ + if (packet.payload != NULL && mpegts_parse_is_psi_pid (parse, packet.pid)) { + MpegTSPacketizerSection section; + + parsed = mpegts_packetizer_push_section (packetizer, &packet, §ion); + if (!parsed) + /* bad section data */ + goto next; + + if (section.complete) { + /* section complete */ + parsed = mpegts_parse_handle_psi (parse, §ion); + gst_buffer_unref (section.buffer); + if (!parsed) + /* bad PSI table */ + goto next; + } + } + + /* push the packet downstream */ + res = mpegts_parse_push (parse, &packet); + + next: + mpegts_packetizer_clear_packet (parse->packetizer, &packet); + } + + gst_object_unref (parse); + return res; +} + +static GstStateChangeReturn +mpegts_parse_change_state (GstElement * element, GstStateChange transition) +{ + MpegTSParse *parse; + GstStateChangeReturn ret; + + parse = GST_MPEGTS_PARSE (element); + ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + mpegts_parse_reset (parse); + break; + default: + break; + } + + return ret; +} + +static gboolean +plugin_init (GstPlugin * plugin) +{ + GST_DEBUG_CATEGORY_INIT (mpegts_parse_debug, "mpegtsparse", 0, + "MPEG transport stream parser"); + + mpegts_packetizer_init_debug (); + + return gst_element_register (plugin, "mpegtsparse", + GST_RANK_NONE, GST_TYPE_MPEGTS_PARSE); +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "mpegtsparse", + "MPEG-2 transport stream parser", + plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) diff --git a/gst/mpegtsparse/mpegtsparse.h b/gst/mpegtsparse/mpegtsparse.h new file mode 100644 index 00000000..cace953a --- /dev/null +++ b/gst/mpegtsparse/mpegtsparse.h @@ -0,0 +1,77 @@ +/* + * mpegts_parse.h - GStreamer MPEG transport stream parser + * Copyright (C) 2007 Alessandro Decina + * + * Authors: + * Alessandro Decina + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + + +#ifndef GST_MPEG_TS_PARSE_H +#define GST_MPEG_TS_PARSE_H + +#include +#include "mpegtspacketizer.h" + +G_BEGIN_DECLS + +#define GST_TYPE_MPEGTS_PARSE \ + (mpegts_parse_get_type()) +#define GST_MPEGTS_PARSE(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MPEGTS_PARSE,MpegTSParse)) +#define GST_MPEGTS_PARSE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MPEGTS_PARSE,MpegTSParseClass)) +#define GST_IS_MPEGTS_PARSE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MPEGTS_PARSE)) +#define GST_IS_MPEGTS_PARSE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MPEGTS_PARSE)) + +typedef struct _MpegTSParse MpegTSParse; +typedef struct _MpegTSParseClass MpegTSParseClass; + +struct _MpegTSParse { + GstElement element; + + GstPad *sinkpad; + GstPad *srcpad; + + /* the following vars must be protected with the OBJECT_LOCK as they can be + * accessed from the application thread and the streaming thread */ + gchar *program_numbers; + GList *pads_to_add; + GList *pads_to_remove; + GHashTable *programs; + + GValueArray *pat_info; + MpegTSPacketizer *packetizer; + GHashTable *psi_pids; + gboolean disposed; +}; + +struct _MpegTSParseClass { + GstElementClass parent_class; + + /* signals */ + void (*pmt_info) (GObject *pmt_info); +}; + +GType gst_mpegts_parse_get_type(void); + +G_END_DECLS + +#endif /* GST_MPEG_TS_PARSE_H */ diff --git a/gst/mpegtsparse/mpegtsparsemarshal.list b/gst/mpegtsparse/mpegtsparsemarshal.list new file mode 100644 index 00000000..41e7f2b5 --- /dev/null +++ b/gst/mpegtsparse/mpegtsparsemarshal.list @@ -0,0 +1 @@ +VOID:INT,OBJECT -- cgit v1.2.1