mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-10-02 16:52:42 +00:00
Code Issues 1 Projects Releases Wiki Activity

Add mpeg transport stream parser written by:

Browse source 
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.
This commit is contained in:
Zaheer Abbas Merali 2007-08-20 14:23:45 +00:00
parent cd2e9804d6
commit e6c86a500d
15 changed files with 2491 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
ChangeLog
View file

@ -1,3 +1,23 @@
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>

2
common

@ -1 +1 @@
Subproject commit b3fe2a25c1cd0f4b021795d0db7330aeb338da7c
Subproject commit 9c7f1a63dfed1b2770b5fdaa16e0ae114b2177cf

2
configure.ac
View file

@ -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

38
gst/mpegtsparse/Makefile.am Normal file
View file

@ -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

116
gst/mpegtsparse/flutspatinfo.c Normal file
View file

@ -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 <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;
}
}

49
gst/mpegtsparse/flutspatinfo.h Normal file
View file

@ -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 <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

197
gst/mpegtsparse/flutspmtinfo.c Normal file
View file

@ -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 <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);
}

58
gst/mpegtsparse/flutspmtinfo.h Normal file
View file

@ -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 <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

181
gst/mpegtsparse/flutspmtstreaminfo.c Normal file
View file

@ -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 <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;
}
}

55
gst/mpegtsparse/flutspmtstreaminfo.h Normal file
View file

@ -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 <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

619
gst/mpegtsparse/mpegtspacketizer.c Normal file
View file

@ -0,0 +1,619 @@
/*
* 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");
}

107
gst/mpegtsparse/mpegtspacketizer.h Normal file
View file

@ -0,0 +1,107 @@
/*
* 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 */

970
gst/mpegtsparse/mpegtsparse.c Normal file
View file

@ -0,0 +1,970 @@
/*
* 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, &section);
if (!parsed)
/* bad section data */
goto next;
if (section.complete) {
/* section complete */
parsed = mpegts_parse_handle_psi (parse, &section);
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)

77
gst/mpegtsparse/mpegtsparse.h Normal file
View file

@ -0,0 +1,77 @@
/*
* 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 */

1
gst/mpegtsparse/mpegtsparsemarshal.list Normal file
View file

@ -0,0 +1 @@
VOID:INT,OBJECT