+2007-08-20 Zaheer Abbas Merali <zaheerabbas at merali dot org>
+
+ * 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 <tim at centricular dot net>
Patch by: Bastien Nocera <hadess at hadess net>
-Subproject commit b3fe2a25c1cd0f4b021795d0db7330aeb338da7c
+Subproject commit 9c7f1a63dfed1b2770b5fdaa16e0ae114b2177cf
interleave \
librfb \
modplug \
+ mpegtsparse \
mpegvideoparse \
multifile \
mve \
gst/librfb/Makefile
gst/modplug/Makefile
gst/modplug/libmodplug/Makefile
+gst/mpegtsparse/Makefile
gst/mpegvideoparse/Makefile
gst/multifile/Makefile
gst/mve/Makefile
--- /dev/null
+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
--- /dev/null
+/*
+ * 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 <jan@fluendo.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+
+#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;
+ }
+}
--- /dev/null
+/*
+ * 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 <jan@fluendo.com>
+ */
+
+#ifndef __MPEGTS_PAT_INFO_H__
+#define __MPEGTS_PAT_INFO_H__
+
+#include <glib.h>
+
+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
--- /dev/null
+/*
+ * 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 <jan@fluendo.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+
+#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);
+}
--- /dev/null
+/*
+ * 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 <jan@fluendo.com>
+ */
+
+#ifndef __MPEGTS_PMT_INFO_H__
+#define __MPEGTS_PMT_INFO_H__
+
+#include <glib.h>
+#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
--- /dev/null
+/*
+ * 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 <jan@fluendo.com>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <gst/gst.h>
+
+#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;
+ }
+}
--- /dev/null
+/*
+ * 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 <jan@fluendo.com>
+ */
+
+#ifndef __MPEGTS_PMT_STREAM_INFO_H__
+#define __MPEGTS_PMT_STREAM_INFO_H__
+
+#include <glib.h>
+
+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
--- /dev/null
+/*
+ * mpegtspacketizer.c -
+ * Copyright (C) 2007 Alessandro Decina
+ *
+ * Authors:
+ * Alessandro Decina <alessandro@nnva.org>
+ *
+ * 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");
+}
--- /dev/null
+/*
+ * mpegtspacketizer.h -
+ * Copyright (C) 2007 Alessandro Decina
+ *
+ * Authors:
+ * Alessandro Decina <alessandro@nnva.org>
+ *
+ * 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 <gst/gst.h>
+#include <gst/base/gstadapter.h>
+#include <glib.h>
+
+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 */
--- /dev/null
+/*
+ * mpegtsparse.c -
+ * Copyright (C) 2007 Alessandro Decina
+ *
+ * Authors:
+ * Alessandro Decina <alessandro@nnva.org>
+ *
+ * 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 <alessandro@nnva.org>");
+
+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)
--- /dev/null
+/*
+ * mpegts_parse.h - GStreamer MPEG transport stream parser
+ * Copyright (C) 2007 Alessandro Decina
+ *
+ * Authors:
+ * Alessandro Decina <alessandro@nnva.org>
+ *
+ * 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 <gst/gst.h>
+#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 */
--- /dev/null
+VOID:INT,OBJECT
projects / platform / upstream / gstreamer.git / commitdiff