From 555486f865d6933da9cf983fc161e56474468ec4 Mon Sep 17 00:00:00 2001 From: Zaheer Abbas Merali Date: Tue, 2 Sep 2008 12:04:32 +0000 Subject: [PATCH] Add Fluendo MPEG PS and TS demuxers to gst-plugins-bad. This is now dual licensed MPL and LGPL. Original commit message from CVS: * configure.ac: * gst/mpegdemux/Makefile.am: * gst/mpegdemux/flumpegdemux.c: * gst/mpegdemux/flutspatinfo.c: * gst/mpegdemux/flutspatinfo.h: * gst/mpegdemux/flutspmtinfo.c: * gst/mpegdemux/flutspmtinfo.h: * gst/mpegdemux/flutspmtstreaminfo.c: * gst/mpegdemux/flutspmtstreaminfo.h: * gst/mpegdemux/gstmpegdefs.h: * gst/mpegdemux/gstmpegdemux.c: * gst/mpegdemux/gstmpegdemux.h: * gst/mpegdemux/gstmpegdesc.c: * gst/mpegdemux/gstmpegdesc.h: * gst/mpegdemux/gstmpegtsdemux.c: * gst/mpegdemux/gstmpegtsdemux.h: * gst/mpegdemux/gstpesfilter.c: * gst/mpegdemux/gstpesfilter.h: * gst/mpegdemux/gstsectionfilter.c: * gst/mpegdemux/gstsectionfilter.h: Add Fluendo MPEG PS and TS demuxers to gst-plugins-bad. This is now dual licensed MPL and LGPL. --- ChangeLog | 25 + configure.ac | 2 + gst/mpegdemux/Makefile.am | 28 + gst/mpegdemux/flumpegdemux.c | 74 + gst/mpegdemux/flutspatinfo.c | 139 ++ gst/mpegdemux/flutspatinfo.h | 72 + gst/mpegdemux/flutspmtinfo.c | 218 +++ gst/mpegdemux/flutspmtinfo.h | 81 ++ gst/mpegdemux/flutspmtstreaminfo.c | 203 +++ gst/mpegdemux/flutspmtstreaminfo.h | 80 ++ gst/mpegdemux/gstmpegdefs.h | 197 +++ gst/mpegdemux/gstmpegdemux.c | 1869 +++++++++++++++++++++++++ gst/mpegdemux/gstmpegdemux.h | 152 +++ gst/mpegdemux/gstmpegdesc.c | 178 +++ gst/mpegdemux/gstmpegdesc.h | 271 ++++ gst/mpegdemux/gstmpegtsdemux.c | 2630 ++++++++++++++++++++++++++++++++++++ gst/mpegdemux/gstmpegtsdemux.h | 224 +++ gst/mpegdemux/gstpesfilter.c | 645 +++++++++ gst/mpegdemux/gstpesfilter.h | 110 ++ gst/mpegdemux/gstsectionfilter.c | 161 +++ gst/mpegdemux/gstsectionfilter.h | 69 + 21 files changed, 7428 insertions(+) create mode 100644 gst/mpegdemux/Makefile.am create mode 100644 gst/mpegdemux/flumpegdemux.c create mode 100644 gst/mpegdemux/flutspatinfo.c create mode 100644 gst/mpegdemux/flutspatinfo.h create mode 100644 gst/mpegdemux/flutspmtinfo.c create mode 100644 gst/mpegdemux/flutspmtinfo.h create mode 100644 gst/mpegdemux/flutspmtstreaminfo.c create mode 100644 gst/mpegdemux/flutspmtstreaminfo.h create mode 100644 gst/mpegdemux/gstmpegdefs.h create mode 100644 gst/mpegdemux/gstmpegdemux.c create mode 100644 gst/mpegdemux/gstmpegdemux.h create mode 100644 gst/mpegdemux/gstmpegdesc.c create mode 100644 gst/mpegdemux/gstmpegdesc.h create mode 100644 gst/mpegdemux/gstmpegtsdemux.c create mode 100644 gst/mpegdemux/gstmpegtsdemux.h create mode 100644 gst/mpegdemux/gstpesfilter.c create mode 100644 gst/mpegdemux/gstpesfilter.h create mode 100644 gst/mpegdemux/gstsectionfilter.c create mode 100644 gst/mpegdemux/gstsectionfilter.h diff --git a/ChangeLog b/ChangeLog index 870c66e..9a7f44e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,28 @@ +2008-09-02 Zaheer Abbas Merali + + * configure.ac: + * gst/mpegdemux/Makefile.am: + * gst/mpegdemux/flumpegdemux.c: + * gst/mpegdemux/flutspatinfo.c: + * gst/mpegdemux/flutspatinfo.h: + * gst/mpegdemux/flutspmtinfo.c: + * gst/mpegdemux/flutspmtinfo.h: + * gst/mpegdemux/flutspmtstreaminfo.c: + * gst/mpegdemux/flutspmtstreaminfo.h: + * gst/mpegdemux/gstmpegdefs.h: + * gst/mpegdemux/gstmpegdemux.c: + * gst/mpegdemux/gstmpegdemux.h: + * gst/mpegdemux/gstmpegdesc.c: + * gst/mpegdemux/gstmpegdesc.h: + * gst/mpegdemux/gstmpegtsdemux.c: + * gst/mpegdemux/gstmpegtsdemux.h: + * gst/mpegdemux/gstpesfilter.c: + * gst/mpegdemux/gstpesfilter.h: + * gst/mpegdemux/gstsectionfilter.c: + * gst/mpegdemux/gstsectionfilter.h: + Add Fluendo MPEG PS and TS demuxers to gst-plugins-bad. This + is now dual licensed MPL and LGPL. + 2008-09-02 Wim Taymans * gst/mpegtsmux/mpegtsmux.c: (new_packet_cb): diff --git a/configure.ac b/configure.ac index c741e34..8ec0f6e 100644 --- a/configure.ac +++ b/configure.ac @@ -256,6 +256,7 @@ AG_GST_CHECK_PLUGIN(freeze) AG_GST_CHECK_PLUGIN(h264parse) AG_GST_CHECK_PLUGIN(librfb) AG_GST_CHECK_PLUGIN(modplug) +AG_GST_CHECK_PLUGIN(mpegdemux) AG_GST_CHECK_PLUGIN(mpegtsparse) AG_GST_CHECK_PLUGIN(mpegtsmux) AG_GST_CHECK_PLUGIN(mpeg4videoparse) @@ -1399,6 +1400,7 @@ gst/h264parse/Makefile gst/librfb/Makefile gst/modplug/Makefile gst/modplug/libmodplug/Makefile +gst/mpegdemux/Makefile gst/mpegtsparse/Makefile gst/mpegtsmux/Makefile gst/mpegtsmux/tsmux/Makefile diff --git a/gst/mpegdemux/Makefile.am b/gst/mpegdemux/Makefile.am new file mode 100644 index 0000000..e078475 --- /dev/null +++ b/gst/mpegdemux/Makefile.am @@ -0,0 +1,28 @@ +plugin_LTLIBRARIES = libgstmpegdemux.la + +libgstmpegdemux_la_SOURCES = \ + flumpegdemux.c \ + flutspatinfo.c \ + flutspmtinfo.c \ + flutspmtstreaminfo.c \ + gstmpegdemux.c \ + gstmpegdesc.c \ + gstmpegtsdemux.c \ + gstpesfilter.c \ + gstsectionfilter.c + +libgstmpegdemux_la_CFLAGS = $(GST_CFLAGS) $(LIBOIL_CFLAGS) +libgstmpegdemux_la_LIBADD = $(GST_BASE_LIBS) $(GST_LIBS) $(LIBOIL_LIBS) +libgstmpegdemux_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + +noinst_HEADERS = \ + gstmpegdefs.h \ + gstmpegdesc.h \ + gstmpegdemux.h \ + gstpesfilter.h \ + gstmpegtsdemux.h \ + flutspatinfo.h \ + flutspmtinfo.h \ + flutspmtstreaminfo.h \ + gstsectionfilter.h + diff --git a/gst/mpegdemux/flumpegdemux.c b/gst/mpegdemux/flumpegdemux.c new file mode 100644 index 0000000..1121b18 --- /dev/null +++ b/gst/mpegdemux/flumpegdemux.c @@ -0,0 +1,74 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstmpegdemux.h" +#include "gstmpegtsdemux.h" + +GST_DEBUG_CATEGORY_EXTERN (gstflupesfilter_debug); +GST_DEBUG_CATEGORY_EXTERN (gstflusectionfilter_debug); +static gboolean +plugin_init (GstPlugin * plugin) +{ + GST_DEBUG_CATEGORY_INIT (gstflupesfilter_debug, "flupesfilter", 0, + "MPEG-TS/PS PES filter output"); + GST_DEBUG_CATEGORY_INIT (gstflusectionfilter_debug, "flusectionfilter", 0, + "MPEG-TS Section filter output"); + + if (!gst_flups_demux_plugin_init (plugin)) + return FALSE; + if (!gst_fluts_demux_plugin_init (plugin)) + return FALSE; + + return TRUE; +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "flumpegdemux", + "MPEG demuxers", + plugin_init, VERSION, + GST_LICENSE_UNKNOWN, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN); diff --git a/gst/mpegdemux/flutspatinfo.c b/gst/mpegdemux/flutspatinfo.c new file mode 100644 index 0000000..ec1a8b6 --- /dev/null +++ b/gst/mpegdemux/flutspatinfo.c @@ -0,0 +1,139 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "flutspatinfo.h" + +enum +{ + PROP_0, + PROP_PROGRAM_NO, + PROP_PID +}; + +static void fluts_pat_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec); +static void fluts_pat_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec); + +GST_BOILERPLATE (FluTsPatInfo, fluts_pat_info, GObject, G_TYPE_OBJECT); + +FluTsPatInfo * +fluts_pat_info_new (guint16 program_no, guint16 pid) +{ + FluTsPatInfo *info; + + info = g_object_new (FLUTS_TYPE_PAT_INFO, NULL); + + info->program_no = program_no; + info->pid = pid; + + return info; +} + +static void +fluts_pat_info_base_init (gpointer klass) +{ +} + +static void +fluts_pat_info_class_init (FluTsPatInfoClass * klass) +{ + GObjectClass *gobject_klass = (GObjectClass *) klass; + + gobject_klass->set_property = fluts_pat_info_set_property; + gobject_klass->get_property = fluts_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 +fluts_pat_info_init (FluTsPatInfo * pat_info, FluTsPatInfoClass * klass) +{ +} + +static void +fluts_pat_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec) +{ + g_return_if_fail (FLUTS_IS_PAT_INFO (object)); + + /* No settable properties */ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); +} + +static void +fluts_pat_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec) +{ + FluTsPatInfo *pat_info; + + g_return_if_fail (FLUTS_IS_PAT_INFO (object)); + + pat_info = FLUTS_PAT_INFO (object); + + switch (prop_id) { + case PROP_PROGRAM_NO: + g_value_set_uint (value, pat_info->program_no); + break; + case PROP_PID: + g_value_set_uint (value, pat_info->pid); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); + break; + } +} diff --git a/gst/mpegdemux/flutspatinfo.h b/gst/mpegdemux/flutspatinfo.h new file mode 100644 index 0000000..3e93fac --- /dev/null +++ b/gst/mpegdemux/flutspatinfo.h @@ -0,0 +1,72 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifndef __FLUTS_PAT_INFO_H__ +#define __FLUTS_PAT_INFO_H__ + +#include + +G_BEGIN_DECLS + +typedef struct FluTsPatInfoClass { + GObjectClass parent_class; +} FluTsPatInfoClass; + +typedef struct FluTsPatInfo { + GObject parent; + + guint16 pid; + guint16 program_no; +} FluTsPatInfo; + +#define FLUTS_TYPE_PAT_INFO (fluts_pat_info_get_type ()) +#define FLUTS_IS_PAT_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), FLUTS_TYPE_PAT_INFO)) +#define FLUTS_PAT_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),FLUTS_TYPE_PAT_INFO, FluTsPatInfo)) + +GType fluts_pat_info_get_type (void); + +FluTsPatInfo *fluts_pat_info_new (guint16 program_no, guint16 pid); + +G_END_DECLS + +#endif diff --git a/gst/mpegdemux/flutspmtinfo.c b/gst/mpegdemux/flutspmtinfo.c new file mode 100644 index 0000000..0f643bb --- /dev/null +++ b/gst/mpegdemux/flutspmtinfo.c @@ -0,0 +1,218 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "flutspmtinfo.h" + +enum +{ + PROP_0, + PROP_PROGRAM_NO, + PROP_VERSION_NO, + PROP_PCR_PID, + PROP_DESCRIPTORS, + PROP_STREAMINFO +}; + +GST_BOILERPLATE (FluTsPmtInfo, fluts_pmt_info, GObject, G_TYPE_OBJECT); + +static void fluts_pmt_info_finalize (GObject * object); +static void fluts_pmt_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec); +static void fluts_pmt_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec); + +static void +fluts_pmt_info_base_init (gpointer klass) +{ +} + +static void +fluts_pmt_info_class_init (FluTsPmtInfoClass * klass) +{ + GObjectClass *gobject_klass = (GObjectClass *) klass; + + gobject_klass->finalize = fluts_pmt_info_finalize; + gobject_klass->set_property = fluts_pmt_info_set_property; + gobject_klass->get_property = fluts_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", + FLUTS_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 +fluts_pmt_info_init (FluTsPmtInfo * pmt_info, FluTsPmtInfoClass * klass) +{ + pmt_info->streams = g_value_array_new (0); + pmt_info->descriptors = g_value_array_new (0); +} + +FluTsPmtInfo * +fluts_pmt_info_new (guint16 program_no, guint16 pcr_pid, guint8 version_no) +{ + FluTsPmtInfo *info; + + info = g_object_new (FLUTS_TYPE_PMT_INFO, NULL); + + info->program_no = program_no; + info->pcr_pid = pcr_pid; + info->version_no = version_no; + + return info; +} + +static void +fluts_pmt_info_finalize (GObject * object) +{ + FluTsPmtInfo *info = FLUTS_PMT_INFO (object); + + g_value_array_free (info->streams); + g_value_array_free (info->descriptors); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +fluts_pmt_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec) +{ + g_return_if_fail (FLUTS_IS_PMT_INFO (object)); + + /* No settable properties */ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); +} + +static void +fluts_pmt_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec) +{ + FluTsPmtInfo *pmt_info; + + g_return_if_fail (FLUTS_IS_PMT_INFO (object)); + + pmt_info = FLUTS_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 +fluts_pmt_info_add_descriptor (FluTsPmtInfo * pmt_info, + const gchar * descriptor, guint length) +{ + GValue value = { 0 }; + GString *string; + + g_return_if_fail (FLUTS_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 +fluts_pmt_info_add_stream (FluTsPmtInfo * pmt_info, FluTsPmtStreamInfo * stream) +{ + GValue v = { 0, }; + + g_return_if_fail (FLUTS_IS_PMT_INFO (pmt_info)); + g_return_if_fail (FLUTS_IS_PMT_STREAM_INFO (stream)); + + g_value_init (&v, G_TYPE_OBJECT); + g_value_take_object (&v, stream); + g_value_array_append (pmt_info->streams, &v); +} diff --git a/gst/mpegdemux/flutspmtinfo.h b/gst/mpegdemux/flutspmtinfo.h new file mode 100644 index 0000000..2c4107e --- /dev/null +++ b/gst/mpegdemux/flutspmtinfo.h @@ -0,0 +1,81 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifndef __FLUTS_PMT_INFO_H__ +#define __FLUTS_PMT_INFO_H__ + +#include +#include "flutspmtstreaminfo.h" + +G_BEGIN_DECLS + +typedef struct FluTsPmtInfoClass { + GObjectClass parent_class; +} FluTsPmtInfoClass; + +typedef struct FluTsPmtInfo { + GObject parent; + + guint16 program_no; + guint16 pcr_pid; + + guint8 version_no; + + GValueArray *descriptors; + GValueArray *streams; +} FluTsPmtInfo; + +FluTsPmtInfo *fluts_pmt_info_new (guint16 program_no, guint16 pcr_pid, guint8 version); +void fluts_pmt_info_add_stream (FluTsPmtInfo *pmt_info, FluTsPmtStreamInfo *stream); +void fluts_pmt_info_add_descriptor (FluTsPmtInfo *pmt_info, + const gchar *descriptor, guint length); + +GType fluts_pmt_info_get_type (void); + +#define FLUTS_TYPE_PMT_INFO (fluts_pmt_info_get_type ()) +#define FLUTS_IS_PMT_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), FLUTS_TYPE_PMT_INFO)) +#define FLUTS_PMT_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),FLUTS_TYPE_PMT_INFO, FluTsPmtInfo)) + +G_END_DECLS + +#endif diff --git a/gst/mpegdemux/flutspmtstreaminfo.c b/gst/mpegdemux/flutspmtstreaminfo.c new file mode 100644 index 0000000..f5b5496 --- /dev/null +++ b/gst/mpegdemux/flutspmtstreaminfo.c @@ -0,0 +1,203 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "flutspmtstreaminfo.h" + +enum +{ + PROP_0, + PROP_PID, + PROP_LANGUAGES, + PROP_STREAM_TYPE, + PROP_DESCRIPTORS, +}; + +GST_BOILERPLATE (FluTsPmtStreamInfo, fluts_pmt_stream_info, GObject, + G_TYPE_OBJECT); + +static void fluts_pmt_stream_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec); +static void fluts_pmt_stream_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec); +static void fluts_pmt_stream_info_finalize (GObject * object); + +static void +fluts_pmt_stream_info_base_init (gpointer klass) +{ +} + +static void +fluts_pmt_stream_info_class_init (FluTsPmtStreamInfoClass * klass) +{ + GObjectClass *gobject_klass = (GObjectClass *) klass; + + gobject_klass->set_property = fluts_pmt_stream_info_set_property; + gobject_klass->get_property = fluts_pmt_stream_info_get_property; + gobject_klass->finalize = fluts_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 +fluts_pmt_stream_info_init (FluTsPmtStreamInfo * pmt_stream_info, + FluTsPmtStreamInfoClass * klass) +{ + pmt_stream_info->languages = g_value_array_new (0); + pmt_stream_info->descriptors = g_value_array_new (0); +} + +static void +fluts_pmt_stream_info_finalize (GObject * object) +{ + FluTsPmtStreamInfo *info = FLUTS_PMT_STREAM_INFO (object); + + g_value_array_free (info->languages); + g_value_array_free (info->descriptors); +} + +FluTsPmtStreamInfo * +fluts_pmt_stream_info_new (guint16 pid, guint8 type) +{ + FluTsPmtStreamInfo *info; + info = g_object_new (FLUTS_TYPE_PMT_STREAM_INFO, NULL); + + info->pid = pid; + info->stream_type = type; + return info; +} + +void +fluts_pmt_stream_info_add_language (FluTsPmtStreamInfo * pmt_info, + gchar * language) +{ + GValue v = { 0, }; + + g_return_if_fail (FLUTS_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 +fluts_pmt_stream_info_add_descriptor (FluTsPmtStreamInfo * pmt_info, + const gchar * descriptor, guint length) +{ + GValue value = { 0 }; + GString *string; + + g_return_if_fail (FLUTS_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 +fluts_pmt_stream_info_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * spec) +{ + g_return_if_fail (FLUTS_IS_PMT_STREAM_INFO (object)); + + /* No settable properties */ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); +} + +static void +fluts_pmt_stream_info_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * spec) +{ + FluTsPmtStreamInfo *si; + + g_return_if_fail (FLUTS_IS_PMT_STREAM_INFO (object)); + + si = FLUTS_PMT_STREAM_INFO (object); + + switch (prop_id) { + case PROP_STREAM_TYPE: + g_value_set_uint (value, si->stream_type); + break; + case PROP_PID: + g_value_set_uint (value, si->pid); + break; + case PROP_LANGUAGES: + g_value_set_boxed (value, si->languages); + break; + case PROP_DESCRIPTORS: + g_value_set_boxed (value, si->descriptors); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec); + break; + } +} diff --git a/gst/mpegdemux/flutspmtstreaminfo.h b/gst/mpegdemux/flutspmtstreaminfo.h new file mode 100644 index 0000000..654daf9 --- /dev/null +++ b/gst/mpegdemux/flutspmtstreaminfo.h @@ -0,0 +1,80 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * The Original Code is Fluendo MPEG Demuxer plugin. + * + * The Initial Developer of the Original Code is Fluendo, S.L. + * Portions created by Fluendo, S.L. are Copyright (C) 2005 + * Fluendo, S.L. All Rights Reserved. + * + * Contributor(s): Jan Schmidt + */ + +#ifndef __FLUTS_PMT_STREAM_INFO_H__ +#define __FLUTS_PMT_STREAM_INFO_H__ + +#include + +G_BEGIN_DECLS + + +typedef struct FluTsPmtStreamInfoClass { + GObjectClass parent_class; +} FluTsPmtStreamInfoClass; + +typedef struct FluTsPmtStreamInfo { + GObject parent; + + guint16 pid; + GValueArray *languages; /* null terminated 3 character ISO639 language code */ + guint8 stream_type; + GValueArray *descriptors; +} FluTsPmtStreamInfo; + +FluTsPmtStreamInfo *fluts_pmt_stream_info_new (guint16 pid, guint8 type); +void fluts_pmt_stream_info_add_language(FluTsPmtStreamInfo* si, + gchar* language); +void fluts_pmt_stream_info_add_descriptor (FluTsPmtStreamInfo *pmt_info, + const gchar *descriptor, guint length); + +GType fluts_pmt_stream_info_get_type (void); + +#define FLUTS_TYPE_PMT_STREAM_INFO (fluts_pmt_stream_info_get_type ()) + +#define FLUTS_IS_PMT_STREAM_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), FLUTS_TYPE_PMT_STREAM_INFO)) +#define FLUTS_PMT_STREAM_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),FLUTS_TYPE_PMT_STREAM_INFO, FluTsPmtStreamInfo)) + +G_END_DECLS + +#endif diff --git a/gst/mpegdemux/gstmpegdefs.h b/gst/mpegdemux/gstmpegdefs.h new file mode 100644 index 0000000..c4d34b0 --- /dev/null +++ b/gst/mpegdemux/gstmpegdefs.h @@ -0,0 +1,197 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifndef __GST_MPEG_DEFS_H__ +#define __GST_MPEG_DEFS_H__ + +/* + * 1011 1100 program_stream_map + * 1011 1101 private_stream_1 + * 1011 1110 padding_stream + * 1011 1111 private_stream_2 + * 110x xxxx ISO/IEC 13818-3 or ISO/IEC 11172-3 audio stream number x xxxx + * 1110 xxxx ITU-T Rec. H.262 | ISO/IEC 13818-2 or ISO/IEC 11172-2 video stream number xxxx + * 1111 0000 ECM_stream + * 1111 0001 EMM_stream + * 1111 0010 ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Annex A or ISO/IEC 13818-6_DSMCC_stream + * 1111 0011 ISO/IEC_13522_stream + * 1111 0100 ITU-T Rec. H.222.1 type A + * 1111 0101 ITU-T Rec. H.222.1 type B + * 1111 0110 ITU-T Rec. H.222.1 type C + * 1111 0111 ITU-T Rec. H.222.1 type D + * 1111 1000 ITU-T Rec. H.222.1 type E + * 1111 1001 ancillary_stream + * 1111 1010 E 1111 1110 reserved data stream + * 1111 1111 program_stream_directory + */ + +#define ID_PS_END_CODE 0x000001B9 +#define ID_PS_PACK_START_CODE 0x000001BA +#define ID_PS_SYSTEM_HEADER_START_CODE 0x000001BB +#define ID_PS_PROGRAM_STREAM_MAP 0x000001BC +#define ID_PRIVATE_STREAM_1 0x000001BD +#define ID_PADDING_STREAM 0x000001BE +#define ID_PRIVATE_STREAM_2 0x000001BF +#define ID_ISO_IEC_MPEG12_AUDIO_STREAM_0 0x000001C0 +#define ID_ISO_IEC_MPEG12_AUDIO_STREAM_32 0x000001DF +#define ID_ISO_IEC_MPEG12_VIDEO_STREAM_0 0x000001E0 +#define ID_ISO_IEC_MPEG12_VIDEO_STREAM_16 0x000001EF +#define ID_ECM_STREAM 0x000001F0 +#define ID_EMM_STREAM 0x000001F1 +#define ID_DSMCC_STREAM 0x000001F2 +#define ID_ISO_IEC_13522_STREAM 0x000001F3 +#define ID_ITU_TREC_H222_TYPE_A_STREAM 0x000001F4 +#define ID_ITU_TREC_H222_TYPE_B_STREAM 0x000001F5 +#define ID_ITU_TREC_H222_TYPE_C_STREAM 0x000001F6 +#define ID_ITU_TREC_H222_TYPE_D_STREAM 0x000001F7 +#define ID_ITU_TREC_H222_TYPE_E_STREAM 0x000001F8 +#define ID_ANCILLARY_STREAM 0x000001F9 +#define ID_RESERVED_STREAM_1 0x000001FA +#define ID_RESERVED_STREAM_2 0x000001FB +#define ID_EXTENDED_METADATA 0x000001FC +#define ID_EXTENDED_STREAM_ID 0x000001FD +#define ID_RESERVED_STREAM_3 0x000001FE +#define ID_PROGRAM_STREAM_DIRECTORY 0x000001FF + +#define PACKET_VIDEO_START_CODE 0x000001E0 +#define PACKET_AUDIO_START_CODE 0x000001C0 +#define PICTURE_START_CODE 0x00000100 +#define USER_DATA_START_CODE 0x000001B2 +#define SEQUENCE_HEADER_CODE 0x000001B3 +#define SEQUENCE_ERROR_CODE 0x000001B4 +#define EXTENSION_START_CODE 0x000001B5 +#define SEQUENCE_END_CODE 0x000001B7 +#define GROUP_START_CODE 0x000001B8 + +#define AC3_SYNC_WORD 0x0b770000 + +#define MPEG_TS_SYNC_BYTE 0x00000047 + +#define PID_PROGRAM_ASSOCIATION_TABLE 0x0000 +#define PID_CONDITIONAL_ACCESS_TABLE 0x0001 +#define PID_RESERVED_FIRST 0x0002 +#define PID_RESERVED_LAST 0x0010 +#define PID_NULL_PACKET 0x1FFF + +#define PID_TYPE_UNKNOWN 0 +#define PID_TYPE_RESERVED 1 +#define PID_TYPE_PROGRAM_ASSOCIATION 2 +#define PID_TYPE_CONDITIONAL_ACCESS 3 +#define PID_TYPE_PROGRAM_MAP 4 +#define PID_TYPE_ELEMENTARY 5 +#define PID_TYPE_NULL_PACKET 6 +#define PID_TYPE_PRIVATE_SECTION 7 + +/* Stream type assignments + * + * 0x00 ITU-T | ISO/IEC Reserved + * 0x01 ISO/IEC 11172 Video + * 0x02 ITU-T Rec. H.262 | ISO/IEC 13818-2 Video or + * ISO/IEC 11172-2 constrained parameter video + * stream + * 0x03 ISO/IEC 11172 Audio + * 0x04 ISO/IEC 13818-3 Audio + * 0x05 ITU-T Rec. H.222.0 | ISO/IEC 13818-1 + * private_sections + * 0x06 ITU-T Rec. H.222.0 | ISO/IEC 13818-1 PES + * packets containing private data + * 0x07 ISO/IEC 13522 MHEG + * 0x08 ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Annex A + * DSM CC + * 0x09 ITU-T Rec. H.222.1 + * 0x0A ISO/IEC 13818-6 type A + * 0x0B ISO/IEC 13818-6 type B + * 0x0C ISO/IEC 13818-6 type C + * 0x0D ISO/IEC 13818-6 type D + * 0x0E ISO/IEC 13818-1 auxiliary + * 0x0F-0x7F ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Reserved + * 0x80-0xFF User Private + */ +#define ST_RESERVED 0x00 +#define ST_VIDEO_MPEG1 0x01 +#define ST_VIDEO_MPEG2 0x02 +#define ST_AUDIO_MPEG1 0x03 +#define ST_AUDIO_MPEG2 0x04 +#define ST_PRIVATE_SECTIONS 0x05 +#define ST_PRIVATE_DATA 0x06 +#define ST_MHEG 0x07 +#define ST_DSMCC 0x08 +#define ST_H222_1 0x09 + +/* later extensions */ +#define ST_AUDIO_AAC 0x0f +#define ST_VIDEO_MPEG4 0x10 +#define ST_VIDEO_H264 0x1b + +/* Un-official Dirac extension */ +#define ST_VIDEO_DIRAC 0xd1 + +/* private stream types */ +#define ST_PS_AUDIO_AC3 0x81 +#define ST_PS_AUDIO_DTS 0x8a +#define ST_PS_AUDIO_LPCM 0x8b +#define ST_PS_DVD_SUBPICTURE 0xff + +/* Un-official time-code stream */ +#define ST_PS_TIMECODE 0xd2 + +/* Internal stream types >= 0x100 */ +#define ST_GST_AUDIO_RAWA52 0x181 + /* Used when we don't yet know which stream type it will be in a PS stream */ +#define ST_GST_VIDEO_MPEG1_OR_2 0x102 + +#define CLOCK_BASE 9LL +#define CLOCK_FREQ (CLOCK_BASE * 10000) + +#define MPEGTIME_TO_GSTTIME(time) (gst_util_uint64_scale ((time), \ + GST_MSECOND/10, CLOCK_BASE)) +#define GSTTIME_TO_MPEGTIME(time) (gst_util_uint64_scale ((time), \ + CLOCK_BASE, GST_MSECOND/10)) + +#define MPEG_MUX_RATE_MULT 50 + +/* some extra GstFlowReturn values used internally */ +#define GST_FLOW_NEED_MORE_DATA -100 +#define GST_FLOW_LOST_SYNC -101 + +#endif /* __GST_MPEG_DEFS_H__ */ diff --git a/gst/mpegdemux/gstmpegdemux.c b/gst/mpegdemux/gstmpegdemux.c new file mode 100644 index 0000000..a4b62d3 --- /dev/null +++ b/gst/mpegdemux/gstmpegdemux.c @@ -0,0 +1,1869 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "gstmpegdefs.h" +#include "gstmpegdemux.h" + +#define MAX_DVD_AUDIO_STREAMS 8 +#define MAX_DVD_SUBPICTURE_STREAMS 32 + +/* We clamp scr delta with 0 so negative bytes won't be possible */ +#define GSTTIME_TO_BYTES(time) \ + ((time != -1) ? gst_util_uint64_scale (MAX(0,(gint64) (GSTTIME_TO_MPEGTIME(time) - demux->first_scr)), demux->scr_rate_n, demux->scr_rate_d) : -1) +#define BYTES_TO_GSTTIME(bytes) ((bytes != -1) ? MPEGTIME_TO_GSTTIME(gst_util_uint64_scale (bytes, demux->scr_rate_d, demux->scr_rate_n)) : -1) + +#define ADAPTER_OFFSET_FLUSH(_bytes_) demux->adapter_offset += (_bytes_) + +GST_DEBUG_CATEGORY_STATIC (gstflupsdemux_debug); +#define GST_CAT_DEFAULT (gstflupsdemux_debug) + +#ifndef GST_CHECK_VERSION +#define GST_CHECK_VERSION(major,minor,micro) \ + (GST_VERSION_MAJOR > (major) || \ + (GST_VERSION_MAJOR == (major) && GST_VERSION_MINOR > (minor)) || \ + (GST_VERSION_MAJOR == (major) && GST_VERSION_MINOR == (minor) && \ + GST_VERSION_MICRO >= (micro))) +#endif + +#if !GST_CHECK_VERSION(0,10,9) +#define GST_BUFFER_IS_DISCONT(buffer) (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) +#endif + +#if GST_CHECK_VERSION(0,10,6) +#define HAVE_NEWSEG_FULL +#else +static GstBuffer * +gst_adapter_take_buffer (GstAdapter * adapter, guint nbytes) +{ + GstBuffer *buf = NULL; + + if (G_UNLIKELY (nbytes > adapter->size)) + return NULL; + + buf = gst_buffer_new_and_alloc (nbytes); + + if (G_UNLIKELY (!buf)) + return NULL; + + /* Slow... */ + memcpy (GST_BUFFER_DATA (buf), gst_adapter_peek (adapter, nbytes), nbytes); + + return buf; +} +#endif + +/* elementfactory information */ +static GstElementDetails flups_demux_details = { + "MPEG Program Demuxer", + "Codec/Demuxer", + "Demultiplexes MPEG Program Streams", + "Wim Taymans " +}; + +#define GST_TYPE_FLUPS_DEMUX_SYNC (gst_flups_demux_sync_get_type ()) +GType +gst_flups_demux_sync_get_type (void) +{ + static GType sync_type = 0; + static GEnumValue sync_types[] = { + {GST_FLUPS_DEMUX_SYNC_AUTO, "Auto-select method to synchronize streams", + "auto"}, + {GST_FLUPS_DEMUX_SYNC_SCR, "Use SCR to synchronize streams", "scr"}, + {GST_FLUPS_DEMUX_SYNC_DTS, "Use DTS to synchronize streams", "dts"}, + {0, NULL, NULL} + }; + + if (sync_type == 0) + sync_type = g_enum_register_static ("GstFluPSDemuxSync", sync_types); + + return sync_type; +} + +/* MPEG2Demux signals and args */ +enum +{ + /* FILL ME */ + LAST_SIGNAL +}; + +enum +{ + ARG_0, + ARG_SYNC, + /* FILL ME */ +}; + +static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/mpeg, " + "mpegversion = (int) { 1, 2 }, " + "systemstream = (boolean) TRUE;" "video/x-cdxa") + ); + +static GstStaticPadTemplate video_template = + GST_STATIC_PAD_TEMPLATE ("video_%02x", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS ("video/mpeg, " + "mpegversion = (int) { 1, 2, 4 }, " "systemstream = (boolean) FALSE;" + "video/x-h264") + ); + +static GstStaticPadTemplate audio_template = + GST_STATIC_PAD_TEMPLATE ("audio_%02x", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS ("audio/mpeg, " + "mpegversion = (int) 1;" + "audio/x-private1-lpcm; " + "audio/x-private1-ac3;" "audio/x-private1-dts;" "audio/ac3") + ); + +static GstStaticPadTemplate private_template = +GST_STATIC_PAD_TEMPLATE ("private_%d", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS_ANY); + +static void gst_flups_demux_base_init (GstFluPSDemuxClass * klass); +static void gst_flups_demux_class_init (GstFluPSDemuxClass * klass); +static void gst_flups_demux_init (GstFluPSDemux * demux); +static void gst_flups_demux_finalize (GstFluPSDemux * demux); +static void gst_flups_demux_reset (GstFluPSDemux * demux); + +static gboolean gst_flups_demux_sink_event (GstPad * pad, GstEvent * event); +static gboolean gst_flups_demux_src_event (GstPad * pad, GstEvent * event); +static gboolean gst_flups_demux_src_query (GstPad * pad, GstQuery * query); +static GstFlowReturn gst_flups_demux_chain (GstPad * pad, GstBuffer * buffer); + +static GstStateChangeReturn gst_flups_demux_change_state (GstElement * element, + GstStateChange transition); + +static GstElementClass *parent_class = NULL; + +/*static guint gst_flups_demux_signals[LAST_SIGNAL] = { 0 };*/ + +GType +gst_flups_demux_get_type (void) +{ + static GType flups_demux_type = 0; + + if (!flups_demux_type) { + static const GTypeInfo flups_demux_info = { + sizeof (GstFluPSDemuxClass), + (GBaseInitFunc) gst_flups_demux_base_init, + NULL, + (GClassInitFunc) gst_flups_demux_class_init, + NULL, + NULL, + sizeof (GstFluPSDemux), + 0, + (GInstanceInitFunc) gst_flups_demux_init, + }; + + flups_demux_type = + g_type_register_static (GST_TYPE_ELEMENT, "GstFluPSDemux", + &flups_demux_info, 0); + + GST_DEBUG_CATEGORY_INIT (gstflupsdemux_debug, "flupsdemux", 0, + "MPEG program stream demultiplexer element"); + } + + return flups_demux_type; +} + +static void +gst_flups_demux_base_init (GstFluPSDemuxClass * klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + + klass->sink_template = gst_static_pad_template_get (&sink_template); + klass->video_template = gst_static_pad_template_get (&video_template); + klass->audio_template = gst_static_pad_template_get (&audio_template); + klass->private_template = gst_static_pad_template_get (&private_template); + + gst_element_class_add_pad_template (element_class, klass->video_template); + gst_element_class_add_pad_template (element_class, klass->audio_template); + gst_element_class_add_pad_template (element_class, klass->private_template); + gst_element_class_add_pad_template (element_class, klass->sink_template); + + gst_element_class_set_details (element_class, &flups_demux_details); +} + +static void +gst_flups_demux_class_init (GstFluPSDemuxClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + parent_class = g_type_class_ref (GST_TYPE_ELEMENT); + + gobject_class = (GObjectClass *) klass; + gstelement_class = (GstElementClass *) klass; + + gobject_class->finalize = (GObjectFinalizeFunc) gst_flups_demux_finalize; + + gstelement_class->change_state = gst_flups_demux_change_state; +} + +static void +gst_flups_demux_init (GstFluPSDemux * demux) +{ + GstFluPSDemuxClass *klass = GST_FLUPS_DEMUX_GET_CLASS (demux); + + demux->sinkpad = gst_pad_new_from_template (klass->sink_template, "sink"); + gst_pad_set_event_function (demux->sinkpad, gst_flups_demux_sink_event); + gst_pad_set_chain_function (demux->sinkpad, gst_flups_demux_chain); + gst_element_add_pad (GST_ELEMENT (demux), demux->sinkpad); + + demux->streams = + g_malloc0 (sizeof (GstFluPSStream *) * (GST_FLUPS_DEMUX_MAX_STREAMS)); + +} + +static void +gst_flups_demux_finalize (GstFluPSDemux * demux) +{ + gst_flups_demux_reset (demux); + g_free (demux->streams); + + G_OBJECT_CLASS (parent_class)->finalize (G_OBJECT (demux)); +} + +static void +gst_flups_demux_reset (GstFluPSDemux * demux) +{ + /* Clean up the streams and pads we allocated */ + gint i; + GstEvent **p_ev; + + for (i = 0; i < GST_FLUPS_DEMUX_MAX_STREAMS; i++) { + GstFluPSStream *stream = demux->streams[i]; + + if (stream != NULL) { + if (stream->pad) + gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->pad); + + g_free (stream); + demux->streams[i] = NULL; + } + } + p_ev = &demux->lang_codes; + + gst_event_replace (p_ev, NULL); +} + +static GstFluPSStream * +gst_flups_demux_create_stream (GstFluPSDemux * demux, gint id, gint stream_type) +{ + GstFluPSStream *stream; + GstPadTemplate *template; + gchar *name; + GstFluPSDemuxClass *klass = GST_FLUPS_DEMUX_GET_CLASS (demux); + GstCaps *caps; + + name = NULL; + template = NULL; + caps = NULL; + + GST_DEBUG_OBJECT (demux, "create stream id 0x%02x, type 0x%02x", id, + stream_type); + + switch (stream_type) { + case ST_VIDEO_MPEG1: + case ST_VIDEO_MPEG2: + case ST_VIDEO_MPEG4: + case ST_GST_VIDEO_MPEG1_OR_2: + { + gint mpeg_version = 1; + if (stream_type == ST_VIDEO_MPEG2 || + (stream_type == ST_GST_VIDEO_MPEG1_OR_2 && demux->is_mpeg2_pack)) { + mpeg_version = 2; + } + if (stream_type == ST_VIDEO_MPEG4) { + mpeg_version = 4; + } + + template = klass->video_template; + name = g_strdup_printf ("video_%02x", id); + caps = gst_caps_new_simple ("video/mpeg", + "mpegversion", G_TYPE_INT, mpeg_version, + "systemstream", G_TYPE_BOOLEAN, FALSE, NULL); + break; + } + case ST_AUDIO_MPEG1: + case ST_AUDIO_MPEG2: + template = klass->audio_template; + name = g_strdup_printf ("audio_%02x", id); + caps = gst_caps_new_simple ("audio/mpeg", + "mpegversion", G_TYPE_INT, 1, NULL); + break; + case ST_PRIVATE_SECTIONS: + case ST_PRIVATE_DATA: + case ST_MHEG: + case ST_DSMCC: + case ST_AUDIO_AAC: + break; + case ST_VIDEO_H264: + template = klass->video_template; + name = g_strdup_printf ("video_%02x", id); + caps = gst_caps_new_simple ("video/x-h264", NULL); + break; + case ST_PS_AUDIO_AC3: + template = klass->audio_template; + name = g_strdup_printf ("audio_%02x", id); + caps = gst_caps_new_simple ("audio/x-private1-ac3", NULL); + break; + case ST_PS_AUDIO_DTS: + template = klass->audio_template; + name = g_strdup_printf ("audio_%02x", id); + caps = gst_caps_new_simple ("audio/x-private1-dts", NULL); + break; + case ST_PS_AUDIO_LPCM: + template = klass->audio_template; + name = g_strdup_printf ("audio_%02x", id); + caps = gst_caps_new_simple ("audio/x-private1-lpcm", NULL); + break; + case ST_PS_DVD_SUBPICTURE: + break; + case ST_GST_AUDIO_RAWA52: + template = klass->audio_template; + name = g_strdup_printf ("audio_%02x", id); + caps = gst_caps_new_simple ("audio/ac3", NULL); + break; + default: + break; + } + + if (name == NULL || template == NULL || caps == NULL) + return NULL; + + stream = g_new0 (GstFluPSStream, 1); + stream->id = id; + stream->discont = TRUE; + stream->need_segment = TRUE; + stream->notlinked = FALSE; + stream->type = stream_type; + stream->pad = gst_pad_new_from_template (template, name); + gst_pad_set_event_function (stream->pad, gst_flups_demux_src_event); + gst_pad_set_query_function (stream->pad, gst_flups_demux_src_query); + gst_pad_use_fixed_caps (stream->pad); + gst_pad_set_caps (stream->pad, caps); + gst_caps_unref (caps); + GST_DEBUG_OBJECT (demux, "create pad %s, caps %" GST_PTR_FORMAT, name, caps); + g_free (name); + + + return stream; +} + +static GstFluPSStream * +gst_flups_demux_get_stream (GstFluPSDemux * demux, gint id, gint type) +{ + GstFluPSStream *stream = demux->streams[id]; + + if (stream == NULL) { + if (!(stream = gst_flups_demux_create_stream (demux, id, type))) + goto unknown_stream; + + GST_DEBUG_OBJECT (demux, "adding pad for stream id 0x%02x type 0x%02x", id, + type); + + gst_pad_set_active (stream->pad, TRUE); + gst_element_add_pad (GST_ELEMENT (demux), stream->pad); + + demux->streams[id] = stream; + } + return stream; + + /* ERROR */ +unknown_stream: + { + GST_DEBUG_OBJECT (demux, "unknown stream id 0x%02x type 0x%02x", id, type); + return NULL; + } +} + +static GstFlowReturn +gst_flups_demux_send_data (GstFluPSDemux * demux, GstFluPSStream * stream, + GstBuffer * buf) +{ + GstFlowReturn result; + guint64 timestamp; + guint size; + + if (stream == NULL) + goto no_stream; + + /* discont */ + if (stream->need_segment) { + gint64 time, start, stop; + GstEvent *newsegment; + + start = demux->base_time + demux->src_segment.start; + if (demux->src_segment.stop != -1) + stop = demux->base_time + demux->src_segment.stop; + else + stop = -1; + time = start; + +#ifdef HAVE_NEWSEG_FULL + GST_INFO_OBJECT (demux, "sending new segment: rate %g applied_rate %g " + "start: %" GST_TIME_FORMAT ", stop: %" GST_TIME_FORMAT + ", time: %" GST_TIME_FORMAT " to pad %" GST_PTR_FORMAT, + demux->sink_segment.rate, demux->sink_segment.applied_rate, + GST_TIME_ARGS (start), GST_TIME_ARGS (stop), + GST_TIME_ARGS (time), stream->pad); + + newsegment = gst_event_new_new_segment_full (FALSE, + demux->sink_segment.rate, demux->sink_segment.applied_rate, + GST_FORMAT_TIME, start, stop, time); +#else + GST_INFO_OBJECT (demux, "sending new segment: rate %g " + "start: %" GST_TIME_FORMAT ", stop: %" GST_TIME_FORMAT + ", time: %" GST_TIME_FORMAT " to pad %" GST_PTR_FORMAT, + demux->sink_segment.rate, GST_TIME_ARGS (start), + GST_TIME_ARGS (stop), GST_TIME_ARGS (time), stream->pad); + + newsegment = gst_event_new_new_segment (FALSE, + demux->sink_segment.rate, GST_FORMAT_TIME, start, stop, time); +#endif + + gst_pad_push_event (stream->pad, newsegment); + + stream->need_segment = FALSE; + } + + /* timestamps */ + if (demux->next_pts != G_MAXUINT64) + timestamp = MPEGTIME_TO_GSTTIME (demux->next_pts); + else + timestamp = GST_CLOCK_TIME_NONE; + + /* OK, sent new segment now prepare the buffer for sending */ + /* caps */ + gst_buffer_set_caps (buf, GST_PAD_CAPS (stream->pad)); + GST_BUFFER_TIMESTAMP (buf) = timestamp; + + /* Set the buffer discont flag, and clear discont state on the stream */ + if (stream->discont) { + GST_DEBUG_OBJECT (demux, "marking discont buffer"); + GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); + + stream->discont = FALSE; + } + size = GST_BUFFER_SIZE (buf); + + demux->next_pts = G_MAXUINT64; + demux->next_dts = G_MAXUINT64; + + result = gst_pad_push (stream->pad, buf); + GST_DEBUG_OBJECT (demux, "pushed stream id 0x%02x type 0x%02x, time: %" + GST_TIME_FORMAT ", size %d. result: %s", + stream->id, stream->type, GST_TIME_ARGS (timestamp), + size, gst_flow_get_name (result)); + + return result; + + /* ERROR */ +no_stream: + { + GST_DEBUG_OBJECT (demux, "no stream given"); + gst_buffer_unref (buf); + return GST_FLOW_OK; + } +} + +static void +gst_flups_demux_mark_discont (GstFluPSDemux * demux, gboolean discont, + gboolean need_segment) +{ + gint id; + + /* mark discont on all streams */ + for (id = 0; id < GST_FLUPS_DEMUX_MAX_STREAMS; id++) { + GstFluPSStream *stream = demux->streams[id]; + + if (stream) { + stream->discont |= discont; + stream->need_segment |= need_segment; + GST_DEBUG_OBJECT (demux, "marked stream as discont %d, need_segment %d", + stream->discont, stream->need_segment); + } + } +} + +static gboolean +gst_flups_demux_send_event (GstFluPSDemux * demux, GstEvent * event) +{ + gint id; + gboolean ret = FALSE; + + for (id = 0; id < GST_FLUPS_DEMUX_MAX_STREAMS; id++) { + GstFluPSStream *stream = demux->streams[id]; + + if (stream && !stream->notlinked) { + (void) gst_event_ref (event); + + if (!gst_pad_push_event (stream->pad, event)) { + GST_DEBUG_OBJECT (stream, "event %s was not handled correctly", + GST_EVENT_TYPE_NAME (event)); + } else { + /* If at least one push returns TRUE, then we return TRUE. */ + GST_DEBUG_OBJECT (stream, "event %s was handled correctly", + GST_EVENT_TYPE_NAME (event)); + ret = TRUE; + } + } + } + + gst_event_unref (event); + return ret; +} + +static gboolean +gst_flups_demux_handle_dvd_event (GstFluPSDemux * demux, GstEvent * event) +{ + const GstStructure *structure = gst_event_get_structure (event); + const char *type = gst_structure_get_string (structure, "event"); + gint i; + gchar cur_stream_name[32]; + GstFluPSStream *temp; + + if (strcmp (type, "dvd-lang-codes") == 0) { + GstEvent **p_ev; + /* Store the language codes event on the element, then iterate over the + * streams it specifies and retrieve them. The stream creation code then + * creates the pad appropriately and sends tag events as needed */ + p_ev = &demux->lang_codes, event; + gst_event_replace (p_ev, event); + + GST_DEBUG_OBJECT (demux, "Handling language codes event"); + + /* Create a video pad to ensure have it before emit no more pads */ + temp = gst_flups_demux_get_stream (demux, 0xe0, ST_VIDEO_MPEG2); + + /* Read out the languages for audio streams and request each one that + * is present */ + for (i = 0; i < MAX_DVD_AUDIO_STREAMS; i++) { + gint stream_format; + gint stream_id; + + g_snprintf (cur_stream_name, 32, "audio-%d-format", i); + if (!gst_structure_get_int (structure, cur_stream_name, &stream_format)) + break; + + switch (stream_format) { + case 0x0: + /* AC3 */ + stream_id = 0x80 + i; + temp = gst_flups_demux_get_stream (demux, stream_id, ST_PS_AUDIO_AC3); + break; + case 0x2: + case 0x3: + /* MPEG audio without and with extension stream are + * treated the same */ + stream_id = 0xC0 + i; + temp = gst_flups_demux_get_stream (demux, stream_id, ST_AUDIO_MPEG1); + break; + case 0x4: + /* LPCM */ + stream_id = 0xA0 + i; + temp = + gst_flups_demux_get_stream (demux, stream_id, ST_PS_AUDIO_LPCM); + break; + case 0x6: + /* DTS */ + stream_id = 0x88 + i; + temp = gst_flups_demux_get_stream (demux, stream_id, ST_PS_AUDIO_DTS); + break; + case 0x7: + /* FIXME: What range is SDDS? */ + break; + default: + GST_WARNING_OBJECT (demux, + "Unknown audio stream format in language code event: %d", + stream_format); + break; + } + } + + /* And subtitle streams */ + for (i = 0; i < MAX_DVD_SUBPICTURE_STREAMS; i++) { + g_snprintf (cur_stream_name, 32, "subpicture-%d-format", i); + + if (gst_structure_get_string (structure, cur_stream_name) == NULL) + break; + + /* Retrieve the subpicture stream to force pad creation */ + temp = gst_flups_demux_get_stream (demux, 0x20 + i, ST_PS_DVD_SUBPICTURE); + } + + GST_DEBUG_OBJECT (demux, "Created all pads from Language Codes event, " + "signalling no-more-pads"); + + gst_element_no_more_pads (GST_ELEMENT (demux)); + demux->need_no_more_pads = FALSE; + } + + gst_event_unref (event); + return TRUE; +} + +static gboolean +gst_flups_demux_sink_event (GstPad * pad, GstEvent * event) +{ + gboolean res = TRUE; + GstFluPSDemux *demux; + + demux = GST_FLUPS_DEMUX (gst_pad_get_parent (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_FLUSH_START: + gst_flups_demux_send_event (demux, event); + break; + case GST_EVENT_FLUSH_STOP: + gst_flups_demux_send_event (demux, event); + + gst_segment_init (&demux->sink_segment, GST_FORMAT_UNDEFINED); + gst_adapter_clear (demux->adapter); + gst_adapter_clear (demux->rev_adapter); + demux->adapter_offset = G_MAXUINT64; + gst_pes_filter_drain (&demux->filter); + demux->current_scr = G_MAXUINT64; + demux->bytes_since_scr = 0; + break; + case GST_EVENT_NEWSEGMENT: + { + gboolean update; + gdouble rate; + GstFormat format; + gint64 start, stop, time; + +#ifdef HAVE_NEWSEG_FULL + { + gdouble arate; + + gst_event_parse_new_segment_full (event, &update, &rate, &arate, + &format, &start, &stop, &time); + gst_segment_set_newsegment_full (&demux->sink_segment, update, rate, + arate, format, start, stop, time); + + if (format == GST_FORMAT_BYTES && demux->scr_rate_n != G_MAXUINT64 + && demux->scr_rate_d != G_MAXUINT64) { + + gst_segment_set_newsegment_full (&demux->src_segment, update, rate, + arate, GST_FORMAT_TIME, BYTES_TO_GSTTIME (start), + BYTES_TO_GSTTIME (stop), BYTES_TO_GSTTIME (time)); + } + + } +#else + gst_event_parse_new_segment (event, &update, &rate, &format, + &start, &stop, &time); + gst_segment_set_newsegment (&demux->sink_segment, update, rate, + format, start, stop, time); + if (format == GST_FORMAT_BYTES && demux->scr_rate_n != G_MAXUINT64 + && demux->scr_rate_d != G_MAXUINT64) { + + gst_segment_set_newsegment (&demux->src_segment, update, rate, + GST_FORMAT_TIME, BYTES_TO_GSTTIME (start), BYTES_TO_GSTTIME (stop), + BYTES_TO_GSTTIME (time)); + } +#endif + + GST_INFO_OBJECT (demux, "received new segment: rate %g " + "format %d, start: %" G_GINT64_FORMAT ", stop: %" G_GINT64_FORMAT + ", time: %" G_GINT64_FORMAT, rate, format, start, stop, time); + + /* we need to emit a new segment */ + gst_flups_demux_mark_discont (demux, TRUE, TRUE); + gst_event_unref (event); + + break; + } + case GST_EVENT_EOS: + GST_INFO_OBJECT (demux, "Received EOS"); + if (!gst_flups_demux_send_event (demux, event)) { + GST_WARNING_OBJECT (demux, "failed pushing EOS on streams"); + GST_ELEMENT_ERROR (demux, STREAM, FAILED, + ("Internal data stream error."), ("Can't push EOS downstream")); + } + break; + case GST_EVENT_CUSTOM_DOWNSTREAM: + case GST_EVENT_CUSTOM_DOWNSTREAM_OOB: + { + const GstStructure *structure = gst_event_get_structure (event); + + if (structure != NULL + && gst_structure_has_name (structure, "application/x-gst-dvd")) { + res = gst_flups_demux_handle_dvd_event (demux, event); + } else { + gst_flups_demux_send_event (demux, event); + } + break; + } + default: + gst_flups_demux_send_event (demux, event); + break; + } + + gst_object_unref (demux); + + return res; +} + +static gboolean +gst_flups_demux_src_event (GstPad * pad, GstEvent * event) +{ + gboolean res = FALSE; + GstFluPSDemux *demux; + + demux = GST_FLUPS_DEMUX (gst_pad_get_parent (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_SEEK: + { + gdouble rate; + GstFormat format; + GstSeekFlags flags; + GstSeekType start_type, stop_type; + gint64 start, stop; + gint64 bstart, bstop; + GstEvent *bevent; + + gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start, + &stop_type, &stop); + + GST_DEBUG_OBJECT (demux, "seek event, rate: %f start: %" GST_TIME_FORMAT + " stop: %" GST_TIME_FORMAT, rate, GST_TIME_ARGS (start), + GST_TIME_ARGS (stop)); + + if (format == GST_FORMAT_BYTES) { + GST_DEBUG_OBJECT (demux, "seek not supported on format %d", format); + goto not_supported; + } + + GST_DEBUG_OBJECT (demux, "seek - trying directly upstream first"); + + /* first try original format seek */ + (void) gst_event_ref (event); + if ((res = gst_pad_push_event (demux->sinkpad, event))) + goto done; + + if (format != GST_FORMAT_TIME) { + /* From here down, we only support time based seeks */ + GST_DEBUG_OBJECT (demux, "seek not supported on format %d", format); + goto not_supported; + } + + /* We need to convert to byte based seek and we need a scr_rate for that. */ + if (demux->scr_rate_n == G_MAXUINT64 || demux->scr_rate_d == G_MAXUINT64) { + GST_DEBUG_OBJECT (demux, "seek not possible, no scr_rate"); + goto not_supported; + } + + GST_DEBUG_OBJECT (demux, "try with scr_rate interpolation"); + + bstart = GSTTIME_TO_BYTES (start); + bstop = GSTTIME_TO_BYTES (stop); + + GST_DEBUG_OBJECT (demux, "in bytes bstart %" G_GINT64_FORMAT " bstop %" + G_GINT64_FORMAT, bstart, bstop); + bevent = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, start_type, + bstart, stop_type, bstop); + + res = gst_pad_push_event (demux->sinkpad, bevent); + + done: + gst_event_unref (event); + break; + } + default: + res = gst_pad_push_event (demux->sinkpad, event); + break; + } + + gst_object_unref (demux); + + return res; + +not_supported: + { + gst_object_unref (demux); + gst_event_unref (event); + + return FALSE; + } +} + +static gboolean +gst_flups_demux_src_query (GstPad * pad, GstQuery * query) +{ + gboolean res = FALSE; + GstFluPSDemux *demux; + + demux = GST_FLUPS_DEMUX (gst_pad_get_parent (pad)); + + GST_LOG_OBJECT (demux, "Have query of type %d on pad %" GST_PTR_FORMAT, + GST_QUERY_TYPE (query), pad); + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_POSITION: + { + GstFormat format; + gint64 position; + + gst_query_parse_position (query, &format, NULL); + + if (format != GST_FORMAT_TIME) { + GST_DEBUG_OBJECT (demux, "position not supported for format %d", + format); + goto not_supported; + } + if (demux->current_scr == G_MAXUINT64 || demux->first_scr == G_MAXUINT64) { + GST_DEBUG_OBJECT (demux, "position not possible, no current_scr"); + goto not_supported; + } + + position = demux->base_time + + MPEGTIME_TO_GSTTIME (demux->current_scr - demux->first_scr); + + GST_LOG_OBJECT (demux, "Position at GStreamer Time:%" GST_TIME_FORMAT, + GST_TIME_ARGS (position)); + + gst_query_set_position (query, format, position); + res = TRUE; + break; + } + case GST_QUERY_DURATION: + { + GstFormat format; + gint64 duration; + GstPad *peer; + + gst_query_parse_duration (query, &format, NULL); + + if ((peer = gst_pad_get_peer (demux->sinkpad)) == NULL) { + GST_DEBUG_OBJECT (demux, "duration not possible, no peer"); + goto not_supported; + } + + /* For any format other than bytes, see if upstream knows first */ + if (format == GST_FORMAT_BYTES) { + GST_DEBUG_OBJECT (demux, "duration not supported for format %d", + format); + gst_object_unref (peer); + goto not_supported; + } + + if (gst_pad_query (peer, query)) { + gst_object_unref (peer); + res = TRUE; + break; + } + + /* Upstream didn't know, so we can only answer TIME queries from + * here on */ + if (format != GST_FORMAT_TIME) { + GST_DEBUG_OBJECT (demux, "duration not supported for format %d", + format); + gst_object_unref (peer); + goto not_supported; + } + + if (demux->mux_rate == -1) { + GST_DEBUG_OBJECT (demux, "duration not possible, no mux_rate"); + gst_object_unref (peer); + goto not_supported; + } + + gst_query_set_duration (query, GST_FORMAT_BYTES, -1); + + if (!gst_pad_query (peer, query)) { + GST_LOG_OBJECT (demux, "query on peer pad failed"); + gst_object_unref (peer); + goto not_supported; + } + gst_object_unref (peer); + + gst_query_parse_duration (query, &format, &duration); + + duration = BYTES_TO_GSTTIME (duration); + + gst_query_set_duration (query, GST_FORMAT_TIME, duration); + res = TRUE; + break; + } + default: + res = gst_pad_query_default (pad, query); + break; + } + + gst_object_unref (demux); + + return res; + +not_supported: + { + gst_object_unref (demux); + + return FALSE; + } +} + +static void +gst_flups_demux_reset_psm (GstFluPSDemux * demux) +{ + gint i; + +#define FILL_TYPE(start, stop, type) \ + for (i=start; i <= stop; i++) \ + demux->psm[i] = type; + + FILL_TYPE (0x00, 0x1f, -1); + FILL_TYPE (0x20, 0x3f, ST_PS_DVD_SUBPICTURE); + FILL_TYPE (0x40, 0x7f, -1); + FILL_TYPE (0x80, 0x87, ST_PS_AUDIO_AC3); + FILL_TYPE (0x88, 0x9f, ST_PS_AUDIO_DTS); + FILL_TYPE (0xa0, 0xbf, ST_PS_AUDIO_LPCM); + FILL_TYPE (0xbd, 0xbd, -1); + FILL_TYPE (0xc0, 0xdf, ST_AUDIO_MPEG1); + FILL_TYPE (0xe0, 0xef, ST_GST_VIDEO_MPEG1_OR_2); + FILL_TYPE (0xf0, 0xff, -1); + +#undef FILL_TYPE +} + +static GstFlowReturn +gst_flups_demux_parse_pack_start (GstFluPSDemux * demux) +{ + const guint8 *data; + guint length; + guint32 scr1, scr2; + guint64 scr, scr_adjusted, new_rate; + + GST_DEBUG ("parsing pack start"); + + /* fixed length to begin with, start code and two scr values */ + length = 8 + 4; + + if (!(data = gst_adapter_peek (demux->adapter, length))) + goto need_more_data; + + /* skip start code */ + data += 4; + + scr1 = GUINT32_FROM_BE (*(guint32 *) data); + scr2 = GUINT32_FROM_BE (*(guint32 *) (data + 4)); + + /* start parsing the stream */ + if ((*data & 0xc0) == 0x40) { + guint32 scr_ext; + guint32 next32; + guint8 stuffing_bytes; + + GST_DEBUG ("Found MPEG2 stream"); + demux->is_mpeg2_pack = TRUE; + + /* mpeg2 has more data */ + length += 2; + if (gst_adapter_available (demux->adapter) < length) + goto need_more_data; + + /* :2=01 ! scr:3 ! marker:1==1 ! scr:15 ! marker:1==1 ! scr:15 */ + + /* check markers */ + if ((scr1 & 0xc4000400) != 0x44000400) + goto lost_sync; + + scr = ((guint64) scr1 & 0x38000000) << 3; + scr |= ((guint64) scr1 & 0x03fff800) << 4; + scr |= ((guint64) scr1 & 0x000003ff) << 5; + scr |= ((guint64) scr2 & 0xf8000000) >> 27; + + /* marker:1==1 ! scr_ext:9 ! marker:1==1 */ + if ((scr2 & 0x04010000) != 0x04010000) + goto lost_sync; + + scr_ext = (scr2 & 0x03fe0000) >> 17; + /* We keep the offset of this scr */ + demux->last_scr_offset = demux->adapter_offset + 12; + + GST_DEBUG_OBJECT (demux, "SCR: 0x%08x SCRE: 0x%08x", scr, scr_ext); + + if (scr_ext) { + scr = (scr * 300 + scr_ext % 300) / 300; + } + /* SCR has been converted into units of 90Khz ticks to make it comparable + to DTS/PTS, that also implies 1 tick rounding error */ + data += 6; + /* PMR:22 ! :2==11 ! reserved:5 ! stuffing_len:3 */ + next32 = (GUINT32_FROM_BE ((*(guint32 *) data))); + if ((next32 & 0x00000300) != 0x00000300) + goto lost_sync; + + new_rate = (next32 & 0xfffffc00) >> 10; + + stuffing_bytes = (next32 & 0x07); + GST_DEBUG_OBJECT (demux, "stuffing bytes: %d", stuffing_bytes); + + data += 4; + while (stuffing_bytes--) { + if (*data++ != 0xff) + goto lost_sync; + } + } else { + GST_DEBUG ("Found MPEG1 stream"); + demux->is_mpeg2_pack = FALSE; + + /* check markers */ + if ((scr1 & 0xf1000100) != 0x21000100) + goto lost_sync; + + if ((scr2 & 0x01800001) != 0x01800001) + goto lost_sync; + + /* :4=0010 ! scr:3 ! marker:1==1 ! scr:15 ! marker:1==1 ! scr:15 ! marker:1==1 */ + scr = ((guint64) scr1 & 0x0e000000) << 5; + scr |= ((guint64) scr1 & 0x00fffe00) << 6; + scr |= ((guint64) scr1 & 0x000000ff) << 7; + scr |= ((guint64) scr2 & 0xfe000000) >> 25; + + /* We keep the offset of this scr */ + demux->last_scr_offset = demux->adapter_offset + 8; + + /* marker:1==1 ! mux_rate:22 ! marker:1==1 */ + new_rate = (scr2 & 0x007ffffe) >> 1; + + data += 8; + } + new_rate *= MPEG_MUX_RATE_MULT; + + /* scr adjusted is the new scr found + the colected adjustment */ + scr_adjusted = scr + demux->scr_adjust; + + GST_LOG_OBJECT (demux, + "SCR: %" G_GINT64_FORMAT " (%" G_GINT64_FORMAT "), mux_rate %" + G_GINT64_FORMAT ", GStreamer Time:%" GST_TIME_FORMAT, + scr, scr_adjusted, new_rate, + GST_TIME_ARGS (MPEGTIME_TO_GSTTIME ((guint64) scr - demux->first_scr))); + + /* keep the first src in order to calculate delta time */ + if (demux->first_scr == G_MAXUINT64) { + demux->first_scr = scr; + demux->first_scr_offset = demux->last_scr_offset; + demux->base_time = MPEGTIME_TO_GSTTIME (demux->first_scr); + /* at begin consider the new_rate as the scr rate, bytes/clock ticks */ + demux->scr_rate_n = new_rate; + demux->scr_rate_d = CLOCK_FREQ; + } else if (demux->first_scr_offset != demux->last_scr_offset) { + /* estimate byte rate related to the SCR */ + demux->scr_rate_n = demux->last_scr_offset - demux->first_scr_offset; + demux->scr_rate_d = scr - demux->first_scr; + } + + GST_DEBUG_OBJECT (demux, "%s mode scr: %" G_GUINT64_FORMAT " at %" + G_GUINT64_FORMAT ", first scr: %" G_GUINT64_FORMAT + " at %" G_GUINT64_FORMAT ", scr rate: %" G_GUINT64_FORMAT + "/%" G_GUINT64_FORMAT "(%f)", + ((demux->sink_segment.rate >= 0.0) ? "forward" : "backward"), + scr, demux->last_scr_offset, + demux->first_scr, demux->first_scr_offset, + demux->scr_rate_n, demux->scr_rate_d, + (float) demux->scr_rate_n / demux->scr_rate_d); + + /* adjustment of the SCR */ + if (demux->current_scr != G_MAXUINT64) { + gint64 diff; + guint64 old_scr, old_mux_rate, bss, adjust; + + /* keep SCR of the previous packet */ + old_scr = demux->current_scr; + old_mux_rate = demux->mux_rate; + + /* Bytes since SCR is the amount we placed in the adapter since then + * (demux->bytes_since_scr) minus the amount remaining in the adapter, + * clamped to >= 0 */ + bss = MAX (0, (gint) (demux->bytes_since_scr - + gst_adapter_available (demux->adapter))); + + /* estimate the new SCR using the previous one according the notes + on point 2.5.2.2 of the ISO/IEC 13818-1 document */ + adjust = (bss * CLOCK_FREQ) / old_mux_rate; + if (demux->sink_segment.rate >= 0.0) + demux->next_scr = old_scr + adjust; + else + demux->next_scr = old_scr - adjust; + + GST_DEBUG_OBJECT (demux, + "bss: %" G_GUINT64_FORMAT ", next_scr: %" G_GUINT64_FORMAT + ", old_scr: %" G_GUINT64_FORMAT ", scr: %" G_GUINT64_FORMAT, + bss, demux->next_scr, old_scr, scr_adjusted); + + /* calculate the absolute deference between the last scr and + the new one */ + if (old_scr > scr_adjusted) + diff = old_scr - scr_adjusted; + else + diff = scr_adjusted - old_scr; + + /* if the difference is more than 1 second we need to reconfigure + adjustment */ + if (diff > CLOCK_FREQ) { + demux->scr_adjust = demux->next_scr - scr; + GST_DEBUG_OBJECT (demux, "discont found, diff: %" G_GINT64_FORMAT + ", adjust %" G_GINT64_FORMAT, diff, demux->scr_adjust); + scr_adjusted = demux->next_scr; + } else { + demux->next_scr = scr_adjusted; + } + } + + /* update the current_scr and rate members */ + demux->mux_rate = new_rate; + demux->current_scr = scr_adjusted; + + /* Reset the bytes_since_scr value to count the data remaining in the + * adapter */ + demux->bytes_since_scr = gst_adapter_available (demux->adapter); + + gst_adapter_flush (demux->adapter, length); + ADAPTER_OFFSET_FLUSH (length); + return GST_FLOW_OK; + +lost_sync: + { + GST_DEBUG_OBJECT (demux, "lost sync"); + return GST_FLOW_LOST_SYNC; + } +need_more_data: + { + GST_DEBUG_OBJECT (demux, "need more data"); + return GST_FLOW_NEED_MORE_DATA; + } +} + +static GstFlowReturn +gst_flups_demux_parse_sys_head (GstFluPSDemux * demux) +{ + guint16 length; + const guint8 *data; + gboolean csps; + + /* start code + length */ + if (!(data = gst_adapter_peek (demux->adapter, 6))) + goto need_more_data; + + /* skip start code */ + data += 4; + + length = GST_READ_UINT16_BE (data); + GST_DEBUG_OBJECT (demux, "length %d", length); + + length += 6; + + if (!(data = gst_adapter_peek (demux->adapter, length))) + goto need_more_data; + + /* skip start code and length */ + data += 6; + + /* marker:1==1 ! rate_bound:22 | marker:1==1 */ + if ((*data & 0x80) != 0x80) + goto marker_expected; + + { + guint32 rate_bound; + + if ((data[2] & 0x01) != 0x01) + goto marker_expected; + + rate_bound = ((guint32) data[0] & 0x7f) << 15; + rate_bound |= ((guint32) data[1]) << 7; + rate_bound |= ((guint32) data[2] & 0xfe) >> 1; + rate_bound *= MPEG_MUX_RATE_MULT; + + GST_DEBUG_OBJECT (demux, "rate bound %u", rate_bound); + + data += 3; + } + + /* audio_bound:6==1 ! fixed:1 | constrained:1 */ + { + guint8 audio_bound; + gboolean fixed; + + /* max number of simultaneous audio streams active */ + audio_bound = (data[0] & 0xfc) >> 2; + /* fixed or variable bitrate */ + fixed = (data[0] & 0x02) == 0x02; + /* meeting constraints */ + csps = (data[0] & 0x01) == 0x01; + + GST_DEBUG_OBJECT (demux, "audio_bound %d, fixed %d, constrained %d", + audio_bound, fixed, csps); + data += 1; + } + + /* audio_lock:1 | video_lock:1 | marker:1==1 | video_bound:5 */ + { + gboolean audio_lock; + gboolean video_lock; + guint8 video_bound; + + audio_lock = (data[0] & 0x80) == 0x80; + video_lock = (data[0] & 0x40) == 0x40; + + if ((data[0] & 0x20) != 0x20) + goto marker_expected; + + /* max number of simultaneous video streams active */ + video_bound = (data[0] & 0x1f); + + GST_DEBUG_OBJECT (demux, "audio_lock %d, video_lock %d, video_bound %d", + audio_lock, video_lock, video_bound); + data += 1; + } + + /* packet_rate_restriction:1 | reserved:7==0x7F */ + { + gboolean packet_rate_restriction; + + if ((data[0] & 0x7f) != 0x7f) + goto marker_expected; + + /* only valid if csps is set */ + if (csps) { + packet_rate_restriction = (data[0] & 0x80) == 0x80; + + GST_DEBUG_OBJECT (demux, "packet_rate_restriction %d", + packet_rate_restriction); + } + } + data += 1; + + { + gint stream_count = (length - 12) / 3; + gint i; + + GST_DEBUG_OBJECT (demux, "number of streams: %d ", stream_count); + + for (i = 0; i < stream_count; i++) { + guint8 stream_id; + gboolean STD_buffer_bound_scale; + guint16 STD_buffer_size_bound; + guint32 buf_byte_size_bound; + + stream_id = *data++; + if (!(stream_id & 0x80)) + goto sys_len_error; + + /* check marker bits */ + if ((*data & 0xC0) != 0xC0) + goto no_placeholder_bits; + + STD_buffer_bound_scale = *data & 0x20; + STD_buffer_size_bound = ((guint16) (*data++ & 0x1F)) << 8; + STD_buffer_size_bound |= *data++; + + if (STD_buffer_bound_scale == 0) { + buf_byte_size_bound = STD_buffer_size_bound * 128; + } else { + buf_byte_size_bound = STD_buffer_size_bound * 1024; + } + + GST_DEBUG_OBJECT (demux, "STD_buffer_bound_scale %d", + STD_buffer_bound_scale); + GST_DEBUG_OBJECT (demux, "STD_buffer_size_bound %d or %d bytes", + STD_buffer_size_bound, buf_byte_size_bound); + } + } + + gst_adapter_flush (demux->adapter, length); + ADAPTER_OFFSET_FLUSH (length); + return GST_FLOW_OK; + + /* ERRORS */ +marker_expected: + { + GST_DEBUG_OBJECT (demux, "expecting marker"); + return GST_FLOW_LOST_SYNC; + } +no_placeholder_bits: + { + GST_DEBUG_OBJECT (demux, "expecting placeholder bit values" + " '11' after stream id"); + return GST_FLOW_LOST_SYNC; + } +sys_len_error: + { + GST_DEBUG_OBJECT (demux, "error in system header length"); + return GST_FLOW_LOST_SYNC; + } +need_more_data: + { + GST_DEBUG_OBJECT (demux, "need more data"); + return GST_FLOW_NEED_MORE_DATA; + } +} + +static GstFlowReturn +gst_flups_demux_parse_psm (GstFluPSDemux * demux) +{ + guint16 length = 0, info_length = 0, es_map_length = 0; + guint8 psm_version = 0; + const guint8 *data, *es_map_base; + gboolean applicable; + + /* start code + length */ + if (!(data = gst_adapter_peek (demux->adapter, 6))) + goto need_more_data; + + /* skip start code */ + data += 4; + + length = GST_READ_UINT16_BE (data); + GST_DEBUG_OBJECT (demux, "length %u", length); + + if (G_UNLIKELY (length > 0x3FA)) + goto psm_len_error; + + length += 6; + + if (!(data = gst_adapter_peek (demux->adapter, length))) + goto need_more_data; + + /* skip start code and length */ + data += 6; + + /* Read PSM applicable bit together with version */ + psm_version = GST_READ_UINT8 (data); + applicable = (psm_version & 0x80) >> 7; + psm_version &= 0x1F; + GST_DEBUG_OBJECT (demux, "PSM version %u (applicable now %u)", psm_version, + applicable); + + /* Jump over version and marker bit */ + data += 2; + + /* Read PS info length */ + info_length = GST_READ_UINT16_BE (data); + /* Cap it to PSM length - needed bytes for ES map length and CRC */ + info_length = MIN (length - 16, info_length); + GST_DEBUG_OBJECT (demux, "PS info length %u bytes", info_length); + + /* Jump over that section */ + data += (2 + info_length); + + /* Read ES map length */ + es_map_length = GST_READ_UINT16_BE (data); + /* Cap it to PSM remaining length - CRC */ + es_map_length = MIN (length - (16 + info_length), es_map_length); + GST_DEBUG_OBJECT (demux, "ES map length %u bytes", es_map_length); + + /* Jump over the size */ + data += 2; + + /* Now read the ES map */ + es_map_base = data; + while (es_map_base + 4 <= data + es_map_length) { + guint8 stream_type = 0, stream_id = 0; + guint16 stream_info_length = 0; + + stream_type = GST_READ_UINT8 (es_map_base); + es_map_base++; + stream_id = GST_READ_UINT8 (es_map_base); + es_map_base++; + stream_info_length = GST_READ_UINT16_BE (es_map_base); + es_map_base += 2; + /* Cap stream_info_length */ + stream_info_length = MIN (data + es_map_length - es_map_base, + stream_info_length); + + GST_DEBUG_OBJECT (demux, "Stream type %02X with id %02X and %u bytes info", + stream_type, stream_id, stream_info_length); + demux->psm[stream_id] = stream_type; + es_map_base += stream_info_length; + } + + gst_adapter_flush (demux->adapter, length); + ADAPTER_OFFSET_FLUSH (length); + return GST_FLOW_OK; + +psm_len_error: + { + GST_DEBUG_OBJECT (demux, "error in PSM length"); + return GST_FLOW_LOST_SYNC; + } +need_more_data: + { + GST_DEBUG_OBJECT (demux, "need more data"); + return GST_FLOW_NEED_MORE_DATA; + } +} + +static void +gst_flups_demux_resync_cb (GstPESFilter * filter, GstFluPSDemux * demux) +{ +} + +static GstFlowReturn +gst_flups_demux_data_cb (GstPESFilter * filter, gboolean first, + GstBuffer * buffer, GstFluPSDemux * demux) +{ + GstBuffer *out_buf; + GstFlowReturn ret = GST_FLOW_OK; + gint stream_type; + guint32 start_code; + guint8 id; + guint8 *data; + guint datalen; + guint offset = 0; + + data = GST_BUFFER_DATA (buffer); + datalen = GST_BUFFER_SIZE (buffer); + + start_code = filter->start_code; + id = filter->id; + + if (first) { + /* find the stream type */ + stream_type = demux->psm[id]; + if (stream_type == -1) { + /* no stream type, if PS1, get the new id */ + if (start_code == ID_PRIVATE_STREAM_1 && datalen >= 2) { + guint8 nframes; + + /* VDR writes A52 streams without any header bytes + * (see ftp://ftp.mplayerhq.hu/MPlayer/samples/MPEG-VOB/vdr-AC3) */ + if (datalen >= 4) { + guint hdr = GST_READ_UINT32_BE (data); + + if (G_UNLIKELY ((hdr & 0xffff0000) == AC3_SYNC_WORD)) { + id = 0x80; + stream_type = demux->psm[id] = ST_GST_AUDIO_RAWA52; + GST_DEBUG_OBJECT (demux, "Found VDR raw A52 stream"); + } + } + + if (G_LIKELY (stream_type == -1)) { + /* new id */ + id = data[offset++]; + /* Number of audio frames in this packet */ + nframes = data[offset++]; + + GST_DEBUG_OBJECT (demux, "private type 0x%02x, %d frames", id, + nframes); + + datalen -= 2; + + /* and remap */ + stream_type = demux->psm[id]; + } + } + if (stream_type == -1) + goto unknown_stream_type; + } + if (filter->pts != -1) { + demux->next_pts = filter->pts + demux->scr_adjust; + GST_DEBUG_OBJECT (demux, "PTS = %" G_GUINT64_FORMAT + "(%" G_GUINT64_FORMAT ")", filter->pts, demux->next_pts); + } else + demux->next_pts = G_MAXUINT64; + + if (filter->dts != -1) { + demux->next_dts = filter->dts + demux->scr_adjust; + } else { + demux->next_dts = demux->next_pts; + } + GST_DEBUG_OBJECT (demux, "DTS = orig %" G_GUINT64_FORMAT + " (%" G_GUINT64_FORMAT ")", filter->dts, demux->next_dts); + + demux->current_stream = gst_flups_demux_get_stream (demux, id, stream_type); + } + + if (demux->current_stream == NULL) { + GST_DEBUG_OBJECT (demux, "Dropping buffer for unknown stream id 0x%02x", + id); + goto done; + } + + /* After 2 seconds of bitstream emit no more pads */ + if (demux->need_no_more_pads + && (demux->current_scr - demux->first_scr) > 2 * CLOCK_FREQ) { + GST_DEBUG_OBJECT (demux, "no more pads, notifying"); + gst_element_no_more_pads (GST_ELEMENT_CAST (demux)); + demux->need_no_more_pads = FALSE; + } + + /* If the stream is not-linked, don't bother creating a sub-buffer + * to send to it, unless we're processing a discont (which resets + * the not-linked status and tries again */ + if (demux->current_stream->discont) { + GST_DEBUG_OBJECT (demux, "stream is discont"); + demux->current_stream->notlinked = FALSE; + } + + if (demux->current_stream->notlinked == FALSE) { + out_buf = gst_buffer_create_sub (buffer, offset, datalen); + + ret = gst_flups_demux_send_data (demux, demux->current_stream, out_buf); + if (ret == GST_FLOW_NOT_LINKED) { + demux->current_stream->notlinked = TRUE; + ret = GST_FLOW_OK; + } + } + +done: + gst_buffer_unref (buffer); + + return ret; + + /* ERRORS */ +unknown_stream_type: + { + GST_DEBUG_OBJECT (demux, "unknown stream type %02x", id); + ret = GST_FLOW_OK; + goto done; + } +} + +static gboolean +gst_flups_demux_resync (GstFluPSDemux * demux, gboolean save) +{ + const guint8 *data; + gint avail; + guint32 code; + gint offset; + gboolean found; + + avail = gst_adapter_available (demux->adapter); + if (avail < 4) + goto need_data; + + /* Common case, read 4 bytes an check it */ + data = gst_adapter_peek (demux->adapter, 4); + + /* read currect code */ + code = GST_READ_UINT32_BE (data); + + /* The common case is that the sync code is at 0 bytes offset */ + if (G_LIKELY ((code & 0xffffff00) == 0x100L)) { + GST_LOG_OBJECT (demux, "Found resync code %08x after 0 bytes", code); + demux->last_sync_code = code; + return TRUE; + } + + /* Otherwise, we are starting at byte 4 and we need to search + the sync code in all available data in the adapter */ + offset = 4; + if (offset >= avail) + goto need_data; /* Not enough data to find sync */ + + data = gst_adapter_peek (demux->adapter, avail); + + do { + code = (code << 8) | data[offset++]; + found = (code & 0xffffff00) == 0x100L; + } while (offset < avail && !found); + + if (!save || demux->sink_segment.rate >= 0.0) { + GST_LOG_OBJECT (demux, "flushing %d bytes", offset - 4); + /* forward playback, we can discard and flush the skipped bytes */ + gst_adapter_flush (demux->adapter, offset - 4); + ADAPTER_OFFSET_FLUSH (offset - 4); + } else { + if (found) { + GST_LOG_OBJECT (demux, "reverse saving %d bytes", offset - 4); + /* reverse playback, we keep the flushed bytes and we will append them to + * the next buffer in the chain function, which is the previous buffer in + * the stream. */ + gst_adapter_push (demux->rev_adapter, + gst_adapter_take_buffer (demux->adapter, offset - 4)); + } else { + GST_LOG_OBJECT (demux, "reverse saving %d bytes", avail); + /* nothing found, keep all bytes */ + gst_adapter_push (demux->rev_adapter, + gst_adapter_take_buffer (demux->adapter, avail)); + } + } + + if (found) { + GST_LOG_OBJECT (demux, "Found resync code %08x after %d bytes", + code, offset - 4); + demux->last_sync_code = code; + } else { + GST_LOG_OBJECT (demux, "No resync after skipping %d", offset); + } + + return found; + +need_data: + { + GST_LOG_OBJECT (demux, "we need more data for resync %d", avail); + return FALSE; + } +} + +static gboolean +gst_flups_demux_is_pes_sync (guint32 sync) +{ + return ((sync & 0xfc) == 0xbc) || + ((sync & 0xe0) == 0xc0) || ((sync & 0xf0) == 0xe0); +} + +static GstFlowReturn +gst_flups_demux_chain (GstPad * pad, GstBuffer * buffer) +{ + GstFluPSDemux *demux = GST_FLUPS_DEMUX (gst_pad_get_parent (pad)); + GstFlowReturn ret = GST_FLOW_OK; + guint32 avail; + gboolean save, discont; + + discont = GST_BUFFER_IS_DISCONT (buffer); + + if (discont) { + GST_LOG_OBJECT (demux, "Received buffer with discont flag and" + " offset %" G_GUINT64_FORMAT, GST_BUFFER_OFFSET (buffer)); + + gst_pes_filter_drain (&demux->filter); + gst_flups_demux_mark_discont (demux, TRUE, FALSE); + + /* mark discont on all streams */ + if (demux->sink_segment.rate >= 0.0) { + demux->current_scr = G_MAXUINT64; + demux->bytes_since_scr = 0; + } + } else { + GST_LOG_OBJECT (demux, "Received buffer with offset %" G_GUINT64_FORMAT, + GST_BUFFER_OFFSET (buffer)); + } + + /* We keep the offset to interpolate SCR */ + demux->adapter_offset = GST_BUFFER_OFFSET (buffer); + + gst_adapter_push (demux->adapter, buffer); + demux->bytes_since_scr += GST_BUFFER_SIZE (buffer); + + avail = gst_adapter_available (demux->rev_adapter); + if (avail > 0) { + GST_LOG_OBJECT (demux, "appending %u saved bytes", avail); + /* if we have a previous reverse chunk, append this now */ + /* FIXME this code assumes we receive discont buffers all thei + * time */ + gst_adapter_push (demux->adapter, + gst_adapter_take_buffer (demux->rev_adapter, avail)); + } + + avail = gst_adapter_available (demux->adapter); + GST_LOG_OBJECT (demux, "avail now: %d, state %d", avail, demux->filter.state); + + switch (demux->filter.state) { + case STATE_DATA_SKIP: + case STATE_DATA_PUSH: + ret = gst_pes_filter_process (&demux->filter); + break; + case STATE_HEADER_PARSE: + break; + default: + break; + } + + switch (ret) { + case GST_FLOW_NEED_MORE_DATA: + /* Go and get more data */ + ret = GST_FLOW_OK; + goto done; + case GST_FLOW_LOST_SYNC: + /* for FLOW_OK or lost-sync, carry onto resync */ + ret = GST_FLOW_OK; + break; + case GST_FLOW_OK: + break; + default: + /* Any other return value should be sent upstream immediately */ + goto done; + } + + /* align adapter data to sync boundary, we keep the data up to the next sync + * point. */ + save = TRUE; + while (gst_flups_demux_resync (demux, save)) { + gboolean ps_sync = TRUE; + + /* now switch on last synced byte */ + switch (demux->last_sync_code) { + case ID_PS_PACK_START_CODE: + ret = gst_flups_demux_parse_pack_start (demux); + break; + case ID_PS_SYSTEM_HEADER_START_CODE: + ret = gst_flups_demux_parse_sys_head (demux); + break; + case ID_PS_END_CODE: + ret = GST_FLOW_OK; + goto done; + case ID_PS_PROGRAM_STREAM_MAP: + ret = gst_flups_demux_parse_psm (demux); + break; + default: + if (gst_flups_demux_is_pes_sync (demux->last_sync_code)) { + ret = gst_pes_filter_process (&demux->filter); + } else { + GST_DEBUG_OBJECT (demux, "sync_code=%08x, non PES sync found" + ", continuing", demux->last_sync_code); + ps_sync = FALSE; + ret = GST_FLOW_LOST_SYNC; + } + break; + } + /* if we found a ps sync, we stop saving the data, any non-ps sync gets + * saved up to the next ps sync. */ + if (ps_sync) + save = FALSE; + + switch (ret) { + case GST_FLOW_NEED_MORE_DATA: + GST_DEBUG_OBJECT (demux, "need more data"); + ret = GST_FLOW_OK; + goto done; + case GST_FLOW_LOST_SYNC: + if (!save || demux->sink_segment.rate >= 0.0) { + GST_DEBUG_OBJECT (demux, "flushing 3 bytes"); + gst_adapter_flush (demux->adapter, 3); + ADAPTER_OFFSET_FLUSH (3); + } else { + GST_DEBUG_OBJECT (demux, "saving 3 bytes"); + gst_adapter_push (demux->rev_adapter, + gst_adapter_take_buffer (demux->adapter, 3)); + } + ret = GST_FLOW_OK; + break; + default: + break; + } + } +done: + gst_object_unref (demux); + + return ret; +} + +static GstStateChangeReturn +gst_flups_demux_change_state (GstElement * element, GstStateChange transition) +{ + GstFluPSDemux *demux = GST_FLUPS_DEMUX (element); + GstStateChangeReturn result; + + switch (transition) { + case GST_STATE_CHANGE_NULL_TO_READY: + demux->adapter = gst_adapter_new (); + demux->rev_adapter = gst_adapter_new (); + demux->adapter_offset = G_MAXUINT64; + gst_pes_filter_init (&demux->filter, demux->adapter, + &demux->adapter_offset); + gst_pes_filter_set_callbacks (&demux->filter, + (GstPESFilterData) gst_flups_demux_data_cb, + (GstPESFilterResync) gst_flups_demux_resync_cb, demux); + demux->filter.gather_pes = TRUE; + demux->first_scr = G_MAXUINT64; + demux->current_scr = G_MAXUINT64; + demux->base_time = G_MAXUINT64; + demux->scr_rate_n = G_MAXUINT64; + demux->scr_rate_d = G_MAXUINT64; + break; + case GST_STATE_CHANGE_READY_TO_PAUSED: + demux->current_scr = G_MAXUINT64; + demux->mux_rate = G_MAXUINT64; + demux->next_pts = G_MAXUINT64; + demux->next_dts = G_MAXUINT64; + demux->first_scr = G_MAXUINT64; + demux->base_time = G_MAXUINT64; + demux->scr_rate_n = G_MAXUINT64; + demux->scr_rate_d = G_MAXUINT64; + demux->need_no_more_pads = TRUE; + + gst_flups_demux_reset_psm (demux); + gst_segment_init (&demux->sink_segment, GST_FORMAT_UNDEFINED); + gst_segment_init (&demux->src_segment, GST_FORMAT_TIME); + break; + default: + break; + } + + result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + gst_flups_demux_reset (demux); + break; + case GST_STATE_CHANGE_READY_TO_NULL: + gst_pes_filter_uninit (&demux->filter); + g_object_unref (demux->adapter); + demux->adapter = NULL; + g_object_unref (demux->rev_adapter); + demux->rev_adapter = NULL; + break; + default: + break; + } + + return result; +} + +gboolean +gst_flups_demux_plugin_init (GstPlugin * plugin) +{ + if (!gst_element_register (plugin, "flupsdemux", + GST_RANK_PRIMARY, GST_TYPE_FLUPS_DEMUX)) + return FALSE; + + return TRUE; +} diff --git a/gst/mpegdemux/gstmpegdemux.h b/gst/mpegdemux/gstmpegdemux.h new file mode 100644 index 0000000..3730bac --- /dev/null +++ b/gst/mpegdemux/gstmpegdemux.h @@ -0,0 +1,152 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifndef __GST_FLUPS_DEMUX_H__ +#define __GST_FLUPS_DEMUX_H__ + +#include +#include + +#include "gstpesfilter.h" + +G_BEGIN_DECLS + +#define GST_TYPE_FLUPS_DEMUX (gst_flups_demux_get_type()) +#define GST_FLUPS_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_FLUPS_DEMUX,GstFluPSDemux)) +#define GST_FLUPS_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_FLUPS_DEMUX,GstFluPSDemuxClass)) +#define GST_FLUPS_DEMUX_GET_CLASS(klass) (G_TYPE_INSTANCE_GET_CLASS((klass),GST_TYPE_FLUPS_DEMUX,GstFluPSDemuxClass)) +#define GST_IS_FLUPS_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_FLUPS_DEMUX)) +#define GST_IS_FLUPS_DEMUX_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_FLUPS_DEMUX)) + +typedef struct _GstFluPSStream GstFluPSStream; +typedef struct _GstFluPSDemux GstFluPSDemux; +typedef struct _GstFluPSDemuxClass GstFluPSDemuxClass; + +#define GST_FLUPS_DEMUX_MAX_STREAMS 256 +#define GST_FLUPS_DEMUX_MAX_PSM 256 + +typedef enum { + GST_FLUPS_DEMUX_SYNC_AUTO = 0, + GST_FLUPS_DEMUX_SYNC_SCR = 1, + GST_FLUPS_DEMUX_SYNC_DTS = 2 +} GstFluPSDemuxSync; + +typedef enum { + STATE_FLUPS_DEMUX_NEED_SYNC, + STATE_FLUPS_DEMUX_SYNCED, + STATE_FLUPS_DEMUX_NEED_MORE_DATA, +} GstFluPSDemuxState; + +/* Information associated with a single FluPS stream. */ +struct _GstFluPSStream { + GstPad * pad; + + gint id; + gint type; + gint size_bound; + + gboolean discont; + gboolean notlinked; + gboolean need_segment; +}; + +struct _GstFluPSDemux { + GstElement parent; + + GstPad * sinkpad; + + GstAdapter * adapter; + GstAdapter * rev_adapter; + guint64 adapter_offset; + guint32 last_sync_code; + GstPESFilter filter; + + gint64 mux_rate; + guint64 first_scr; + guint64 first_dts; + guint64 base_time; + guint64 current_scr; + guint64 next_scr; + guint64 bytes_since_scr; + gint64 scr_adjust; + guint64 scr_rate_n; + guint64 scr_rate_d; + guint64 first_scr_offset; + guint64 last_scr_offset; + + gint16 psm[GST_FLUPS_DEMUX_MAX_PSM]; + + GstSegment sink_segment; + GstSegment src_segment; + + /* stream output */ + GstFluPSStream * current_stream; + guint64 next_pts; + guint64 next_dts; + GstFluPSStream ** streams; + gboolean need_no_more_pads; + + /* Indicates an MPEG-2 stream */ + gboolean is_mpeg2_pack; + + /* Language codes event is stored when a dvd-lang-codes + * custom event arrives from upstream */ + GstEvent * lang_codes; +}; + +struct _GstFluPSDemuxClass { + GstElementClass parent_class; + + GstPadTemplate *sink_template; + GstPadTemplate *video_template; + GstPadTemplate *audio_template; + GstPadTemplate *private_template; +}; + +GType gst_flups_demux_get_type (void); + +gboolean gst_flups_demux_plugin_init (GstPlugin *plugin); + +G_END_DECLS + +#endif /* __GST_FLUPS_DEMUX_H__ */ diff --git a/gst/mpegdemux/gstmpegdesc.c b/gst/mpegdemux/gstmpegdesc.c new file mode 100644 index 0000000..1bab07b --- /dev/null +++ b/gst/mpegdemux/gstmpegdesc.c @@ -0,0 +1,178 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#include + +#include + +#include "gstmpegdesc.h" + +void +gst_mpeg_descriptor_free (GstMPEGDescriptor * desc) +{ + g_return_if_fail (desc != NULL); + + g_free (desc); +} + +static guint +gst_mpeg_descriptor_parse_1 (guint8 * data, guint size) +{ + guint8 tag; + guint8 length; + + /* need at least 2 bytes for tag and length */ + if (size < 2) + return 0; + + tag = *data++; + length = *data++; + size -= 2; + + GST_DEBUG ("tag: 0x%02x, length: %d", tag, length); + + if (length > size) + return 0; + + return length + 2;; +} + +GstMPEGDescriptor * +gst_mpeg_descriptor_parse (guint8 * data, guint size) +{ + guint8 *current; + guint consumed, total, n_desc; + GstMPEGDescriptor *result; + + g_return_val_if_fail (data != NULL, NULL); + + current = data; + total = 0; + n_desc = 0; + + do { + consumed = gst_mpeg_descriptor_parse_1 (current, size); + + if (consumed > 0) { + current += consumed; + total += consumed; + size -= consumed; + n_desc++; + } + } + while (consumed > 0); + + GST_DEBUG ("parsed %d descriptors", n_desc); + + if (total == 0) + return NULL; + + result = g_malloc (sizeof (GstMPEGDescriptor) + total); + result->n_desc = n_desc; + result->data_length = total; + result->data = ((guint8 *) result) + sizeof (GstMPEGDescriptor); + + memcpy (result->data, data, total); + + return result; +} + +guint +gst_mpeg_descriptor_n_desc (GstMPEGDescriptor * desc) +{ + g_return_val_if_fail (desc != NULL, 0); + + return desc->n_desc; +} + +guint8 * +gst_mpeg_descriptor_find (GstMPEGDescriptor * desc, gint tag) +{ + gint length; + guint8 *current; + guint size; + + g_return_val_if_fail (desc != NULL, NULL); + + current = desc->data; + length = desc->data_length; + + while (length > 0) { + if (DESC_TAG (current) == tag) + return current; + + size = DESC_LENGTH (current) + 2; + + current += size; + length -= size; + } + return NULL; +} + +guint8 * +gst_mpeg_descriptor_nth (GstMPEGDescriptor * desc, guint i) +{ + gint length; + guint8 *current; + guint size; + + g_return_val_if_fail (desc != NULL, NULL); + + if (i > desc->n_desc) + return NULL; + + current = desc->data; + length = desc->data_length; + + while (length > 0) { + if (i == 0) + return current; + + size = DESC_LENGTH (current) + 2; + + current += size; + length -= size; + i--; + } + return NULL; +} diff --git a/gst/mpegdemux/gstmpegdesc.h b/gst/mpegdemux/gstmpegdesc.h new file mode 100644 index 0000000..91a4221 --- /dev/null +++ b/gst/mpegdemux/gstmpegdesc.h @@ -0,0 +1,271 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifndef __GST_MPEG_DESC_H__ +#define __GST_MPEG_DESC_H__ + +#include +/* + * descriptor_tag TS PS Identification + * 0 n/a n/a Reserved + * 1 n/a n/a Reserved + * 2 X X video_stream_descriptor + * 3 X X audio_stream_descriptor + * 4 X X hierarchy_descriptor + * 5 X X registration_descriptor + * 6 X X data_stream_alignment_descriptor + * 7 X X target_background_grid_descriptor + * 8 X X video_window_descriptor + * 9 X X CA_descriptor + * 10 X X ISO_639_language_descriptor + * 11 X X system_clock_descriptor + * 12 X X multiplex_buffer_utilization_descriptor + * 13 X X copyright_descriptor + * 14 X maximum bitrate descriptor + * 15 X X private data indicator descriptor + * 16 X X smoothing buffer descriptor + * 17 X STD_descriptor + * 18 X X IBP descriptor + * 19-63 n/a n/a ITU-T Rec. H.222.0 | ISO/IEC 13818-1 Reserved + * 64-255 n/a n/a User Private + */ +#define DESC_VIDEO_STREAM 2 +#define DESC_AUDIO_STREAM 3 +#define DESC_HIERARCHY 4 +#define DESC_REGISTRATION 5 +#define DESC_DATA_STREAM_ALIGNMENT 6 +#define DESC_TARGET_BACKGROUND_GRID 7 +#define DESC_VIDEO_WINDOW 8 +#define DESC_CA 9 +#define DESC_ISO_639_LANGUAGE 10 +#define DESC_SYSTEM_CLOCK 11 +#define DESC_MULTIPLEX_BUFFER_UTILISATION 12 +#define DESC_COPYRIGHT 13 +#define DESC_MAXIMUM_BITRATE 14 +#define DESC_PRIVATE_DATA_INDICATOR 15 +#define DESC_SMOOTHING_BUFFER 16 +#define DESC_STD 17 +#define DESC_IBP 18 + +#define DESC_DIRAC_TC_PRIVATE 0xAC + +/* DVB tags */ +#define DESC_DVB_NETWORK_NAME 0x40 +#define DESC_DVB_SERVICE_LIST 0x41 +#define DESC_DVB_STUFFING 0x42 +#define DESC_DVB_SATELLITE_DELIVERY_SYSTEM 0x43 +#define DESC_DVB_CABLE_DELIVERY_SYSTEM 0x44 +#define DESC_DVB_VBI_DATA 0x45 +#define DESC_DVB_VBI_TELETEXT 0x46 +#define DESC_DVB_BOUQUET_NAME 0x47 +#define DESC_DVB_SERVICE 0x48 +#define DESC_DVB_COUNTRY_AVAILABILITY 0x49 +#define DESC_DVB_LINKAGE 0x4A +#define DESC_DVB_NVOD_REFERENCE 0x4B +#define DESC_DVB_TIME_SHIFTED_SERVICE 0x4C +#define DESC_DVB_SHORT_EVENT 0x4D +#define DESC_DVB_EXTENDED_EVENT 0x4E +#define DESC_DVB_TIME_SHIFTED_EVENT 0x4F +#define DESC_DVB_COMPONENT 0x50 +#define DESC_DVB_MOSAIC 0x51 +#define DESC_DVB_STREAM_IDENTIFIER 0x52 +#define DESC_DVB_CA_IDENTIFIER 0x53 +#define DESC_DVB_CONTENT 0x54 +#define DESC_DVB_PARENTAL_RATING 0x55 +#define DESC_DVB_TELETEXT 0x56 +#define DESC_DVB_TELEPHONE 0x57 +#define DESC_DVB_LOCAL_TIME_OFFSET 0x58 +#define DESC_DVB_SUBTITLING 0x59 +#define DESC_DVB_TERRESTRIAL_DELIVERY_SYSTEM 0x5A +#define DESC_DVB_MULTILINGUAL_NETWORK_NAME 0x5B +#define DESC_DVB_MULTILINGUAL_BOUQUET_NAME 0x5C +#define DESC_DVB_MULTILINGUAL_SERVICE_NAME 0x5D +#define DESC_DVB_MULTILINGUAL_COMPONENT 0x5E +#define DESC_DVB_PRIVATE_DATA 0x5F +#define DESC_DVB_SERVICE_MOVE 0x60 +#define DESC_DVB_SHORT_SMOOTHING_BUFFER 0x61 +#define DESC_DVB_FREQUENCY_LIST 0x62 +#define DESC_DVB_PARTIAL_TRANSPORT_STREAM 0x63 +#define DESC_DVB_DATA_BROADCAST 0x64 +#define DESC_DVB_SCRAMBLING 0x65 +#define DESC_DVB_DATA_BROADCAST_ID 0x66 +#define DESC_DVB_TRANSPORT_STREAM 0x67 +#define DESC_DVB_DSNG 0x68 +#define DESC_DVB_PDC 0x69 +#define DESC_DVB_AC3 0x6A +#define DESC_DVB_ANCILLARY_DATA 0x6B +#define DESC_DVB_CELL_LIST 0x6C +#define DESC_DVB_CELL_FREQUENCY_LINK 0x6D +#define DESC_DVB_ANNOUNCEMENT_SUPPORT 0x6E +#define DESC_DVB_APPLICATION_SIGNALLING 0x6F +#define DESC_DVB_ADAPTATION_FIELD_DATA 0x70 +#define DESC_DVB_SERVICE_IDENTIFIER 0x71 +#define DESC_DVB_SERVICE_AVAILABILITY 0x72 +#define DESC_DVB_DEFAULT_AUTHORITY 0x73 +#define DESC_DVB_RELATED_CONTENT 0x74 +#define DESC_DVB_TVA_ID 0x75 +#define DESC_DVB_CONTENT_IDENTIFIER 0x76 +#define DESC_DVB_TIMESLICE_FEC_IDENTIFIER 0x77 +#define DESC_DVB_ECM_REPETITION_RATE 0x78 +#define DESC_DVB_S2_SATELLITE_DELIVERY_SYSTEM 0x79 +#define DESC_DVB_ENHANCED_AC3 0x7A +#define DESC_DVB_DTS 0x7B +#define DESC_DVB_AAC 0x7C +/* 0x7D and 0x7E are reserved for future use */ +#define DESC_DVB_EXTENSION 0x7F +/* 0x80 - 0xFE are user defined */ +/* 0xFF is forbidden */ + +/* common for all descriptors */ +#define DESC_TAG(desc) (desc[0]) +#define DESC_LENGTH(desc) (desc[1]) + +/* video_stream_descriptor */ +#define DESC_VIDEO_STREAM_multiple_framerate_flag(desc) (((desc)[2] & 0x80) == 0x80) +#define DESC_VIDEO_STREAM_frame_rate_code(desc) (((desc)[2] & 0x38) >> 3) +#define DESC_VIDEO_STREAM_MPEG_1_only_flag(desc) (((desc)[2] & 0x04) == 0x04) +#define DESC_VIDEO_STREAM_constrained_parameter_flag(desc) (((desc)[2] & 0x02) == 0x02) +#define DESC_VIDEO_STREAM_still_picture_flag(desc) (((desc)[2] & 0x01) == 0x01) +/* if (MPEG_1_only_flag == 1) */ +#define DESC_VIDEO_STREAM_profile_and_level_indication(desc) ((desc)[3]) +#define DESC_VIDEO_STREAM_chroma_format(desc) (((desc)[4] & 0xc0) >> 6) +#define DESC_VIDEO_STREAM_frame_rate_extension_flag(desc) (((desc)[4] & 0x20) == 0x20) + +/* audio_stream_descriptor */ +#define DESC_AUDIO_STREAM_free_format_flag(desc) (((desc)[2] & 0x80) == 0x80) +#define DESC_AUDIO_STREAM_ID(desc) (((desc)[2] & 0x40) == 0x40) +#define DESC_AUDIO_STREAM_layer(desc) (((desc)[2] & 0x30) >> 4) +#define DESC_AUDIO_STREAM_variable_rate_audio_indicator(desc) (((desc)[2] & 0x08) == 0x08) + +/* hierarchy_descriptor */ +#define DESC_HIERARCHY_hierarchy_type(desc) (((desc)[2] & 0x0f)) +#define DESC_HIERARCHY_hierarchy_layer_index(desc) (((desc)[3] & 0x3f)) +#define DESC_HIERARCHY_hierarchy_embedded_layer_index(desc) (((desc)[4] & 0x3f)) +#define DESC_HIERARCHY_hierarchy_channel(desc) (((desc)[5] & 0x3f)) + +/* registration_descriptor */ +#define DESC_REGISTRATION_format_identifier(desc) (GST_READ_UINT32_BE ((desc)+2)) +#define DESC_REGISTRATION_additional_ident_info_len(desc) ((desc)[1] - 4) +#define DESC_REGISTRATION_additional_ident_info(desc) (&(desc)[6]) + +/* data_stream_alignment_descriptor */ +#define DESC_DATA_STREAM_ALIGNMENT_alignment_type(desc) ((desc)[2]) + +/* target_background_grid_descriptor */ +#define DESC_TARGET_BACKGROUND_GRID_horizontal_size(desc) (GST_READ_UINT16_BE ((desc)+2) >> 2) +#define DESC_TARGET_BACKGROUND_GRID_vertical_size(desc) ((GST_READ_UINT32_BE ((desc)+2) & 0x0003fff0) >> 4) +#define DESC_TARGET_BACKGROUND_GRID_aspect_ratio_information(desc) ((desc)[5] & 0x0f) + +/* video_window_descriptor */ +#define DESC_VIDEO_WINDOW_horizontal_offset(desc) (GST_READ_UINT16_BE ((desc)+2) >> 2) +#define DESC_VIDEO_WINDOW_vertical_offset(desc) ((GST_READ_UINT32_BE ((desc)+2) & 0x0003fff0) >> 4) +#define DESC_VIDEO_WINDOW_window_priority(desc) ((desc)[5] & 0x0f) + +/* CA_descriptor */ +#define DESC_CA_system_ID(desc) (GST_READ_UINT16_BE ((desc)+2)) +#define DESC_CA_PID(desc) (GST_READ_UINT16_BE ((desc)+2) & 0x1fff) + +/* ISO_639_language_descriptor */ +#define DESC_ISO_639_LANGUAGE_codes_n(desc) ((desc[1]) >> 2) +#define DESC_ISO_639_LANGUAGE_language_code_nth(desc,i) (&(desc[2 + (4*i)])) +#define DESC_ISO_639_LANGUAGE_audio_type_nth(desc,i) ((desc)[5 + (4*i)]) + +/* system_clock_descriptor */ +#define DESC_SYSTEM_CLOCK_external_clock_reference_indicator(desc) (((desc)[2] & 0x80) == 0x80) +#define DESC_SYSTEM_CLOCK_clock_accuracy_integer(desc) ((desc)[2] & 0x3f) +#define DESC_SYSTEM_CLOCK_clock_accuracy_exponent(desc) (((desc)[3] & 0xe0) >> 5) + +/* multiplex_buffer_utilization_descriptor */ +#define DESC_MULTIPLEX_BUFFER_UTILISATION_bound_valid_flag(desc) (((desc)[2] & 0x80) == 0x80) +#define DESC_MULTIPLEX_BUFFER_UTILISATION_LTW_offset_lower_bound(desc) (GST_READ_UINT16_BE ((desc)+2) & 0x7fff) +#define DESC_MULTIPLEX_BUFFER_UTILISATION_LTW_offset_upper_bound(desc) (GST_READ_UINT16_BE ((desc)+4) & 0x7fff) + +/* copyright_descriptor */ +#define DESC_COPYRIGHT_copyright_identifier(desc) (GST_READ_UINT32_BE ((desc)+2)) +#define DESC_COPYRIGHT_additional_copyright_info_len(desc) ((desc)[1] - 4) +#define DESC_COPYRIGHT_additional_copyright_info(desc) (&(desc)[6]) + +/* maximum_bitrate_descriptor */ +#define DESC_MAXIMUM_BITRAT_maximum_bitrate(desc) (((((guint32)desc[2]) & 0x3f) << 16) | \ + GST_READ_UINT16_BE ((desc)+3)) + +/* private_data_indicator_descriptor */ +#define DESC_PRIVATE_DATA_INDICATOR_indicator(desc) (GST_READ_UINT32_BE(&desc[2])) + +/* smoothing_buffer_descriptor */ +#define DESC_SMOOTHING_BUFFER_sb_leak_rate(desc) (((((guint32)desc[2]) & 0x3f) << 16) | \ + GST_READ_UINT16_BE ((desc)+3)) +#define DESC_SMOOTHING_BUFFER_sb_size(desc) (((((guint32)desc[5]) & 0x3f) << 16) | \ + GST_READ_UINT16_BE ((desc)+6)) +/* STD_descriptor */ +#define DESC_STD_leak_valid_flag(desc) (((desc)[2] & 0x01) == 0x01) + +/* ibp_descriptor */ +#define DESC_IBP_closed_gop_flag(desc) (((desc)[2] & 0x80) == 0x80) +#define DESC_IBP_identical_gop_flag(desc) (((desc)[2] & 0x40) == 0x40) +#define DESC_IBP_max_gop_length(desc) (GST_READ_UINT16_BE ((desc)+6) & 0x3fff) + +/* time_code descriptor */ +#define DESC_TIMECODE_video_pid(desc) (GST_READ_UINT16_BE ((desc) + 2) & 0x1fff) + +/* Stream identifier descriptor */ +#define DESC_DVB_STREAM_IDENTIFIER_component_tag(desc) (desc[2]) + +/* DVB Network Name descriptor */ +#define DESC_DVB_NETWORK_NAME_length(desc) (GST_READ_UINT8((desc)+1)) +#define DESC_DVB_NETWORK_NAME_text(desc) (desc+2) + +typedef struct { + guint n_desc; + guint8 data_length; + guint8 *data; +} GstMPEGDescriptor; + +GstMPEGDescriptor* gst_mpeg_descriptor_parse (guint8 *data, guint size); +void gst_mpeg_descriptor_free (GstMPEGDescriptor *desc); + +guint gst_mpeg_descriptor_n_desc (GstMPEGDescriptor *desc); +guint8* gst_mpeg_descriptor_find (GstMPEGDescriptor *desc, gint tag); +guint8* gst_mpeg_descriptor_nth (GstMPEGDescriptor *desc, guint i); + +#endif /* __GST_MPEG_DESC_H__ */ diff --git a/gst/mpegdemux/gstmpegtsdemux.c b/gst/mpegdemux/gstmpegtsdemux.c new file mode 100644 index 0000000..cbd7cc3 --- /dev/null +++ b/gst/mpegdemux/gstmpegtsdemux.c @@ -0,0 +1,2630 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#ifdef USE_LIBOIL +#include +#endif + +#include "gstmpegdefs.h" +#include "gstmpegtsdemux.h" +#include "flutspatinfo.h" +#include "flutspmtinfo.h" + +#ifndef GST_CHECK_VERSION +#define GST_CHECK_VERSION(major,minor,micro) \ + (GST_VERSION_MAJOR > (major) || \ + (GST_VERSION_MAJOR == (major) && GST_VERSION_MINOR > (minor)) || \ + (GST_VERSION_MAJOR == (major) && GST_VERSION_MINOR == (minor) && \ + GST_VERSION_MICRO >= (micro))) +#endif + +#ifndef GST_BUFFER_IS_DISCONT +#define GST_BUFFER_IS_DISCONT(buffer) \ + (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) +#endif + +GST_DEBUG_CATEGORY_STATIC (gstflutsdemux_debug); +#define GST_CAT_DEFAULT (gstflutsdemux_debug) + +/* elementfactory information */ +#ifdef USE_LIBOIL +#define LONGNAME "MPEG Transport stream demuxer (liboil build)" +#else +#define LONGNAME "MPEG Transport stream demuxer" +#endif + +#ifndef __always_inline +#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) +#define __always_inline inline __attribute__((always_inline)) +#else +#define __always_inline inline +#endif +#endif + +#ifndef DISABLE_INLINE +#define FORCE_INLINE __always_inline +#else +#define FORCE_INLINE +#endif + +static GstElementDetails fluts_demux_details = { + LONGNAME, + "Codec/Demuxer", + "Demultiplexes MPEG2 Transport Streams", + "Wim Taymans " +}; + +/* MPEG2Demux signals and args */ +enum +{ + /* FILL ME */ + LAST_SIGNAL +}; + +#define DEFAULT_PROP_ES_PIDS "" +#define DEFAULT_PROP_CHECK_CRC TRUE +#define DEFAULT_PROP_PROGRAM_NUMBER -1 + +/* latency in mseconds */ +#define TS_LATENCY 700 + +enum +{ + PROP_0, + PROP_ES_PIDS, + PROP_CHECK_CRC, + PROP_PROGRAM_NUMBER, + PROP_PAT_INFO, + PROP_PMT_INFO, + PROP_M2TS +}; + +#define VIDEO_CAPS \ + GST_STATIC_CAPS (\ + "video/mpeg, " \ + "mpegversion = (int) { 1, 2, 4 }, " \ + "systemstream = (boolean) FALSE; " \ + "video/x-h264;" \ + "video/x-dirac" \ + ) + +#define AUDIO_CAPS \ + GST_STATIC_CAPS ( \ + "audio/mpeg, " \ + "mpegversion = (int) { 1, 4 };" \ + "audio/x-lpcm, " \ + "width = (int) { 16, 20, 24 }, " \ + "rate = (int) { 48000, 96000 }, " \ + "channels = (int) [ 1, 8 ], " \ + "dynamic_range = (int) [ 0, 255 ], " \ + "emphasis = (boolean) { FALSE, TRUE }, " \ + "mute = (boolean) { FALSE, TRUE }; " \ + "audio/x-ac3;" \ + "audio/x-dts" \ + ) + +static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("video/mpegts") + ); + +static GstStaticPadTemplate video_template = +GST_STATIC_PAD_TEMPLATE ("video_%04x", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + VIDEO_CAPS); + +static GstStaticPadTemplate audio_template = +GST_STATIC_PAD_TEMPLATE ("audio_%04x", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + AUDIO_CAPS); + +static GstStaticPadTemplate private_template = +GST_STATIC_PAD_TEMPLATE ("private_%04x", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS_ANY); + +static void gst_fluts_demux_base_init (GstFluTSDemuxClass * klass); +static void gst_fluts_demux_class_init (GstFluTSDemuxClass * klass); +static void gst_fluts_demux_init (GstFluTSDemux * demux); +static void gst_fluts_demux_finalize (GstFluTSDemux * demux); +static void gst_fluts_demux_reset (GstFluTSDemux * demux); + +//static void gst_fluts_demux_remove_pads (GstFluTSDemux * demux); +static void gst_fluts_demux_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_fluts_demux_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static gboolean gst_fluts_demux_is_PMT (GstFluTSDemux * demux, guint16 PID); + +static gboolean gst_fluts_demux_sink_event (GstPad * pad, GstEvent * event); +static GstFlowReturn gst_fluts_demux_chain (GstPad * pad, GstBuffer * buffer); +static gboolean gst_fluts_demux_sink_setcaps (GstPad * pad, GstCaps * caps); + +#ifdef HAVE_LATENCY +static GstClock *gst_fluts_demux_provide_clock (GstElement * element); +static gboolean gst_fluts_demux_src_pad_query (GstPad * pad, GstQuery * query); +#endif + +static GstStateChangeReturn gst_fluts_demux_change_state (GstElement * element, + GstStateChange transition); + +static FluTsPmtInfo *fluts_demux_build_pmt_info (GstFluTSDemux * demux, + guint16 pmt_pid); + +static GstElementClass *parent_class = NULL; + +/*static guint gst_fluts_demux_signals[LAST_SIGNAL] = { 0 };*/ + +GType +gst_fluts_demux_get_type (void) +{ + static GType fluts_demux_type = 0; + + if (G_UNLIKELY (!fluts_demux_type)) { + static const GTypeInfo fluts_demux_info = { + sizeof (GstFluTSDemuxClass), + (GBaseInitFunc) gst_fluts_demux_base_init, + NULL, + (GClassInitFunc) gst_fluts_demux_class_init, + NULL, + NULL, + sizeof (GstFluTSDemux), + 0, + (GInstanceInitFunc) gst_fluts_demux_init, + }; + + fluts_demux_type = + g_type_register_static (GST_TYPE_ELEMENT, "GstFluTSDemux", + &fluts_demux_info, 0); + + GST_DEBUG_CATEGORY_INIT (gstflutsdemux_debug, "flutsdemux", 0, + "MPEG program stream demultiplexer element"); + } + + return fluts_demux_type; +} + +static void +gst_fluts_demux_base_init (GstFluTSDemuxClass * klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (klass); + + klass->sink_template = gst_static_pad_template_get (&sink_template); + klass->video_template = gst_static_pad_template_get (&video_template); + klass->audio_template = gst_static_pad_template_get (&audio_template); + klass->private_template = gst_static_pad_template_get (&private_template); + + gst_element_class_add_pad_template (element_class, klass->video_template); + gst_element_class_add_pad_template (element_class, klass->audio_template); + gst_element_class_add_pad_template (element_class, klass->private_template); + gst_element_class_add_pad_template (element_class, klass->sink_template); + + gst_element_class_set_details (element_class, &fluts_demux_details); +} + +static void +gst_fluts_demux_class_init (GstFluTSDemuxClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *gstelement_class; + + parent_class = g_type_class_peek_parent (klass); + + gobject_class = (GObjectClass *) klass; + gstelement_class = (GstElementClass *) klass; + + gobject_class->finalize = (GObjectFinalizeFunc) gst_fluts_demux_finalize; + gobject_class->set_property = gst_fluts_demux_set_property; + gobject_class->get_property = gst_fluts_demux_get_property; + + g_object_class_install_property (gobject_class, PROP_ES_PIDS, + g_param_spec_string ("es-pids", + "Colon separated list of PIDs containing Elementary Streams", + "PIDs to treat as Elementary Streams in the absence of a PMT, " + "eg 0x10:0x11:0x20", DEFAULT_PROP_ES_PIDS, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, PROP_CHECK_CRC, + g_param_spec_boolean ("check-crc", "Check CRC", + "Enable CRC checking", DEFAULT_PROP_CHECK_CRC, G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, PROP_PROGRAM_NUMBER, + g_param_spec_int ("program-number", "Program Number", + "Program number to demux for (-1 to ignore)", -1, G_MAXINT, + DEFAULT_PROP_PROGRAM_NUMBER, 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", + FLUTS_TYPE_PAT_INFO, G_PARAM_READABLE), G_PARAM_READABLE)); + + g_object_class_install_property (gobject_class, PROP_PMT_INFO, + g_param_spec_object ("pmt-info", + "Information about the current program", + "GObject with properties containing information from the TS PMT " + "about the currently selected program and its streams", + FLUTS_TYPE_PMT_INFO, G_PARAM_READABLE)); + + g_object_class_install_property (gobject_class, PROP_M2TS, + g_param_spec_boolean ("m2ts_mode", "M2TS(192 bytes) Mode", + "Defines if the input is normal TS ie .ts(188 bytes)" + "or Blue-Ray Format ie .m2ts(192 bytes).", FALSE, G_PARAM_READWRITE)); + + gstelement_class->change_state = gst_fluts_demux_change_state; +#ifdef HAVE_LATENCY + gstelement_class->provide_clock = gst_fluts_demux_provide_clock; +#endif +} + +static void +gst_fluts_demux_init (GstFluTSDemux * demux) +{ + GstFluTSDemuxClass *klass = GST_FLUTS_DEMUX_GET_CLASS (demux); + + demux->streams = g_malloc0 (sizeof (GstFluTSStream *) * (FLUTS_MAX_PID + 1)); + demux->sinkpad = gst_pad_new_from_template (klass->sink_template, "sink"); + gst_pad_set_chain_function (demux->sinkpad, gst_fluts_demux_chain); + gst_pad_set_event_function (demux->sinkpad, gst_fluts_demux_sink_event); + gst_pad_set_setcaps_function (demux->sinkpad, gst_fluts_demux_sink_setcaps); + gst_element_add_pad (GST_ELEMENT (demux), demux->sinkpad); + + demux->elementary_pids = NULL; + demux->nb_elementary_pids = 0; + demux->check_crc = DEFAULT_PROP_CHECK_CRC; + demux->program_number = DEFAULT_PROP_PROGRAM_NUMBER; + demux->packetsize = FLUTS_NORMAL_TS_PACKETSIZE; + demux->m2ts_mode = FALSE; + +#ifdef USE_LIBOIL + oil_init (); +#endif +} + +static void +gst_fluts_demux_finalize (GstFluTSDemux * demux) +{ + gst_fluts_demux_reset (demux); + g_free (demux->streams); + + G_OBJECT_CLASS (parent_class)->finalize (G_OBJECT (demux)); +} + +static void +gst_fluts_demux_reset (GstFluTSDemux * demux) +{ + /* Clean up the streams and pads we allocated */ + gint i; + + for (i = 0; i < FLUTS_MAX_PID + 1; i++) { + GstFluTSStream *stream = demux->streams[i]; + + if (stream != NULL) { + if (stream->pad) + gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->pad); + if (stream->ES_info) + gst_mpeg_descriptor_free (stream->ES_info); + + if (stream->PMT.entries) + g_array_free (stream->PMT.entries, TRUE); + if (stream->PMT.program_info) + gst_mpeg_descriptor_free (stream->PMT.program_info); + + if (stream->PAT.entries) + g_array_free (stream->PAT.entries, TRUE); + + switch (stream->PID_type) { + case PID_TYPE_ELEMENTARY: + gst_pes_filter_uninit (&stream->filter); + break; + case PID_PROGRAM_ASSOCIATION_TABLE: + case PID_CONDITIONAL_ACCESS_TABLE: + case PID_TYPE_PROGRAM_MAP: + gst_section_filter_uninit (&stream->section_filter); + break; + } + + g_free (stream); + demux->streams[i] = NULL; + } + } + +#ifdef HAVE_LATENCY + if (demux->clock) { + g_object_unref (demux->clock); + demux->clock = NULL; + } +#endif +} + +#if 0 +static void +gst_fluts_demux_remove_pads (GstFluTSDemux * demux) +{ + /* remove pads we added in preparation for adding new ones */ + /* FIXME: instead of walking all streams, we should retain a list only + * of streams that have added pads */ + gint i; + + if (demux->need_no_more_pads) { + gst_element_no_more_pads ((GstElement *) demux); + demux->need_no_more_pads = FALSE; + } + + for (i = 0; i < FLUTS_MAX_PID + 1; i++) { + GstFluTSStream *stream = demux->streams[i]; + + if (stream != NULL) { + + if (GST_IS_PAD (stream->pad)) { + gst_pad_push_event (stream->pad, gst_event_new_eos ()); + gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->pad); + } + stream->pad = NULL; + + if (stream->PID_type == PID_TYPE_ELEMENTARY) + gst_pes_filter_drain (&stream->filter); + } + } +} +#endif + + +static guint32 crc_tab[256] = { + 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, + 0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, + 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7, + 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, + 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, + 0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, + 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef, + 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, + 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, + 0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, + 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0, + 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, + 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, + 0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, + 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, + 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, + 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, + 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, + 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050, + 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, + 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, + 0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, + 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1, + 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, + 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, + 0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, + 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9, + 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, + 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, + 0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, + 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71, + 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, + 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, + 0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, + 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, + 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, + 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, + 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, + 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676, + 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, + 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, + 0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, + 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 +}; + +/*This function fills the value of negotiated packetsize at sinkpad*/ +static gboolean +gst_fluts_demux_sink_setcaps (GstPad * pad, GstCaps * caps) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (gst_pad_get_parent (pad)); + gboolean ret = FALSE; + GstStructure *structure = NULL; + gint expected_packetsize = + (demux-> + m2ts_mode ? FLUTS_M2TS_TS_PACKETSIZE : FLUTS_NORMAL_TS_PACKETSIZE); + gint packetsize = expected_packetsize; + + structure = gst_caps_get_structure (caps, 0); + + GST_DEBUG_OBJECT (demux, "setcaps called with %" GST_PTR_FORMAT, caps); + + if (!gst_structure_get_int (structure, "packetsize", &packetsize)) { + GST_DEBUG_OBJECT (demux, "packetsize parameter not found in sink caps"); + } + + if (packetsize < expected_packetsize) { + GST_WARNING_OBJECT (demux, "packetsize = %" G_GINT32_FORMAT "is less then" + "expected packetsize of %d bytes", packetsize, expected_packetsize); + goto beach; + } + + /* here we my have a correct value for packet size */ + demux->packetsize = packetsize; + ret = TRUE; + +beach: + gst_object_unref (demux); + return ret; +} + +static FORCE_INLINE guint32 +gst_fluts_demux_calc_crc32 (guint8 * data, guint datalen) +{ + gint i; + guint32 crc = 0xffffffff; + + for (i = 0; i < datalen; i++) { + crc = (crc << 8) ^ crc_tab[((crc >> 24) ^ *data++) & 0xff]; + } + return crc; +} + +static FORCE_INLINE gboolean +gst_fluts_is_dirac_stream (GstFluTSStream * stream) +{ + gboolean is_dirac = FALSE; + + if (stream->stream_type != ST_VIDEO_DIRAC) + return FALSE; + + if (stream->ES_info != NULL) { + guint8 *dirac_desc; + + /* Check for a Registration Descriptor to confirm this is dirac */ + dirac_desc = gst_mpeg_descriptor_find (stream->ES_info, DESC_REGISTRATION); + if (dirac_desc != NULL && DESC_LENGTH (dirac_desc) >= 4) { + if (DESC_REGISTRATION_format_identifier (dirac_desc) == 0x64726163) { /* 'drac' in hex */ + is_dirac = TRUE; + } + } else { + /* Check for old mapping as originally specified too */ + dirac_desc = gst_mpeg_descriptor_find (stream->ES_info, + DESC_DIRAC_TC_PRIVATE); + if (dirac_desc != NULL && DESC_LENGTH (dirac_desc) == 0) + is_dirac = TRUE; + } + } + + return is_dirac; +} + +static FORCE_INLINE gboolean +gst_fluts_stream_is_video (GstFluTSStream * stream) +{ + switch (stream->stream_type) { + case ST_VIDEO_MPEG1: + case ST_VIDEO_MPEG2: + case ST_VIDEO_MPEG4: + case ST_VIDEO_H264: + return TRUE; + case ST_VIDEO_DIRAC: + return gst_fluts_is_dirac_stream (stream); + } + + return FALSE; +} + +static gboolean +gst_fluts_demux_fill_stream (GstFluTSStream * stream, guint8 id, + guint8 stream_type) +{ + GstPadTemplate *template; + gchar *name; + GstFluTSDemuxClass *klass; + GstFluTSDemux *demux; + GstCaps *caps; + + if (stream->stream_type && stream->stream_type != stream_type) + goto wrong_type; + + demux = stream->demux; + klass = GST_FLUTS_DEMUX_GET_CLASS (demux); + + name = NULL; + template = NULL; + caps = NULL; + + switch (stream_type) { + case ST_VIDEO_MPEG1: + case ST_VIDEO_MPEG2: + template = klass->video_template; + name = g_strdup_printf ("video_%04x", stream->PID); + caps = gst_caps_new_simple ("video/mpeg", + "mpegversion", G_TYPE_INT, stream_type == ST_VIDEO_MPEG1 ? 1 : 2, + "systemstream", G_TYPE_BOOLEAN, FALSE, NULL); + break; + case ST_AUDIO_MPEG1: + case ST_AUDIO_MPEG2: + template = klass->audio_template; + name = g_strdup_printf ("audio_%04x", stream->PID); + caps = gst_caps_new_simple ("audio/mpeg", + "mpegversion", G_TYPE_INT, 1, NULL); + break; + case ST_PRIVATE_DATA: + /* check if there is an AC3 descriptor associated with this stream + * from the PMT */ + if (gst_mpeg_descriptor_find (stream->ES_info, DESC_DVB_AC3)) { + template = klass->audio_template; + name = g_strdup_printf ("audio_%04x", stream->PID); + caps = gst_caps_new_simple ("audio/x-ac3", NULL); + } else if (gst_mpeg_descriptor_find (stream->ES_info, DESC_DVB_TELETEXT)) { + template = klass->private_template; + name = g_strdup_printf ("private_%04x", stream->PID); + caps = gst_caps_new_simple ("private/teletext", NULL); + } + break; + case ST_PRIVATE_SECTIONS: + case ST_MHEG: + case ST_DSMCC: + break; + case ST_AUDIO_AAC: + template = klass->audio_template; + name = g_strdup_printf ("audio_%04x", stream->PID); + caps = gst_caps_new_simple ("audio/mpeg", + "mpegversion", G_TYPE_INT, 4, NULL); + break; + case ST_VIDEO_MPEG4: + template = klass->video_template; + name = g_strdup_printf ("video_%04x", stream->PID); + caps = gst_caps_new_simple ("video/mpeg", + "mpegversion", G_TYPE_INT, 4, + "systemstream", G_TYPE_BOOLEAN, FALSE, NULL); + break; + case ST_VIDEO_H264: + template = klass->video_template; + name = g_strdup_printf ("video_%04x", stream->PID); + caps = gst_caps_new_simple ("video/x-h264", NULL); + break; + case ST_VIDEO_DIRAC: + if (gst_fluts_is_dirac_stream (stream)) { + template = klass->video_template; + name = g_strdup_printf ("video_%04x", stream->PID); + caps = gst_caps_new_simple ("video/x-dirac", NULL); + } + break; + case ST_PS_AUDIO_AC3: + template = klass->audio_template; + name = g_strdup_printf ("audio_%04x", stream->PID); + caps = gst_caps_new_simple ("audio/x-ac3", NULL); + break; + case ST_PS_AUDIO_DTS: + template = klass->audio_template; + name = g_strdup_printf ("audio_%04x", stream->PID); + caps = gst_caps_new_simple ("audio/x-dts", NULL); + break; + case ST_PS_AUDIO_LPCM: + template = klass->audio_template; + name = g_strdup_printf ("audio_%04x", stream->PID); + caps = gst_caps_new_simple ("audio/x-lpcm", NULL); + break; + case ST_PS_DVD_SUBPICTURE: + break; + default: + break; + } + if (name == NULL || template == NULL || caps == NULL) + return FALSE; + + stream->stream_type = stream_type; + stream->id = id; + stream->pad = gst_pad_new_from_template (template, name); + gst_pad_use_fixed_caps (stream->pad); + gst_pad_set_caps (stream->pad, caps); + gst_caps_unref (caps); +#ifdef HAVE_LATENCY + gst_pad_set_query_function (stream->pad, + GST_DEBUG_FUNCPTR (gst_fluts_demux_src_pad_query)); +#endif + g_free (name); + + return TRUE; + +wrong_type: + { + return FALSE; + } +} + +static FORCE_INLINE gboolean +fluts_is_elem_pid (GstFluTSDemux * demux, guint16 PID) +{ + int i; + + /* check if it's in our partial ts pid list */ + for (i = 0; i < demux->nb_elementary_pids; i++) { + if (demux->elementary_pids[i] == PID) { + return TRUE; + } + } + + return FALSE; +} + +static gboolean +gst_fluts_demux_send_new_segment (GstFluTSDemux * demux, + GstFluTSStream * stream, gint64 pts) +{ + GstFluTSStream *PCR_stream; + GstFluTSStream *PMT_stream; + GstClockTime time; + guint64 base_PCR; + + /* for the reference start time we need to consult the PCR_PID of the + * current PMT */ + if (demux->current_PMT == 0) + goto no_pmt; + + PMT_stream = demux->streams[demux->current_PMT]; + if (PMT_stream == NULL) + goto no_pmt_stream; + + PCR_stream = demux->streams[PMT_stream->PMT.PCR_PID]; + if (PCR_stream == NULL) + goto no_pcr_stream; + + if (PCR_stream->base_PCR == -1) { + GST_DEBUG_OBJECT (demux, "no base PCR, using last PCR %" G_GUINT64_FORMAT, + PCR_stream->last_PCR); + PCR_stream->base_PCR = PCR_stream->last_PCR; + } else { + GST_DEBUG_OBJECT (demux, "using base PCR %" G_GUINT64_FORMAT, + PCR_stream->base_PCR); + } + if (PCR_stream->last_PCR == -1) { + GST_DEBUG_OBJECT (demux, "no last PCR, using PTS %" G_GUINT64_FORMAT, pts); + PCR_stream->base_PCR = pts; + PCR_stream->last_PCR = pts; + } + base_PCR = PCR_stream->base_PCR; + + time = MPEGTIME_TO_GSTTIME (base_PCR); + + GST_DEBUG_OBJECT (demux, "segment PTS to (%" G_GUINT64_FORMAT ") time: %" + G_GUINT64_FORMAT, base_PCR, time); + +#ifdef HAVE_LATENCY + if (demux->clock && demux->clock_base == GST_CLOCK_TIME_NONE) { + demux->clock_base = gst_clock_get_time (demux->clock); + gst_clock_set_calibration (demux->clock, + gst_clock_get_internal_time (demux->clock), demux->clock_base, 1, 1); + } +#endif + + gst_pad_push_event (stream->pad, + gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, time, -1, 0)); + + return TRUE; + + /* ERRORS */ +no_pmt: + { + /* check if it's in our partial ts pid list */ + if (fluts_is_elem_pid (demux, stream->PID)) { + GST_DEBUG_OBJECT (demux, + "Elementary PID, using pts %" G_GUINT64_FORMAT, pts); + time = MPEGTIME_TO_GSTTIME (pts) + stream->base_time; + GST_DEBUG_OBJECT (demux, "segment PTS to (%" G_GUINT64_FORMAT ") time: %" + G_GUINT64_FORMAT, pts, time); + + gst_pad_push_event (stream->pad, + gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, time, -1, 0)); + return TRUE; + } + + } +no_pmt_stream: + { + GST_DEBUG_OBJECT (demux, "no PMT stream found"); + return FALSE; + } +no_pcr_stream: + { + GST_DEBUG_OBJECT (demux, "no PCR stream found"); + return FALSE; + } +} + +#ifndef GST_FLOW_IS_SUCCESS +#define GST_FLOW_IS_SUCCESS(ret) ((ret) >= GST_FLOW_OK) +#endif + +static GstFlowReturn +gst_fluts_demux_combine_flows (GstFluTSDemux * demux, GstFluTSStream * stream, + GstFlowReturn ret) +{ + gint i; + + /* store the value */ + stream->last_ret = ret; + + /* if it's success we can return the value right away */ + if (GST_FLOW_IS_SUCCESS (ret)) + goto done; + + /* any other error that is not-linked can be returned right + * away */ + if (ret != GST_FLOW_NOT_LINKED) + goto done; + + /* only return NOT_LINKED if all other pads returned NOT_LINKED */ + for (i = 0; i < FLUTS_MAX_PID + 1; i++) { + if (!(stream = demux->streams[i])) + continue; + + /* some other return value (must be SUCCESS but we can return + * other values as well) */ + ret = stream->last_ret; + if (ret != GST_FLOW_NOT_LINKED) + goto done; + } + /* if we get here, all other pads were unlinked and we return + * NOT_LINKED then */ +done: + return ret; +} + + +static GstFlowReturn +gst_fluts_demux_data_cb (GstPESFilter * filter, gboolean first, + GstBuffer * buffer, GstFluTSStream * stream) +{ + GstFluTSDemux *demux; + GstFlowReturn ret; + GstPad *srcpad; + gint64 pts; + GstClockTime time; + + demux = stream->demux; + srcpad = stream->pad; + + GST_LOG_OBJECT (demux, "got data on PID 0x%04x", stream->PID); + + if (first && filter->pts != -1) { + pts = filter->pts; + time = MPEGTIME_TO_GSTTIME (pts) + stream->base_time; + + if ((stream->last_time > 0 && stream->last_time < time && + time - stream->last_time > GST_SECOND * 60 * 10) + || (stream->last_time > time + && stream->last_time - time > GST_SECOND * 60 * 10)) { + /* check first to see if we're in middle of detecting a discont in PCR. + * if we are we're not sure what timestamp the buffer should have, best + * to drop. */ + if (stream->PMT_pid <= FLUTS_MAX_PID && demux->streams[stream->PMT_pid] && + demux->streams[demux->streams[stream->PMT_pid]->PMT.PCR_PID] && + demux->streams[demux->streams[stream->PMT_pid]->PMT.PCR_PID]-> + discont_PCR) { + GST_WARNING_OBJECT (demux, "middle of discont, dropping"); + goto bad_timestamp; + } + /* check for wraparounds */ + else if (stream->last_time > 0 && time < stream->last_time && + stream->last_time - time > MPEGTIME_TO_GSTTIME (G_MAXUINT32)) { + /* wrap around occurred */ + if (stream->base_time + MPEGTIME_TO_GSTTIME ((guint64) (1) << 33) + + MPEGTIME_TO_GSTTIME (pts) > + stream->last_time + GST_SECOND * 60 * 10) { + GST_DEBUG_OBJECT (demux, + "looks like we have a corrupt packet because its pts is a lot lower than" + " the previous pts but not a wraparound"); + goto bad_timestamp; + } + /* wraparound has occured but before we have detected in the pcr, + * so check we're actually getting pcr's...if we are, don't update + * the base time..just set the time and last_time correctly + */ + if (stream->PMT_pid <= FLUTS_MAX_PID && demux->streams[stream->PMT_pid] + && demux->streams[demux->streams[stream->PMT_pid]->PMT.PCR_PID] + && demux->streams[demux->streams[stream->PMT_pid]->PMT.PCR_PID]-> + last_PCR > 0) { + GST_DEBUG_OBJECT (demux, "timestamps wrapped before noticed in PCR"); + time = MPEGTIME_TO_GSTTIME (pts) + stream->base_time + + MPEGTIME_TO_GSTTIME ((guint64) (1) << 33); + stream->last_time = time; + } else { + stream->base_time = stream->base_time + + MPEGTIME_TO_GSTTIME ((guint64) (1) << 33); + time = MPEGTIME_TO_GSTTIME (pts) + stream->base_time; + GST_DEBUG_OBJECT (demux, + "timestamps wrapped around, compensating with new base time: %" + GST_TIME_FORMAT "last time: %" GST_TIME_FORMAT " time: %" + GST_TIME_FORMAT, GST_TIME_ARGS (stream->base_time), + GST_TIME_ARGS (stream->last_time), GST_TIME_ARGS (time)); + stream->last_time = time; + } + } else if (stream->last_time > 0 && time > stream->last_time && + time - stream->last_time > MPEGTIME_TO_GSTTIME (G_MAXUINT32) && + stream->base_time > 0) { + /* had a previous wrap around */ + if (time - MPEGTIME_TO_GSTTIME ((guint64) (1) << 33) + + GST_SECOND * 60 * 10 < stream->last_time) { + GST_DEBUG_OBJECT (demux, + "looks like we have a corrupt packet because its pts is a lot higher than" + " the previous pts but not because of a wraparound or pcr discont"); + goto bad_timestamp; + } + if (ABS ((time - MPEGTIME_TO_GSTTIME ((guint64) (1) << 33)) - + stream->last_time) < GST_SECOND) { + GST_DEBUG_OBJECT (demux, + "timestamps wrapped around earlier but we have an out of pts: %" + G_GUINT64_FORMAT ", as %" GST_TIME_FORMAT " translated to: %" + GST_TIME_FORMAT " and last_time of %" GST_TIME_FORMAT, pts, + GST_TIME_ARGS (time), + GST_TIME_ARGS (time - MPEGTIME_TO_GSTTIME ((guint64) (1) << 33)), + GST_TIME_ARGS (stream->last_time)); + time = time - MPEGTIME_TO_GSTTIME ((guint64) (1) << 33); + } else { + GST_DEBUG_OBJECT (demux, + "timestamp may have wrapped around recently but not sure and pts" + " is very different, dropping it timestamp of this packet: %" + GST_TIME_FORMAT " compared to last timestamp: %" GST_TIME_FORMAT, + GST_TIME_ARGS (time - + MPEGTIME_TO_GSTTIME ((guint64) (1) << (33))), + GST_TIME_ARGS (stream->last_time)); + goto bad_timestamp; + } + + } else { + /* we must have a corrupt packet */ + GST_WARNING_OBJECT (demux, "looks like we have a corrupt packet because" + " its timestamp is buggered timestamp: %" GST_TIME_FORMAT + " compared to" " last timestamp: %" GST_TIME_FORMAT, + GST_TIME_ARGS (time), GST_TIME_ARGS (stream->last_time)); + goto bad_timestamp; + } + } else { /* do not set last_time if a packet with pts from before wrap + around arrived after the wrap around occured */ + stream->last_time = time; + } + } else { + time = GST_CLOCK_TIME_NONE; + pts = -1; + } + + GST_LOG_OBJECT (demux, "setting PTS to (%" G_GUINT64_FORMAT ") time: %" + GST_TIME_FORMAT " on buffer 0x%x first buffer: %d base_time: %" + GST_TIME_FORMAT, pts, GST_TIME_ARGS (time), buffer, first, + GST_TIME_ARGS (stream->base_time)); + + GST_BUFFER_TIMESTAMP (buffer) = time; + + /* check if we have a pad already */ + if (srcpad == NULL) { + /* fill in the last bits of the stream */ + /* if no stream type, then assume it based on the PES start code, + * needed for partial ts streams without PMT */ + if (G_UNLIKELY (stream->flags & FLUTS_STREAM_FLAG_STREAM_TYPE_UNKNOWN)) { + if ((filter->start_code & 0xFFFFFFF0) == PACKET_VIDEO_START_CODE) { + /* it is mpeg2 video */ + stream->stream_type = ST_VIDEO_MPEG2; + stream->flags &= ~FLUTS_STREAM_FLAG_STREAM_TYPE_UNKNOWN; + stream->flags |= FLUTS_STREAM_FLAG_IS_VIDEO; + GST_DEBUG_OBJECT (demux, "Found stream 0x%04x without PMT with video " + "start_code. Treating as video", stream->PID); + } else if ((filter->start_code & 0xFFFFFFE0) == PACKET_AUDIO_START_CODE) { + /* it is mpeg audio */ + stream->stream_type = ST_AUDIO_MPEG2; + stream->flags &= ~FLUTS_STREAM_FLAG_STREAM_TYPE_UNKNOWN; + GST_DEBUG_OBJECT (demux, "Found stream 0x%04x without PMT with audio " + "start_code. Treating as audio", stream->PID); + } else { + GST_LOG_OBJECT (demux, "Stream start code on pid 0x%04x is: 0x%x", + stream->PID, filter->start_code); + } + } + if (!gst_fluts_demux_fill_stream (stream, filter->id, stream->stream_type)) + goto unknown_type; + + GST_DEBUG_OBJECT (demux, + "New stream 0x%04x of type %d with caps %" GST_PTR_FORMAT, stream->PID, + stream->stream_type, GST_PAD_CAPS (stream->pad)); + + srcpad = stream->pad; + + /* activate and add */ + gst_pad_set_active (srcpad, TRUE); + gst_element_add_pad (GST_ELEMENT_CAST (demux), srcpad); + demux->need_no_more_pads = TRUE; + + /* send new_segment */ + gst_fluts_demux_send_new_segment (demux, stream, pts); + } + + GST_DEBUG_OBJECT (demux, "pushing buffer"); + gst_buffer_set_caps (buffer, GST_PAD_CAPS (srcpad)); + ret = gst_pad_push (srcpad, buffer); + ret = gst_fluts_demux_combine_flows (demux, stream, ret); + + return ret; + + /* ERROR */ +unknown_type: + { + GST_DEBUG_OBJECT (demux, "got unknown stream id 0x%02x, type 0x%02x", + filter->id, filter->type); + gst_buffer_unref (buffer); + return gst_fluts_demux_combine_flows (demux, stream, GST_FLOW_NOT_LINKED); + } +bad_timestamp: + { + gst_buffer_unref (buffer); + return gst_fluts_demux_combine_flows (demux, stream, GST_FLOW_OK); + } + +} + +static void +gst_fluts_demux_resync_cb (GstPESFilter * filter, GstFluTSStream * stream) +{ + /* does nothing for now */ +} + +static gboolean +gst_fluts_demux_is_reserved_PID (GstFluTSDemux * demux, guint16 PID) +{ + return (PID >= PID_RESERVED_FIRST) && (PID < PID_RESERVED_LAST); +} + +/* This function assumes that provided PID never will be greater than + * FLUTS_MAX_PID (13 bits), this is currently guaranteed as everywhere in + * the code recovered PID at maximum is 13 bits long. + */ +static FORCE_INLINE GstFluTSStream * +gst_fluts_demux_get_stream_for_PID (GstFluTSDemux * demux, guint16 PID) +{ + GstFluTSStream *stream = NULL; + + stream = demux->streams[PID]; + + if (G_UNLIKELY (stream == NULL)) { + stream = g_new0 (GstFluTSStream, 1); + + stream->demux = demux; + stream->PID = PID; + stream->pad = NULL; + stream->base_PCR = -1; + stream->last_PCR = -1; + stream->last_PCR_difference = -1; + stream->PMT.version_number = -1; + stream->PAT.version_number = -1; + stream->PMT_pid = FLUTS_MAX_PID + 1; + stream->flags |= FLUTS_STREAM_FLAG_STREAM_TYPE_UNKNOWN; + + switch (PID) { + /* check for fixed mapping */ + case PID_PROGRAM_ASSOCIATION_TABLE: + stream->PID_type = PID_TYPE_PROGRAM_ASSOCIATION; + /* initialise section filter */ + gst_section_filter_init (&stream->section_filter); + break; + case PID_CONDITIONAL_ACCESS_TABLE: + stream->PID_type = PID_TYPE_CONDITIONAL_ACCESS; + /* initialise section filter */ + gst_section_filter_init (&stream->section_filter); + break; + case PID_NULL_PACKET: + stream->PID_type = PID_TYPE_NULL_PACKET; + break; + default: + /* mark reserved PIDs */ + if (gst_fluts_demux_is_reserved_PID (demux, PID)) { + stream->PID_type = PID_TYPE_RESERVED; + } else { + /* check if PMT found in PAT */ + if (gst_fluts_demux_is_PMT (demux, PID)) { + stream->PID_type = PID_TYPE_PROGRAM_MAP; + /* initialise section filter */ + gst_section_filter_init (&stream->section_filter); + } else + stream->PID_type = PID_TYPE_UNKNOWN; + } + break; + } + GST_DEBUG_OBJECT (demux, "creating stream %p for PID 0x%04x, PID_type %d", + stream, PID, stream->PID_type); + + demux->streams[PID] = stream; + } + + return stream; +} + +/* + * CA_section() { + * table_id 8 uimsbf == 0x01 + * section_syntax_indicator 1 bslbf == 1 + * '0' 1 bslbf == 0 + * reserved 2 bslbf + * section_length 12 uimsbf == 00xxxxx... + * reserved 18 bslbf + * version_number 5 uimsbf + * current_next_indicator 1 bslbf + * section_number 8 uimsbf + * last_section_number 8 uimsbf + * for (i=0; idemux; + + GST_DEBUG_OBJECT (demux, "parsing CA section"); + return TRUE; +} + +static void +gst_fluts_activate_pmt (GstFluTSDemux * demux, GstFluTSStream * stream) +{ + GST_DEBUG_OBJECT (demux, "activating PMT 0x%08x", stream->PID); + + /* gst_fluts_demux_remove_pads (demux); */ + + demux->current_PMT = stream->PID; + + /* PMT has been updated, signal the change */ + if (demux->current_PMT == stream->PID) + g_object_notify ((GObject *) (demux), "pmt-info"); +} + +/* + * TS_program_map_section() { + * table_id 8 uimsbf == 0x02 + * section_syntax_indicator 1 bslbf == 1 + * '0' 1 bslbf == 0 + * reserved 2 bslbf + * section_length 12 uimsbf == 00xxxxx... + * program_number 16 uimsbf + * reserved 2 bslbf + * version_number 5 uimsbf + * current_next_indicator 1 bslbf + * section_number 8 uimsbf + * last_section_number 8 uimsbf + * reserved 3 bslbf + * PCR_PID 13 uimsbf + * reserved 4 bslbf + * program_info_length 12 uimsbf == 00xxxxx... + * for (i=0; idemux; + + if (*data++ != 0x02) + goto wrong_id; + if ((data[0] & 0xc0) != 0x80) + goto wrong_sync; + if ((data[0] & 0x0c) != 0x00) + goto wrong_seclen; + + data += 2; + + if (demux->check_crc) + if (gst_fluts_demux_calc_crc32 (data - 3, datalen) != 0) + goto wrong_crc; + + GST_DEBUG_OBJECT (demux, "PMT section_length: %d", datalen - 3); + + PMT = &stream->PMT; + + /* check if version number changed */ + version_number = (data[2] & 0x3e) >> 1; + GST_DEBUG_OBJECT (demux, "PMT version_number: %d", version_number); + + current_next_indicator = (data[2] & 0x01); + GST_DEBUG_OBJECT (demux, "PMT current_next_indicator %d", + current_next_indicator); + if (current_next_indicator == 0) + goto not_yet_applicable; + program_number = GST_READ_UINT16_BE (data); + + if (demux->program_number != -1 && demux->program_number != program_number) { + goto wrong_program_number; + } + if (demux->program_number == -1) { + GST_INFO_OBJECT (demux, "No program number set, so using first parsed PMT" + "'s program number: %d", program_number); + demux->program_number = program_number; + } + + if (version_number == PMT->version_number) + goto same_version; + + PMT->version_number = version_number; + PMT->current_next_indicator = current_next_indicator; + + stream->PMT.program_number = program_number; + data += 3; + GST_DEBUG_OBJECT (demux, "PMT program_number: %d", PMT->program_number); + + PMT->section_number = *data++; + GST_DEBUG_OBJECT (demux, "PMT section_number: %d", PMT->section_number); + + PMT->last_section_number = *data++; + GST_DEBUG_OBJECT (demux, "PMT last_section_number: %d", + PMT->last_section_number); + + PMT->PCR_PID = GST_READ_UINT16_BE (data); + PMT->PCR_PID &= 0x1fff; + data += 2; + GST_DEBUG_OBJECT (demux, "PMT PCR_PID: 0x%04x", PMT->PCR_PID); + /* create or get stream, not much we can say about it except that when we get + * a data stream and we need a PCR, we can use the stream to get/store the + * base_PCR. */ + gst_fluts_demux_get_stream_for_PID (demux, PMT->PCR_PID); + + if ((data[0] & 0x0c) != 0x00) + goto wrong_pilen; + + PMT->program_info_length = GST_READ_UINT16_BE (data); + PMT->program_info_length &= 0x0fff; + /* FIXME: validate value of program_info_length */ + data += 2; + + /* FIXME: validate value of program_info_length, before using */ + + /* parse descriptor */ + if (G_UNLIKELY (PMT->program_info)) + gst_mpeg_descriptor_free (PMT->program_info); + PMT->program_info = + gst_mpeg_descriptor_parse (data, PMT->program_info_length); + + /* skip descriptor */ + data += PMT->program_info_length; + GST_DEBUG_OBJECT (demux, "PMT program_info_length: %d", + PMT->program_info_length); + + entries = datalen - 3 - PMT->program_info_length - 9 - 4; + + if (G_UNLIKELY (PMT->entries)) + g_array_free (PMT->entries, TRUE); + PMT->entries = g_array_new (FALSE, TRUE, sizeof (GstFluTSPMTEntry)); + + while (entries > 0) { + GstFluTSPMTEntry entry; + GstFluTSStream *ES_stream; + guint8 stream_type; + guint16 ES_info_length; + + stream_type = *data++; + + entry.PID = GST_READ_UINT16_BE (data); + entry.PID &= 0x1fff; + data += 2; + + if ((data[0] & 0x0c) != 0x00) + goto wrong_esilen; + + ES_info_length = GST_READ_UINT16_BE (data); + ES_info_length &= 0x0fff; + data += 2; + + /* get/create elementary stream */ + ES_stream = gst_fluts_demux_get_stream_for_PID (demux, entry.PID); + /* check if PID unknown */ + if (ES_stream->PID_type == PID_TYPE_UNKNOWN) { + /* set as elementary */ + ES_stream->PID_type = PID_TYPE_ELEMENTARY; + /* set stream type */ + ES_stream->stream_type = stream_type; + ES_stream->flags &= ~FLUTS_STREAM_FLAG_STREAM_TYPE_UNKNOWN; + + /* init base and last time */ + ES_stream->base_time = 0; + ES_stream->last_time = 0; + + /* parse descriptor */ + ES_stream->ES_info = gst_mpeg_descriptor_parse (data, ES_info_length); + + if (stream_type == ST_PRIVATE_SECTIONS) { + /* not really an ES, so use section filter not pes filter */ + /* initialise section filter */ + gst_section_filter_init (&ES_stream->section_filter); + ES_stream->PID_type = PID_TYPE_PRIVATE_SECTION; + ES_stream->pad = gst_pad_new_from_static_template (&private_template, + g_strdup_printf ("private_%04x", entry.PID)); + gst_pad_set_active (ES_stream->pad, TRUE); + gst_element_add_pad (GST_ELEMENT_CAST (demux), ES_stream->pad); + } else { + /* Recognise video streams based on stream_type */ + if (gst_fluts_stream_is_video (ES_stream)) + ES_stream->flags |= FLUTS_STREAM_FLAG_IS_VIDEO; + + /* set adaptor */ + gst_pes_filter_init (&ES_stream->filter, NULL, NULL); + gst_pes_filter_set_callbacks (&ES_stream->filter, + (GstPESFilterData) gst_fluts_demux_data_cb, + (GstPESFilterResync) gst_fluts_demux_resync_cb, ES_stream); + if (ES_stream->flags & FLUTS_STREAM_FLAG_IS_VIDEO) + ES_stream->filter.allow_unbounded = TRUE; + ES_stream->PMT_pid = stream->PID; + } + } + /* skip descriptor */ + data += ES_info_length; + GST_DEBUG_OBJECT (demux, + " PMT stream_type: %02x, PID: 0x%04x (ES_info_len %d)", stream_type, + entry.PID, ES_info_length); + + g_array_append_val (PMT->entries, entry); + + entries -= 5 + ES_info_length; + } + CRC = GST_READ_UINT32_BE (data); + GST_DEBUG_OBJECT (demux, "PMT CRC: 0x%08x", CRC); + + if (demux->program_number == -1) { + /* No program specified, take the first PMT */ + if (demux->current_PMT == 0 || demux->current_PMT == stream->PID) + gst_fluts_activate_pmt (demux, stream); + } else { + /* Program specified, activate this if it matches */ + if (demux->program_number == PMT->program_number) + gst_fluts_activate_pmt (demux, stream); + } + + return TRUE; + + /* ERRORS */ +wrong_crc: + { + GST_DEBUG_OBJECT (demux, "wrong crc"); + return FALSE; + } +same_version: + { + GST_DEBUG_OBJECT (demux, "same version as existing PMT"); + return TRUE; + } +wrong_program_number: + { + GST_DEBUG_OBJECT (demux, "PMT is for program number we don't care about"); + return TRUE; + } + +not_yet_applicable: + { + GST_DEBUG_OBJECT (demux, "Ignoring PMT with current_next_indicator = 0"); + return TRUE; + } +wrong_id: + { + GST_DEBUG_OBJECT (demux, "expected table_id == 0, got 0x%02x", data[0]); + return FALSE; + } +wrong_sync: + { + GST_DEBUG_OBJECT (demux, "expected sync 10, got %02x", data[0]); + return FALSE; + } +wrong_seclen: + { + GST_DEBUG_OBJECT (demux, + "first two bits of section length must be 0, got %02x", data[0]); + return FALSE; + } +wrong_pilen: + { + GST_DEBUG_OBJECT (demux, + "first two bits of program_info length must be 0, got %02x", data[0]); + return FALSE; + } +wrong_esilen: + { + GST_DEBUG_OBJECT (demux, + "first two bits of ES_info length must be 0, got %02x", data[0]); + g_array_free (stream->PMT.entries, TRUE); + stream->PMT.entries = NULL; + gst_mpeg_descriptor_free (stream->PMT.program_info); + stream->PMT.program_info = NULL; + return FALSE; + } +} + +/* + * private_section() { + * table_id 8 uimsbf + * section_syntax_indicator 1 bslbf + * private_indicator 1 bslbf + * reserved 2 bslbf + * private_section_length 12 uimsbf + * if (section_syntax_indicator == '0') { + * for ( i=0;idemux; + + if (demux->check_crc) + if (gst_fluts_demux_calc_crc32 (data, datalen) != 0) + goto wrong_crc; + + /* just dump this down the pad */ + if (gst_pad_alloc_buffer (stream->pad, 0, datalen, NULL, &buffer) == + GST_FLOW_OK) { +#ifdef USE_LIBOIL + oil_memcpy (buffer->data, data, datalen); +#else + memcpy (buffer->data, data, datalen); +#endif + gst_pad_push (stream->pad, buffer); + } + + GST_DEBUG_OBJECT (demux, "parsing private section"); + return TRUE; + +wrong_crc: + { + GST_DEBUG_OBJECT (demux, "wrong crc"); + return FALSE; + } +} + +/* + * adaptation_field() { + * adaptation_field_length 8 uimsbf + * if(adaptation_field_length >0) { + * discontinuity_indicator 1 bslbf + * random_access_indicator 1 bslbf + * elementary_stream_priority_indicator 1 bslbf + * PCR_flag 1 bslbf + * OPCR_flag 1 bslbf + * splicing_point_flag 1 bslbf + * transport_private_data_flag 1 bslbf + * adaptation_field_extension_flag 1 bslbf + * if(PCR_flag == '1') { + * program_clock_reference_base 33 uimsbf + * reserved 6 bslbf + * program_clock_reference_extension 9 uimsbf + * } + * if(OPCR_flag == '1') { + * original_program_clock_reference_base 33 uimsbf + * reserved 6 bslbf + * original_program_clock_reference_extension 9 uimsbf + * } + * if (splicing_point_flag == '1') { + * splice_countdown 8 tcimsbf + * } + * if(transport_private_data_flag == '1') { + * transport_private_data_length 8 uimsbf + * for (i=0; idemux; + + data_end = ((guint8 *) data) + data_len; + + length = *data++; + if (G_UNLIKELY (length > data_len)) + goto wrong_length; + + GST_DEBUG_OBJECT (demux, "parsing adaptation field, length %d", length); + + if (length > 0) { + guint8 flags = *data++; + + GST_DEBUG_OBJECT (demux, "flags 0x%02x", flags); + /* discontinuity flag */ + if (flags & 0x80) { + GST_DEBUG_OBJECT (demux, "discontinuity flag set"); + } + /* PCR_flag */ + if (flags & 0x10) { + guint32 pcr1; + guint16 pcr2; + guint64 pcr, pcr_ext; + gboolean valid_pcr = TRUE; + + pcr1 = GST_READ_UINT32_BE (data); + pcr2 = GST_READ_UINT16_BE (data + 4); + pcr = ((guint64) pcr1) << 1; + pcr |= (pcr2 & 0x8000) >> 15; + pcr_ext = (pcr2 & 0x01ff); + if (pcr_ext) + pcr = (pcr * 300 + pcr_ext % 300) / 300; + GST_DEBUG_OBJECT (demux, "have PCR %" G_GUINT64_FORMAT " on PID 0x%04x " + "and last pcr is %" G_GUINT64_FORMAT, + pcr, stream->PID, stream->last_PCR); + /* pcr has been converted into units of 90Khz ticks + * so assume discont if last pcr was > 900000 (10 second) lower */ + if (stream->last_PCR != -1 && + (pcr - stream->last_PCR > 900000 || pcr < stream->last_PCR)) { + GstClockTimeDiff base_time_difference; + + GST_DEBUG_OBJECT (demux, + "looks like we have a discont, this pcr should really be approx: %" + G_GUINT64_FORMAT, stream->last_PCR + stream->last_PCR_difference); + if (stream->discont_PCR == FALSE) { + if (pcr > stream->last_PCR) { + base_time_difference = -MPEGTIME_TO_GSTTIME ((pcr - + (stream->last_PCR + stream->last_PCR_difference))); + } else { + base_time_difference = MPEGTIME_TO_GSTTIME ((stream->last_PCR + + stream->last_PCR_difference) - pcr); + } + stream->discont_PCR = TRUE; + stream->discont_difference = base_time_difference; + valid_pcr = FALSE; + } else { + GstClockTimeDiff base_time_difference; + + /* need to update all pmt streams in case this pcr is pcr + * for multiple programs */ + int j; + gboolean *pmts_checked = (gboolean *) & demux->pmts_checked; + memset (pmts_checked, 0, sizeof (gboolean) * (FLUTS_MAX_PID + 1)); + + for (j = 0; j < FLUTS_MAX_PID + 1; j++) { + if (demux->streams[j] && demux->streams[j]->PMT_pid) { + if (!pmts_checked[demux->streams[j]->PMT_pid]) { + /* check if this is correct pcr for pmt */ + if (demux->streams[demux->streams[j]->PMT_pid] && + stream->PID == + demux->streams[demux->streams[j]->PMT_pid]->PMT.PCR_PID) { + /* checking the pcr discont is similar this second time + * if similar, update the es pids + * if not, assume it's a false discont due to corruption + * or other */ + if (pcr > stream->last_PCR) { + base_time_difference = -MPEGTIME_TO_GSTTIME ((pcr - + (stream->last_PCR + stream->last_PCR_difference))); + } else { + base_time_difference = + MPEGTIME_TO_GSTTIME ((stream->last_PCR + + stream->last_PCR_difference) - pcr); + } + if ((base_time_difference - stream->discont_difference > 0 && + base_time_difference - stream->discont_difference < + GST_SECOND * 10) || + (stream->discont_difference - base_time_difference > 0 && + stream->discont_difference - base_time_difference < + GST_SECOND * 10)) { + pmt_stream = demux->streams[demux->streams[j]->PMT_pid]; + GST_DEBUG_OBJECT (demux, "Updating base_time on all es " + "pids belonging to PMT 0x%02x", stream->PMT_pid); + for (i = 0; i <= pmt_stream->PMT.entries->len; i++) { + GstFluTSPMTEntry *cur_entry = + &g_array_index (pmt_stream->PMT.entries, + GstFluTSPMTEntry, i); + GST_DEBUG_OBJECT (demux, + "Updating base time on " "pid 0x%02x by %" + G_GINT64_FORMAT, cur_entry->PID, + stream->discont_difference); + if (cur_entry->PID <= FLUTS_MAX_PID + && demux->streams[cur_entry->PID]) { + demux->streams[cur_entry->PID]->base_time += + stream->discont_difference; + } + } + } else { + GST_DEBUG_OBJECT (demux, "last PCR discont looked to be " + "bogus: previous discont difference %" G_GINT64_FORMAT + " now %" G_GINT64_FORMAT, stream->discont_difference, + base_time_difference); + valid_pcr = FALSE; + } + } + } + pmts_checked[demux->streams[j]->PMT_pid] = TRUE; + } + } + + stream->discont_PCR = FALSE; + stream->discont_difference = 0; + } + } else if (stream->last_PCR != -1) { + if (stream->discont_PCR) { + GST_DEBUG_OBJECT (demux, "last PCR discont looked to be bogus"); + stream->discont_PCR = FALSE; + stream->discont_difference = 0; + } + stream->last_PCR_difference = pcr - stream->last_PCR; + } + GST_DEBUG_OBJECT (demux, + "valid pcr: %d last PCR difference: %" G_GUINT64_FORMAT, valid_pcr, + stream->last_PCR_difference); + if (valid_pcr) { + + stream->last_PCR = pcr; + +#ifdef HAVE_LATENCY + if (demux->clock && demux->clock_base != GST_CLOCK_TIME_NONE) { + gdouble r_squared; + GstFluTSStream *PMT_stream; + + /* for the reference start time we need to consult the PCR_PID of the + * current PMT */ + PMT_stream = demux->streams[demux->current_PMT]; + if (PMT_stream->PMT.PCR_PID == stream->PID) { + GST_LOG_OBJECT (demux, + "internal %" GST_TIME_FORMAT " observation %" GST_TIME_FORMAT + " pcr: %" G_GUINT64_FORMAT " base_pcr: %" G_GUINT64_FORMAT + "pid: %d", + GST_TIME_ARGS (gst_clock_get_internal_time (demux->clock)), + GST_TIME_ARGS (MPEGTIME_TO_GSTTIME (pcr) - + MPEGTIME_TO_GSTTIME (stream->base_PCR) + stream->base_time + + demux->clock_base), pcr, stream->base_PCR, stream->PID); + gst_clock_add_observation (demux->clock, + gst_clock_get_internal_time (demux->clock), + demux->clock_base + stream->base_time + + MPEGTIME_TO_GSTTIME (pcr) - + MPEGTIME_TO_GSTTIME (stream->base_PCR), &r_squared); + } + } +#endif + } + data += 6; + } + /* OPCR_flag */ + if (flags & 0x08) { + guint32 opcr1; + guint16 opcr2; + guint64 opcr, opcr_ext; + + opcr1 = GST_READ_UINT32_BE (data); + opcr2 = GST_READ_UINT16_BE (data + 4); + opcr = ((guint64) opcr1) << 1; + opcr |= (opcr2 & 0x8000) >> 15; + opcr_ext = (opcr2 & 0x01ff); + if (opcr_ext) + opcr = (opcr * 300 + opcr_ext % 300) / 300; + GST_DEBUG_OBJECT (demux, "have OPCR %" G_GUINT64_FORMAT " on PID 0x%04x", + opcr, stream->PID); + stream->last_OPCR = opcr; + data += 6; + } + /* splicing_point_flag */ + if (flags & 0x04) { + guint8 splice_countdown; + + splice_countdown = *data++; + GST_DEBUG_OBJECT (demux, "have splicing point, countdown %d", + splice_countdown); + } + /* transport_private_data_flag */ + if (flags & 0x02) { + guint8 plength = *data++; + + if (data + plength > data_end) + goto private_data_too_large; + + GST_DEBUG_OBJECT (demux, "have private data, length: %d", plength); + data += plength; + } + /* adaptation_field_extension_flag */ + if (flags & 0x01) { + GST_DEBUG_OBJECT (demux, "have field extension"); + } + } + + *consumed = length + 1; + return TRUE; + + /* ERRORS */ +wrong_length: + { + GST_DEBUG_OBJECT (demux, "length %d > %d", length, data_len); + return FALSE; + } +private_data_too_large: + { + GST_DEBUG_OBJECT (demux, "have too large a private data length"); + return FALSE; + } +} + +/* + * program_association_section() { + * table_id 8 uimsbf == 0x00 + * section_syntax_indicator 1 bslbf == 1 + * '0' 1 bslbf == 0 + * reserved 2 bslbf + * section_length 12 uimsbf == 00xxxxx... + * transport_stream_id 16 uimsbf + * reserved 2 bslbf + * version_number 5 uimsbf + * current_next_indicator 1 bslbf + * section_number 8 uimsbf + * last_section_number 8 uimsbf + * for (i=0; idemux; + + if (datalen < 8) + return FALSE; + + if (*data++ != 0x00) + goto wrong_id; + if ((data[0] & 0xc0) != 0x80) + goto wrong_sync; + if ((data[0] & 0x0c) != 0x00) + goto wrong_seclen; + + data += 2; + GST_DEBUG_OBJECT (demux, "PAT section_length: %d", datalen - 3); + + if (demux->check_crc) + if (gst_fluts_demux_calc_crc32 (data - 3, datalen) != 0) + goto wrong_crc; + + PAT = &stream->PAT; + + version_number = (data[2] & 0x3e) >> 1; + GST_DEBUG_OBJECT (demux, "PAT version_number: %d", version_number); + if (version_number == PAT->version_number) + goto same_version; + + current_next_indicator = (data[2] & 0x01); + GST_DEBUG_OBJECT (demux, "PAT current_next_indicator %d", + current_next_indicator); + if (current_next_indicator == 0) + goto not_yet_applicable; + + PAT->version_number = version_number; + PAT->current_next_indicator = current_next_indicator; + + PAT->transport_stream_id = GST_READ_UINT16_BE (data); + data += 3; + GST_DEBUG_OBJECT (demux, "PAT stream_id: %d", PAT->transport_stream_id); + + PAT->section_number = *data++; + PAT->last_section_number = *data++; + + GST_DEBUG_OBJECT (demux, "PAT current_next_indicator: %d", + PAT->current_next_indicator); + GST_DEBUG_OBJECT (demux, "PAT section_number: %d", PAT->section_number); + GST_DEBUG_OBJECT (demux, "PAT last_section_number: %d", + PAT->last_section_number); + + /* 5 bytes after section length and a 4 bytes CRC, + * the rest is 4 byte entries */ + entries = (datalen - 3 - 9) / 4; + + if (PAT->entries) + g_array_free (PAT->entries, TRUE); + PAT->entries = + g_array_sized_new (FALSE, TRUE, sizeof (GstFluTSPATEntry), entries); + + while (entries--) { + GstFluTSPATEntry entry; + GstFluTSStream *PMT_stream; + + entry.program_number = GST_READ_UINT16_BE (data); + data += 2; + entry.PID = GST_READ_UINT16_BE (data); + entry.PID &= 0x1fff; + data += 2; + + /* get/create stream for PMT */ + PMT_stream = gst_fluts_demux_get_stream_for_PID (demux, entry.PID); + if (PMT_stream->PID_type != PID_TYPE_PROGRAM_MAP) { + /* set as program map */ + PMT_stream->PID_type = PID_TYPE_PROGRAM_MAP; + /* initialise section filter */ + gst_section_filter_init (&PMT_stream->section_filter); + } + + g_array_append_val (PAT->entries, entry); + + GST_DEBUG_OBJECT (demux, " PAT program: %d, PID 0x%04x", + entry.program_number, entry.PID); + } + CRC = GST_READ_UINT32_BE (data); + GST_DEBUG_OBJECT (demux, "PAT CRC: 0x%08x", CRC); + + /* PAT has been updated, signal the change */ + g_object_notify ((GObject *) (demux), "pat-info"); + + return TRUE; + + /* ERRORS */ +wrong_crc: + { + GST_DEBUG_OBJECT (demux, "wrong crc"); + return FALSE; + } +same_version: + { + GST_DEBUG_OBJECT (demux, "same version as existing PAT"); + return TRUE; + } +not_yet_applicable: + { + GST_DEBUG_OBJECT (demux, "Ignoring PAT with current_next_indicator = 0"); + return TRUE; + } +wrong_id: + { + GST_DEBUG_OBJECT (demux, "expected table_id == 0, got %02x", data[0]); + return FALSE; + } +wrong_sync: + { + GST_DEBUG_OBJECT (demux, "expected sync 10, got %02x", data[0]); + return FALSE; + } +wrong_seclen: + { + GST_DEBUG_OBJECT (demux, + "first two bits of section length must be 0, got %02x", data[0]); + return FALSE; + } +} + +static gboolean +gst_fluts_demux_is_PMT (GstFluTSDemux * demux, guint16 PID) +{ + GstFluTSStream *stream; + GstFluTSPAT *PAT; + gint i; + + /* get the PAT */ + stream = demux->streams[PID_PROGRAM_ASSOCIATION_TABLE]; + if (stream == NULL || stream->PAT.entries == NULL) + return FALSE; + + PAT = &stream->PAT; + + for (i = 0; i < PAT->entries->len; i++) { + GstFluTSPATEntry *entry; + + entry = &g_array_index (PAT->entries, GstFluTSPATEntry, i); + if (!entry) + continue; + + if (entry->PID == PID) + return TRUE; + } + return FALSE; +} + +/* + * transport_packet(){ + * sync_byte 8 bslbf == 0x47 + * transport_error_indicator 1 bslbf + * payload_unit_start_indicator 1 bslbf + * transport _priority 1 bslbf + * PID 13 uimsbf + * transport_scrambling_control 2 bslbf + * adaptation_field_control 2 bslbf + * continuity_counter 4 uimsbf + * if(adaptation_field_control=='10' || adaptation_field_control=='11'){ + * adaptation_field() + * } + * if(adaptation_field_control=='01' || adaptation_field_control=='11') { + * for (i=0;iPID; + transport_scrambling_control = (data[2] & 0xc0) >> 6; + adaptation_field_control = (data[2] & 0x30) >> 4; + continuity_counter = data[2] & 0x0f; + + data += 3; + datalen -= 3; + + GST_DEBUG_OBJECT (demux, "afc 0x%x, pusi %d, PID 0x%04x datalen %u", + adaptation_field_control, payload_unit_start_indicator, PID, datalen); + + ret = GST_FLOW_OK; + + /* packets with adaptation_field_control == 0 must be skipped */ + if (adaptation_field_control == 0) + goto skip; + + /* parse adaption field if any */ + if (adaptation_field_control & 0x2) { + guint consumed; + + if (!gst_fluts_demux_parse_adaptation_field (stream, data, + datalen, &consumed)) + goto done; + + if (datalen <= consumed) + goto too_small; + + data += consumed; + datalen -= consumed; + GST_DEBUG_OBJECT (demux, "consumed: %u datalen: %u", consumed, datalen); + } + + /* If this packet has a payload, handle it */ + if (adaptation_field_control & 0x1) { + GST_DEBUG_OBJECT (demux, "Packet payload %d bytes, PID 0x%04x", datalen, + PID); + + /* For unknown streams, check if the PID is in the partial PIDs + * list as an elementary stream and override the type if so + */ + if (stream->PID_type == PID_TYPE_UNKNOWN) { + if (fluts_is_elem_pid (demux, PID)) { + GST_DEBUG_OBJECT (demux, + "PID 0x%04x is an elementary stream in the PID list", PID); + stream->PID_type = PID_TYPE_ELEMENTARY; + stream->flags |= FLUTS_STREAM_FLAG_STREAM_TYPE_UNKNOWN; + stream->base_time = 0; + stream->last_time = 0; + + /* Clear any existing descriptor */ + if (stream->ES_info) { + gst_mpeg_descriptor_free (stream->ES_info); + stream->ES_info = NULL; + } + + /* Initialise our PES filter */ + gst_pes_filter_init (&stream->filter, NULL, NULL); + gst_pes_filter_set_callbacks (&stream->filter, + (GstPESFilterData) gst_fluts_demux_data_cb, + (GstPESFilterResync) gst_fluts_demux_resync_cb, stream); + } + } + + /* now parse based on the stream type */ + switch (stream->PID_type) { + case PID_TYPE_PROGRAM_ASSOCIATION: + case PID_TYPE_CONDITIONAL_ACCESS: + case PID_TYPE_PROGRAM_MAP: + case PID_TYPE_PRIVATE_SECTION: + { + GstBuffer *sec_buf; + guint8 *section_data; + guint16 section_length; + guint8 pointer; + + /* do stuff with our section */ + if (payload_unit_start_indicator) { + pointer = *data++; + datalen -= 1; + if (pointer >= datalen) { + GST_DEBUG_OBJECT (demux, "pointer: 0x%02x too large", pointer); + return GST_FLOW_OK; + } + data += pointer; + datalen -= pointer; + } + + /* FIXME: try to use data directly instead of creating a buffer and + pushing in into adapter at section filter */ + sec_buf = gst_buffer_new_and_alloc (datalen); +#ifdef USE_LIBOIL + oil_memcpy (GST_BUFFER_DATA (sec_buf), data, datalen); +#else + memcpy (GST_BUFFER_DATA (sec_buf), data, datalen); +#endif + if (gst_section_filter_push (&stream->section_filter, + payload_unit_start_indicator, continuity_counter, sec_buf)) { + GST_DEBUG_OBJECT (demux, "section finished"); + /* section ready */ + section_length = stream->section_filter.section_length; + section_data = + (guint8 *) gst_adapter_peek (stream->section_filter.adapter, + section_length + 3); + + switch (stream->PID_type) { + case PID_TYPE_PROGRAM_ASSOCIATION: + gst_fluts_stream_parse_pat (stream, section_data, + section_length + 3); + break; + case PID_TYPE_CONDITIONAL_ACCESS: + gst_fluts_stream_parse_cat (stream, section_data, + section_length + 3); + break; + case PID_TYPE_PROGRAM_MAP: + gst_fluts_stream_parse_pmt (stream, section_data, + section_length + 3); + break; + case PID_TYPE_PRIVATE_SECTION: + gst_fluts_stream_parse_private_section (stream, section_data, + section_length + 3); + break; + } + + gst_section_filter_clear (&stream->section_filter); + + } else { + /* section still going, don't parse left */ + GST_DEBUG_OBJECT (demux, "section still going for PID 0x%04x", PID); + } + break; + } + case PID_TYPE_NULL_PACKET: + GST_DEBUG_OBJECT (demux, + "skipping PID 0x%04x, type 0x%04x (NULL packet)", PID, + stream->PID_type); + break; + case PID_TYPE_UNKNOWN: + GST_DEBUG_OBJECT (demux, "skipping unknown PID 0x%04x, type 0x%04x", + PID, stream->PID_type); + break; + case PID_TYPE_ELEMENTARY: + { + GstBuffer *es_buf; + + if (payload_unit_start_indicator) { + GST_DEBUG_OBJECT (demux, "new PES start for PID 0x%04x", PID); + gst_pes_filter_drain (&stream->filter); + } + GST_LOG_OBJECT (demux, "Elementary packet of size %u for PID 0x%04x", + datalen, PID); + + if (datalen > 0) { + es_buf = gst_buffer_new_and_alloc (datalen); +#ifdef USE_LIBOIL + oil_memcpy (GST_BUFFER_DATA (es_buf), data, datalen); +#else + memcpy (GST_BUFFER_DATA (es_buf), data, datalen); +#endif + ret = gst_pes_filter_push (&stream->filter, es_buf); + break; + } else { + GST_WARNING_OBJECT (demux, "overflow of datalen: %u so skipping", + datalen); + return GST_FLOW_OK; + } + + } + } + } + +done: + return ret; + +skip: + { + GST_DEBUG_OBJECT (demux, "skipping, adaptation_field_control == 0"); + return GST_FLOW_OK; + } +too_small: + { + GST_DEBUG_OBJECT (demux, "skipping, adaptation_field consumed all data"); + return GST_FLOW_OK; + } +} + +static FORCE_INLINE GstFlowReturn +gst_fluts_demux_parse_transport_packet (GstFluTSDemux * demux, + const guint8 * data) +{ + GstFlowReturn ret; + guint16 PID; + GstFluTSStream *stream; + + /* skip sync byte */ + data++; + + /* get PID */ + PID = ((data[0] & 0x1f) << 8) | data[1]; + + /* get the stream. */ + stream = gst_fluts_demux_get_stream_for_PID (demux, PID); + + /* parse the stream */ + ret = gst_fluts_demux_parse_stream (demux, stream, data, + FLUTS_NORMAL_TS_PACKETSIZE - 1); + + return ret; + + /* ERRORS */ +} + +static gboolean +gst_fluts_demux_send_event (GstFluTSDemux * demux, GstEvent * event) +{ + gint i; + gboolean have_stream = FALSE, res = TRUE; + + for (i = 0; i < FLUTS_MAX_PID + 1; i++) { + GstFluTSStream *stream = demux->streams[i]; + + if (stream && stream->pad) { + res &= gst_pad_push_event (stream->pad, gst_event_ref (event)); + have_stream = TRUE; + } + } + gst_event_unref (event); + + return have_stream; +} + +static gboolean +gst_fluts_demux_sink_event (GstPad * pad, GstEvent * event) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (gst_pad_get_parent (pad)); + gboolean res; + + GST_DEBUG_OBJECT (demux, "got event %s", + gst_event_type_get_name (GST_EVENT_TYPE (event))); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_FLUSH_START: + res = gst_fluts_demux_send_event (demux, event); + break; + case GST_EVENT_FLUSH_STOP: + gst_adapter_clear (demux->adapter); + res = gst_fluts_demux_send_event (demux, event); + break; + case GST_EVENT_EOS: + if (!(res = gst_fluts_demux_send_event (demux, event))) { + /* we have no streams */ + GST_ELEMENT_ERROR (demux, STREAM, TYPE_NOT_FOUND, + (NULL), ("No valid streams found at EOS")); + } + break; + case GST_EVENT_NEWSEGMENT: + res = gst_fluts_demux_send_event (demux, event); + break; + default: + res = gst_fluts_demux_send_event (demux, event); + break; + } + gst_object_unref (demux); + + return TRUE; +} + +#ifdef HAVE_LATENCY +static gboolean +gst_fluts_demux_provides_clock (GstElement * element) +{ + GstFluTSDemux *demux; + GstQuery *query; + gboolean is_live = FALSE; + GstPad *peer; + + demux = GST_FLUTS_DEMUX (element); + query = gst_query_new_latency (); + peer = gst_pad_get_peer (demux->sinkpad); + + if (peer) { + if (gst_pad_query (peer, query)) + gst_query_parse_latency (query, &is_live, NULL, NULL); + gst_object_unref (peer); + } + gst_query_unref (query); + + return is_live; +} + +static GstClock * +gst_fluts_demux_provide_clock (GstElement * element) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (element); + + if (gst_fluts_demux_provides_clock (element)) { + if (demux->clock == NULL) { + demux->clock = g_object_new (GST_TYPE_SYSTEM_CLOCK, "name", + "FluTSClock", NULL); + demux->clock_base = GST_CLOCK_TIME_NONE; + } + + return demux->clock; + } + + return NULL; +} + +static gboolean +gst_fluts_demux_src_pad_query (GstPad * pad, GstQuery * query) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (gst_pad_get_parent (pad)); + gboolean res = FALSE; + GstPad *peer; + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_LATENCY: + { + peer = gst_pad_get_peer (demux->sinkpad); + if (peer) { + res = gst_pad_query (peer, query); + if (res) { + gboolean is_live; + GstClockTime min_latency, max_latency; + + gst_query_parse_latency (query, &is_live, &min_latency, &max_latency); + if (is_live) { + min_latency += TS_LATENCY * GST_MSECOND; + if (max_latency != GST_CLOCK_TIME_NONE) + max_latency += TS_LATENCY * GST_MSECOND; + } + + gst_query_set_latency (query, is_live, min_latency, max_latency); + } + gst_object_unref (peer); + } + break; + } + default: + res = gst_pad_query_default (pad, query); + } + + return res; +} +#endif + +static FORCE_INLINE guint +gst_fluts_demux_sync_scan (GstFluTSDemux * demux, const guint8 * in_data, + guint size, guint * flush) +{ + guint sync_count = 0; + const guint8 *end_scan = in_data + size - demux->packetsize; + guint8 *ptr_data = (guint8 *) in_data; + + while (ptr_data <= end_scan && sync_count < LENGHT_SYNC_LUT) { + /* if sync code is found try to store it in the LUT */ + if (G_LIKELY (IS_MPEGTS_SYNC (ptr_data))) { + demux->sync_lut[sync_count] = ptr_data; + sync_count++; + /* skip paketsize bytes and try find next */ + ptr_data += demux->packetsize; + } else { + ptr_data++; + } + } + + *flush = ptr_data - in_data; + + return sync_count; +} + +static GstFlowReturn +gst_fluts_demux_chain (GstPad * pad, GstBuffer * buffer) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (gst_pad_get_parent (pad)); + GstFlowReturn ret = GST_FLOW_OK; + const guint8 *data; + guint avail; + guint flush = 0; + gint i; + guint sync_count; + + if (GST_BUFFER_IS_DISCONT (buffer)) + gst_adapter_clear (demux->adapter); + + /* first push the new buffer into the adapter */ + gst_adapter_push (demux->adapter, buffer); + + /* check if there's enough data to parse a packet */ + avail = gst_adapter_available (demux->adapter); + if (G_UNLIKELY (avail < demux->packetsize)) + goto done; + + /* recover all data from adapter */ + data = gst_adapter_peek (demux->adapter, avail); + + /* scan for sync codes */ + sync_count = gst_fluts_demux_sync_scan (demux, data, avail, &flush); + + /* process all packets */ + for (i = 0; i < sync_count; i++) { + ret = gst_fluts_demux_parse_transport_packet (demux, demux->sync_lut[i]); + if (G_UNLIKELY (ret != GST_FLOW_OK)) { + if (ret == GST_FLOW_LOST_SYNC) { + ret = GST_FLOW_OK; + continue; + } + flush = demux->sync_lut[i] - data + demux->packetsize; + goto done; + } + } + +done: + /* flush processed data */ + gst_adapter_flush (demux->adapter, flush); + + gst_object_unref (demux); + + return ret; +} + +static GstStateChangeReturn +gst_fluts_demux_change_state (GstElement * element, GstStateChange transition) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (element); + GstStateChangeReturn result; + + + switch (transition) { + case GST_STATE_CHANGE_NULL_TO_READY: + demux->adapter = gst_adapter_new (); + demux->sync_lut = g_new0 (guint8 *, LENGHT_SYNC_LUT); + break; + case GST_STATE_CHANGE_READY_TO_PAUSED: + break; + default: + break; + } + + result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + switch (transition) { + case GST_STATE_CHANGE_PAUSED_TO_READY: + gst_fluts_demux_reset (demux); + break; + case GST_STATE_CHANGE_READY_TO_NULL: + g_object_unref (demux->adapter); + g_free (demux->sync_lut); + break; + default: + break; + } + + return result; +} + +static GValueArray * +fluts_demux_build_pat_info (GstFluTSDemux * demux) +{ + GValueArray *vals = NULL; + GstFluTSPAT *PAT; + gint i; + + g_return_val_if_fail (demux->streams[0] != NULL, NULL); + g_return_val_if_fail (demux->streams[0]->PID_type == + PID_TYPE_PROGRAM_ASSOCIATION, NULL); + + PAT = &(demux->streams[0]->PAT); + vals = g_value_array_new (PAT->entries->len); + + for (i = 0; i < PAT->entries->len; i++) { + GstFluTSPATEntry *cur_entry = + &g_array_index (PAT->entries, GstFluTSPATEntry, i); + GValue v = { 0, }; + FluTsPatInfo *info_obj; + + info_obj = fluts_pat_info_new (cur_entry->program_number, cur_entry->PID); + + g_value_init (&v, G_TYPE_OBJECT); + g_value_take_object (&v, info_obj); + g_value_array_append (vals, &v); + } + return vals; +} + +static FluTsPmtInfo * +fluts_demux_build_pmt_info (GstFluTSDemux * demux, guint16 pmt_pid) +{ + FluTsPmtInfo *info_obj; + GstFluTSPMT *PMT; + gint i; + + g_return_val_if_fail (demux->streams[pmt_pid] != NULL, NULL); + g_return_val_if_fail (demux->streams[pmt_pid]->PID_type == + PID_TYPE_PROGRAM_MAP, NULL); + + PMT = &(demux->streams[pmt_pid]->PMT); + + info_obj = fluts_pmt_info_new (PMT->program_number, PMT->PCR_PID, + PMT->version_number); + + for (i = 0; i < PMT->entries->len; i++) { + GstFluTSStream *stream; + FluTsPmtStreamInfo *stream_info; + GstFluTSPMTEntry *cur_entry = + &g_array_index (PMT->entries, GstFluTSPMTEntry, i); + + stream = demux->streams[cur_entry->PID]; + stream_info = + fluts_pmt_stream_info_new (cur_entry->PID, stream->stream_type); + + if (stream->ES_info) { + int i; + + /* add languages */ + guint8 *iso639_languages = + gst_mpeg_descriptor_find (stream->ES_info, DESC_ISO_639_LANGUAGE); + if (iso639_languages) { + for (i = 0; i < DESC_ISO_639_LANGUAGE_codes_n (iso639_languages); i++) { + gchar *language_n = (gchar *) + DESC_ISO_639_LANGUAGE_language_code_nth (iso639_languages, i); + fluts_pmt_stream_info_add_language (stream_info, + g_strndup (language_n, 3)); + } + } + + for (i = 0; i < gst_mpeg_descriptor_n_desc (stream->ES_info); ++i) { + guint8 *desc = gst_mpeg_descriptor_nth (stream->ES_info, i); + + /* add the whole descriptor, tag + length + DESC_LENGTH bytes */ + fluts_pmt_stream_info_add_descriptor (stream_info, + (gchar *) desc, 2 + DESC_LENGTH (desc)); + } + } + fluts_pmt_info_add_stream (info_obj, stream_info); + } + return info_obj; +} + +static void +gst_fluts_demux_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (object); + gchar **pids; + guint num_pids; + int i; + + switch (prop_id) { + case PROP_ES_PIDS: + pids = g_strsplit (g_value_get_string (value), ":", -1); + num_pids = g_strv_length (pids); + if (num_pids > 0) { + demux->elementary_pids = g_new0 (guint16, num_pids); + demux->nb_elementary_pids = num_pids; + for (i = 0; i < num_pids; i++) { + demux->elementary_pids[i] = strtol (pids[i], NULL, 0); + GST_INFO ("partial TS ES pid %d", demux->elementary_pids[i]); + } + } + g_strfreev (pids); + break; + case PROP_CHECK_CRC: + demux->check_crc = g_value_get_boolean (value); + break; + case PROP_PROGRAM_NUMBER: + demux->program_number = g_value_get_int (value); + break; + case PROP_M2TS: + demux->m2ts_mode = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_fluts_demux_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstFluTSDemux *demux = GST_FLUTS_DEMUX (object); + int i; + + switch (prop_id) { + case PROP_ES_PIDS: + if (demux->nb_elementary_pids == 0) { + g_value_set_static_string (value, ""); + } else { + gchar **ts_pids; + + ts_pids = g_new0 (gchar *, demux->nb_elementary_pids + 1); + for (i = 0; i < demux->nb_elementary_pids; i++) { + ts_pids[i] = g_strdup_printf ("%d", demux->elementary_pids[i]); + } + + g_value_set_string (value, g_strjoinv (":", ts_pids)); + g_strfreev (ts_pids); + } + break; + case PROP_CHECK_CRC: + g_value_set_boolean (value, demux->check_crc); + break; + case PROP_PROGRAM_NUMBER: + g_value_set_int (value, demux->program_number); + break; + case PROP_PAT_INFO: + { + if (demux->streams[0] != NULL) { + g_value_take_boxed (value, fluts_demux_build_pat_info (demux)); + } + break; + } + case PROP_PMT_INFO: + { + if (demux->current_PMT != 0 && demux->streams[demux->current_PMT] != NULL) { + g_value_take_object (value, fluts_demux_build_pmt_info (demux, + demux->current_PMT)); + } + break; + } + case PROP_M2TS: + g_value_set_boolean (value, demux->m2ts_mode); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +gboolean +gst_fluts_demux_plugin_init (GstPlugin * plugin) +{ + if (!gst_element_register (plugin, "flutsdemux", + GST_RANK_PRIMARY, GST_TYPE_FLUTS_DEMUX)) + return FALSE; + + return TRUE; +} diff --git a/gst/mpegdemux/gstmpegtsdemux.h b/gst/mpegdemux/gstmpegtsdemux.h new file mode 100644 index 0000000..b35fb03 --- /dev/null +++ b/gst/mpegdemux/gstmpegtsdemux.h @@ -0,0 +1,224 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifndef __GST_FLUTS_DEMUX_H__ +#define __GST_FLUTS_DEMUX_H__ + +#include +#include + +#include "gstmpegdesc.h" +#include "gstpesfilter.h" +#include "gstsectionfilter.h" + +G_BEGIN_DECLS + +#if (POST_10_12) +#define HAVE_LATENCY +#endif + +#define FLUTS_MAX_PID 0x1fff +#define FLUTS_NORMAL_TS_PACKETSIZE 188 +#define FLUTS_M2TS_TS_PACKETSIZE 192 + +#define LENGHT_SYNC_LUT 256 + +#define IS_MPEGTS_SYNC(data) (((data)[0] == 0x47) && \ + (((data)[1] & 0x80) == 0x00) && \ + (((data)[3] & 0x10) == 0x10)) + +#define GST_TYPE_FLUTS_DEMUX (gst_fluts_demux_get_type()) +#define GST_FLUTS_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),\ + GST_TYPE_FLUTS_DEMUX,GstFluTSDemux)) +#define GST_FLUTS_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),\ + GST_TYPE_FLUTS_DEMUX,GstFluTSDemuxClass)) +#define GST_FLUTS_DEMUX_GET_CLASS(klass) (G_TYPE_INSTANCE_GET_CLASS((klass),\ + GST_TYPE_FLUTS_DEMUX,GstFluTSDemuxClass)) +#define GST_IS_FLUTS_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),\ + GST_TYPE_FLUTS_DEMUX)) +#define GST_IS_FLUTS_DEMUX_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),\ + GST_TYPE_FLUTS_DEMUX)) + +typedef struct _GstFluTSStream GstFluTSStream; +typedef struct _GstFluTSPMTEntry GstFluTSPMTEntry; +typedef struct _GstFluTSPMT GstFluTSPMT; +typedef struct _GstFluTSPATEntry GstFluTSPATEntry; +typedef struct _GstFluTSPAT GstFluTSPAT; +typedef struct _GstFluTSDemux GstFluTSDemux; +typedef struct _GstFluTSDemuxClass GstFluTSDemuxClass; + +struct _GstFluTSPMTEntry { + guint16 PID; +}; + +struct _GstFluTSPMT { + guint16 program_number; + guint8 version_number; + gboolean current_next_indicator; + guint8 section_number; + guint8 last_section_number; + guint16 PCR_PID; + guint16 program_info_length; + GstMPEGDescriptor * program_info; + + GArray * entries; +}; + +struct _GstFluTSPATEntry { + guint16 program_number; + guint16 PID; +}; + +struct _GstFluTSPAT { + guint16 transport_stream_id; + guint8 version_number; + gboolean current_next_indicator; + guint8 section_number; + guint8 last_section_number; + + GArray * entries; +}; + +typedef enum _FluTsStreamFlags { + FLUTS_STREAM_FLAG_STREAM_TYPE_UNKNOWN = 0x01, + FLUTS_STREAM_FLAG_PMT_VALID = 0x02, + FLUTS_STREAM_FLAG_IS_VIDEO = 0x04 +} FluTsStreamFlags; + +/* Information associated to a single MPEG stream. */ +struct _GstFluTSStream { + GstFluTSDemux * demux; + + FluTsStreamFlags flags; + + /* PID and type */ + guint16 PID; + guint8 PID_type; + + /* adaptation_field data */ + guint64 last_PCR; + guint64 base_PCR; + guint64 last_OPCR; + guint64 last_PCR_difference; + gboolean discont_PCR; + GstClockTimeDiff discont_difference; + + /* for PAT streams */ + GstFluTSPAT PAT; + + /* for PMT streams */ + GstFluTSPMT PMT; + + /* for CA streams */ + + /* for PAT, PMT, CA and private streams */ + GstSectionFilter section_filter; + + /* for PES streams */ + guint8 id; + guint8 stream_type; + GstPESFilter filter; + GstPad * pad; + GstFlowReturn last_ret; + GstMPEGDescriptor *ES_info; + /* needed because 33bit mpeg timestamps wrap around every (approx) 26.5 hrs */ + GstClockTimeDiff base_time; + GstClockTime last_time; + /* pid of PMT that this stream belongs to */ + guint16 PMT_pid; +}; + +struct _GstFluTSDemux { + GstElement parent; + + /* properties */ + gboolean check_crc; + + /* sink pad and adapter */ + GstPad * sinkpad; + GstAdapter * adapter; + guint8 ** sync_lut; + + /* current PMT PID */ + guint16 current_PMT; + + /* Array of FLUTS_MAX_PID + 1 stream entries */ + GstFluTSStream ** streams; + /* Array to perform pmts checks at gst_fluts_demux_parse_adaptation_field */ + gboolean pmts_checked[FLUTS_MAX_PID + 1]; + + /* Array of Elementary Stream pids for ts with PMT */ + guint16 * elementary_pids; + guint nb_elementary_pids; + + /* Program number to use */ + gint program_number; + + /* indicates that we need to close our pad group, because we've added + * at least one pad */ + gboolean need_no_more_pads; + guint16 packetsize; + gboolean m2ts_mode; +#ifdef HAVE_LATENCY + /* clocking */ + GstClock * clock; + GstClockTime clock_base; +#endif +}; + +struct _GstFluTSDemuxClass { + GstElementClass parent_class; + + GstPadTemplate * sink_template; + GstPadTemplate * video_template; + GstPadTemplate * audio_template; + GstPadTemplate * private_template; +}; + +GType gst_fluts_demux_get_type (void); + +gboolean gst_fluts_demux_plugin_init (GstPlugin *plugin); + +G_END_DECLS + +#endif /* __GST_FLUTS_DEMUX_H__ */ diff --git a/gst/mpegdemux/gstpesfilter.c b/gst/mpegdemux/gstpesfilter.c new file mode 100644 index 0000000..8a2ee28 --- /dev/null +++ b/gst/mpegdemux/gstpesfilter.c @@ -0,0 +1,645 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstmpegdefs.h" +#include "gstpesfilter.h" + +GST_DEBUG_CATEGORY (gstflupesfilter_debug); +#define GST_CAT_DEFAULT (gstflupesfilter_debug) + +static GstFlowReturn gst_pes_filter_data_push (GstPESFilter * filter, + gboolean first, GstBuffer * buffer); + +#define ADAPTER_OFFSET_FLUSH(_bytes_) if (filter->adapter_offset) *filter->adapter_offset = *filter->adapter_offset + (_bytes_) + +/* May pass null for adapter to have the filter create one */ +void +gst_pes_filter_init (GstPESFilter * filter, GstAdapter * adapter, + guint64 * adapter_offset) +{ + g_return_if_fail (filter != NULL); + + if (adapter != NULL) + g_object_ref (adapter); + else + adapter = gst_adapter_new (); + + filter->adapter = adapter; + filter->adapter_offset = adapter_offset; + filter->state = STATE_HEADER_PARSE; + filter->gather_pes = FALSE; + filter->allow_unbounded = FALSE; +} + +void +gst_pes_filter_uninit (GstPESFilter * filter) +{ + g_return_if_fail (filter != NULL); + + if (filter->adapter) + g_object_unref (filter->adapter); + filter->adapter = NULL; + filter->adapter_offset = NULL; +} + +void +gst_pes_filter_set_callbacks (GstPESFilter * filter, + GstPESFilterData data_cb, GstPESFilterResync resync_cb, gpointer user_data) +{ + g_return_if_fail (filter != NULL); + + filter->data_cb = data_cb; + filter->resync_cb = resync_cb; + filter->user_data = user_data; +} + +/* sync:4 == 00xx ! pts:3 ! 1 ! pts:15 ! 1 | pts:15 ! 1 */ +#define READ_TS(data, target, lost_sync_label) \ + if ((*data & 0x01) != 0x01) goto lost_sync_label; \ + target = ((guint64) (*data++ & 0x0E)) << 29; \ + target |= ((guint64) (*data++ )) << 22; \ + if ((*data & 0x01) != 0x01) goto lost_sync_label; \ + target |= ((guint64) (*data++ & 0xFE)) << 14; \ + target |= ((guint64) (*data++ )) << 7; \ + if ((*data & 0x01) != 0x01) goto lost_sync_label; \ + target |= ((guint64) (*data++ & 0xFE)) >> 1; + +static gboolean +gst_pes_filter_is_sync (guint32 sync) +{ + return ((sync & 0xfffffffc) == 0x000001bc) || + ((sync & 0xffffffe0) == 0x000001c0) || + ((sync & 0xfffffff0) == 0x000001f0) || + ((sync & 0xfffffff0) == 0x000001e0); +} + +static GstFlowReturn +gst_pes_filter_parse (GstPESFilter * filter) +{ + GstFlowReturn ret; + guint32 start_code; + + gboolean STD_buffer_bound_scale; + guint16 STD_buffer_size_bound; + const guint8 *data; + gint avail, datalen; + gboolean have_size = FALSE; + + /* read start code and length */ + if (!(data = gst_adapter_peek (filter->adapter, 6))) + goto need_more_data; + + /* get start code */ + start_code = GST_READ_UINT32_BE (data); + if (!gst_pes_filter_is_sync (start_code)) + goto lost_sync; + + filter->start_code = start_code; + filter->id = data[3]; + + /* skip start code */ + data += 4; + + /* start parsing length */ + filter->length = GST_READ_UINT16_BE (data); + + /* see how much is available */ + avail = gst_adapter_available (filter->adapter); + + GST_DEBUG ("id 0x%02x length %d, avail %d start code 0x%02x", filter->id, + filter->length, avail, filter->start_code); + + /* A data length of 0 indicates an unbounded packet in transport + * streams, but actually a 0 sized packet in program streams or + * for anything except video packets */ + + /* FIXME: Remove this hack that is checking start_code. Instead, we need + * a callback that a start_code has been collected, giving the caller a chance + * to set the allow_unbounded flag if they want */ + if (filter->length == 0 && + ((filter->start_code & 0xFFFFFFF0) == PACKET_VIDEO_START_CODE || + filter->allow_unbounded)) { + GST_DEBUG ("id 0x%02x, unbounded length", filter->id); + filter->unbounded_packet = TRUE; + } else { + filter->unbounded_packet = FALSE; + + if (filter->gather_pes && avail < filter->length + 6) { + GST_DEBUG ("id 0x%02x, bounded length %d, only have %d", + filter->id, filter->length + 6, avail); + goto need_more_data; + } + + /* if we need more data from now on, we lost sync */ + avail = MIN (avail, filter->length + 6); + } + + /* read more data, either the whole packet if there is a length + * or whatever we have available if this in an unbounded packet. */ + if (!(data = gst_adapter_peek (filter->adapter, avail))) + goto need_more_data; + + /* This will make us flag LOST_SYNC if we run out of data from here onward */ + have_size = TRUE; + + /* skip start code and length */ + data += 6; + datalen = avail - 6; + + GST_DEBUG ("datalen %d", datalen); + + switch (filter->start_code) { + case ID_PS_PROGRAM_STREAM_MAP: + case ID_PRIVATE_STREAM_2: + case ID_ECM_STREAM: + case ID_EMM_STREAM: + case ID_PROGRAM_STREAM_DIRECTORY: + case ID_DSMCC_STREAM: + case ID_ITU_TREC_H222_TYPE_E_STREAM: + goto skip; + case ID_PADDING_STREAM: + GST_DEBUG ("skipping padding stream"); + goto skip; + default: + break; + } + + if (datalen < 1) + goto need_more_data; + + filter->pts = filter->dts = -1; + + /* stuffing bits, first two bits are '10' for mpeg2 pes so this code is + * not triggered. */ + while (TRUE) { + if (*data != 0xff) + break; + + data++; + datalen--; + + GST_DEBUG ("got stuffing bit"); + + if (datalen < 1) + goto need_more_data; + } + + /* STD buffer size, never for mpeg2 */ + if ((*data & 0xc0) == 0x40) { + GST_DEBUG ("have STD"); + + if (datalen < 3) + goto need_more_data; + + STD_buffer_bound_scale = *data & 0x20; + STD_buffer_size_bound = ((guint16) (*data++ & 0x1F)) << 8; + STD_buffer_size_bound |= *data++; + + datalen -= 2; + } + + /* PTS but no DTS, never for mpeg2 */ + if ((*data & 0xf0) == 0x20) { + GST_DEBUG ("PTS without DTS"); + + if (datalen < 5) + goto need_more_data; + READ_TS (data, filter->pts, lost_sync); + GST_DEBUG ("PTS found %" G_GUINT64_FORMAT, filter->pts); + datalen -= 5; + } + /* PTS and DTS, never for mpeg2 */ + else if ((*data & 0xf0) == 0x30) { + GST_DEBUG ("PTS and DTS"); + + if (datalen < 10) + goto need_more_data; + READ_TS (data, filter->pts, lost_sync); + READ_TS (data, filter->dts, lost_sync); + GST_DEBUG ("PTS found %" G_GUINT64_FORMAT, filter->pts); + GST_DEBUG ("DTS found %" G_GUINT64_FORMAT, filter->dts); + datalen -= 10; + } else if ((*data & 0xc0) == 0x80) { + /* mpeg2 case */ + guchar flags; + guint8 header_data_length = 0; + + GST_DEBUG ("MPEG2 PES packet"); + + if (datalen < 3) + goto need_more_data; + /* 2: '10' + * 2: PES_scrambling_control + * 1: PES_priority + * 1: data_alignment_indicator + * 1: copyright + * 1: original_or_copy + */ + flags = *data++; + + GST_DEBUG ("flags: 0x%02x", flags); + if ((flags & 0xc0) != 0x80) + goto lost_sync; + + /* check PES scrambling control */ + if ((flags & 0x30) != 0) + goto encrypted; + + /* 2: PTS_DTS_flags + * 1: ESCR_flag + * 1: ES_rate_flag + * 1: DSM_trick_mode_flag + * 1: additional_copy_info_flag + * 1: PES_CRC_flag + * 1: PES_extension_flag + */ + flags = *data++; + + /* 8: PES_header_data_length */ + header_data_length = *data++; + datalen -= 3; + + GST_DEBUG ("header_data_length: %d, flags 0x%02x", + header_data_length, flags); + + if (header_data_length > datalen) + goto need_more_data; + + /* only DTS: this is invalid */ + if ((flags & 0xc0) == 0x40) + goto lost_sync; + + /* check for PTS */ + if ((flags & 0x80)) { + if (datalen < 5) + goto need_more_data; + + READ_TS (data, filter->pts, lost_sync); + GST_DEBUG ("PTS found %" G_GUINT64_FORMAT, filter->pts); + header_data_length -= 5; + datalen -= 5; + } + /* check for DTS */ + if ((flags & 0x40)) { + READ_TS (data, filter->dts, lost_sync); + if (datalen < 5) + goto need_more_data; + GST_DEBUG ("DTS found %" G_GUINT64_FORMAT, filter->dts); + header_data_length -= 5; + datalen -= 5; + } + /* ESCR_flag */ + if ((flags & 0x20)) { + GST_DEBUG ("%x ESCR found", filter->id); + if (datalen < 6) + goto need_more_data; + data += 6; + header_data_length -= 6; + datalen -= 6; + } + /* ES_rate_flag */ + if ((flags & 0x10)) { + guint32 es_rate; + + if (datalen < 3) + goto need_more_data; + + es_rate = ((guint32) (*data++ & 0x07)) << 14; + es_rate |= ((guint32) (*data++)) << 7; + es_rate |= ((guint32) (*data++ & 0xFE)) >> 1; + GST_DEBUG ("%x ES Rate found %u", filter->id, es_rate); + header_data_length -= 3; + datalen -= 3; + } + /* DSM_trick_mode_flag */ + if ((flags & 0x08)) { + guint8 trick_mode_flags; + + if (datalen < 1) + goto need_more_data; + + /* 3: trick_mode_control */ + trick_mode_flags = *data++; + GST_DEBUG ("%x DSM trick mode found, flags 0x%02x", filter->id, + trick_mode_flags); + + /* fast_forward */ + if ((trick_mode_flags & 0xe0) == 0x00) { + } + /* slow motion */ + else if ((trick_mode_flags & 0xe0) == 0x20) { + } + /* freeze frame */ + else if ((trick_mode_flags & 0xe0) == 0x40) { + } + /* fast reverse */ + else if ((trick_mode_flags & 0xe0) == 0x60) { + } + /* slow reverse */ + else if ((trick_mode_flags & 0xe0) == 0x80) { + } + /* reserved */ + else { + } + + header_data_length -= 1; + datalen -= 1; + } + /* additional_copy_info_flag */ + if ((flags & 0x04)) { + GST_DEBUG ("%x additional copy info, flags 0x%02x", filter->id, *data); + } + /* PES_CRC_flag */ + if ((flags & 0x02)) { + GST_DEBUG ("%x PES_CRC", filter->id); + } + /* PES_extension_flag */ + if ((flags & 0x01)) { + GST_DEBUG ("%x PES_extension", filter->id); + } + + /* calculate the amount of real data in this PES packet */ + data += header_data_length; + datalen -= header_data_length; + } else if (*data == 0x0f) { + /* Not sure what this clause is for */ + data++; + datalen--; + } else { + /* Data byte wasn't recognised as a flags byte */ + GST_DEBUG ("Unrecognised flags byte 0x%02x\n", *data); + goto lost_sync; + } + + { + GstBuffer *out; + guint16 consumed; + + consumed = avail - 6 - datalen; + + if (filter->unbounded_packet == FALSE) { + filter->length -= avail - 6; + GST_DEBUG ("pushing %d, need %d more, consumed %d", + datalen, filter->length, consumed); + } else { + GST_DEBUG ("pushing %d, unbounded packet, consumed %d", + datalen, consumed); + } + + if (datalen > 0) { + out = gst_buffer_new (); + GST_BUFFER_DATA (out) = g_memdup (data, datalen); + GST_BUFFER_SIZE (out) = datalen; + GST_BUFFER_MALLOCDATA (out) = GST_BUFFER_DATA (out); + + ret = gst_pes_filter_data_push (filter, TRUE, out); + filter->first = FALSE; + } else { + GST_LOG ("first being set to TRUE"); + filter->first = TRUE; + ret = GST_FLOW_OK; + } + + if (filter->length > 0 || filter->unbounded_packet) + filter->state = STATE_DATA_PUSH; + } + + gst_adapter_flush (filter->adapter, avail); + ADAPTER_OFFSET_FLUSH (avail); + + return ret; + +need_more_data: + { + if (filter->unbounded_packet == FALSE) { + if (have_size == TRUE) { + GST_DEBUG ("bounded need more data %d, lost sync", + gst_adapter_available (filter->adapter)); + ret = GST_FLOW_LOST_SYNC; + } else { + GST_DEBUG ("bounded need more data %d, breaking for more", + gst_adapter_available (filter->adapter)); + ret = GST_FLOW_NEED_MORE_DATA; + } + } else { + GST_DEBUG ("unbounded need more data %d", + gst_adapter_available (filter->adapter)); + ret = GST_FLOW_NEED_MORE_DATA; + } + + return ret; + } +skip: + { + GST_DEBUG ("skipping 0x%02x", filter->id); + gst_adapter_flush (filter->adapter, avail); + ADAPTER_OFFSET_FLUSH (avail); + + filter->length -= avail - 6; + if (filter->length > 0 || filter->unbounded_packet) + filter->state = STATE_DATA_SKIP; + return GST_FLOW_OK; + } +encrypted: + { + GST_DEBUG ("skipping encrypted 0x%02x", filter->id); + gst_adapter_flush (filter->adapter, avail); + ADAPTER_OFFSET_FLUSH (avail); + + filter->length -= avail - 6; + if (filter->length > 0 || filter->unbounded_packet) + filter->state = STATE_DATA_SKIP; + return GST_FLOW_OK; + } +lost_sync: + { + GST_DEBUG ("lost sync"); + gst_adapter_flush (filter->adapter, 4); + ADAPTER_OFFSET_FLUSH (4); + + return GST_FLOW_LOST_SYNC; + } +} + +static GstFlowReturn +gst_pes_filter_data_push (GstPESFilter * filter, gboolean first, + GstBuffer * buffer) +{ + GstFlowReturn ret; + + GST_LOG ("pushing, first: %d", first); + + if (filter->data_cb) { + ret = filter->data_cb (filter, first, buffer, filter->user_data); + } else { + gst_buffer_unref (buffer); + ret = GST_FLOW_OK; + } + return ret; +} + +GstFlowReturn +gst_pes_filter_push (GstPESFilter * filter, GstBuffer * buffer) +{ + GstFlowReturn ret; + + g_return_val_if_fail (filter != NULL, GST_FLOW_ERROR); + g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR); + + switch (filter->state) { + case STATE_HEADER_PARSE: + gst_adapter_push (filter->adapter, buffer); + ret = gst_pes_filter_parse (filter); + break; + case STATE_DATA_PUSH: + ret = gst_pes_filter_data_push (filter, filter->first, buffer); + filter->first = FALSE; + break; + case STATE_DATA_SKIP: + gst_buffer_unref (buffer); + ret = GST_FLOW_OK; + break; + default: + goto wrong_state; + } + return ret; + + /* ERROR */ +wrong_state: + { + GST_DEBUG ("wrong internal state %d", filter->state); + return GST_FLOW_ERROR; + } +} + +GstFlowReturn +gst_pes_filter_process (GstPESFilter * filter) +{ + GstFlowReturn ret; + gboolean skip = FALSE; + + g_return_val_if_fail (filter != NULL, GST_FLOW_ERROR); + + switch (filter->state) { + case STATE_HEADER_PARSE: + ret = gst_pes_filter_parse (filter); + break; + case STATE_DATA_SKIP: + skip = TRUE; + /* fallthrough */ + case STATE_DATA_PUSH: + if (filter->length > 0 || filter->unbounded_packet) { + gint avail; + + avail = gst_adapter_available (filter->adapter); + if (filter->unbounded_packet == FALSE) + avail = MIN (avail, filter->length); + + if (skip) { + gst_adapter_flush (filter->adapter, avail); + ADAPTER_OFFSET_FLUSH (avail); + ret = GST_FLOW_OK; + } else { + GstBuffer *out; + guint8 *data; + + data = gst_adapter_take (filter->adapter, avail); + + out = gst_buffer_new (); + GST_BUFFER_DATA (out) = data; + GST_BUFFER_SIZE (out) = avail; + GST_BUFFER_MALLOCDATA (out) = data; + + ret = gst_pes_filter_data_push (filter, filter->first, out); + filter->first = FALSE; + } + + if (filter->unbounded_packet == FALSE) { + filter->length -= avail; + if (filter->length == 0) + filter->state = STATE_HEADER_PARSE; + } + } else { + filter->state = STATE_HEADER_PARSE; + ret = GST_FLOW_OK; + } + break; + default: + goto wrong_state; + } + return ret; + + /* ERROR */ +wrong_state: + { + GST_DEBUG ("wrong internal state %d", filter->state); + return GST_FLOW_ERROR; + } +} + +void +gst_pes_filter_flush (GstPESFilter * filter) +{ + g_return_if_fail (filter != NULL); + + if (filter->adapter) { + gst_adapter_clear (filter->adapter); + if (filter->adapter_offset) + *filter->adapter_offset = G_MAXUINT64; + } + filter->state = STATE_HEADER_PARSE; +} + +GstFlowReturn +gst_pes_filter_drain (GstPESFilter * filter) +{ + g_return_val_if_fail (filter != NULL, GST_FLOW_ERROR); + + gst_pes_filter_flush (filter); + + return GST_FLOW_OK; +} diff --git a/gst/mpegdemux/gstpesfilter.h b/gst/mpegdemux/gstpesfilter.h new file mode 100644 index 0000000..b35d874 --- /dev/null +++ b/gst/mpegdemux/gstpesfilter.h @@ -0,0 +1,110 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifndef __GST_PES_FILTER_H__ +#define __GST_PES_FILTER_H__ + +#include +#include + +G_BEGIN_DECLS + +typedef struct _GstPESFilter GstPESFilter; + +typedef GstFlowReturn (*GstPESFilterData) (GstPESFilter * filter, gboolean first, GstBuffer * buffer, + gpointer user_data); +typedef void (*GstPESFilterResync) (GstPESFilter * filter, gpointer user_data); +typedef void (*GstPESFilterIndex) (GstPESFilter * filter, gpointer user_data); + +typedef enum { + STATE_HEADER_PARSE, + STATE_DATA_PUSH, + STATE_DATA_SKIP +} GstPESFilterState; + +struct _GstPESFilter { + GstAdapter * adapter; + guint64 * adapter_offset; + + GstPESFilterState state; + /* Whether to collect entire PES packets before + * outputting */ + gboolean gather_pes; + /* Whether unbounded packets are allowed in this + * stream */ + gboolean allow_unbounded; + + gboolean first; + GstPESFilterData data_cb; + GstPESFilterResync resync_cb; + gpointer user_data; + + guint32 start_code; + guint8 id; + gboolean unbounded_packet; + guint16 length; + + guint8 type; + + gint64 pts; + gint64 dts; +}; + +void gst_pes_filter_init (GstPESFilter * filter, GstAdapter * adapter, guint64 * adapter_offset); + +void gst_pes_filter_uninit (GstPESFilter * filter); + +void gst_pes_filter_set_callbacks (GstPESFilter * filter, + GstPESFilterData data_cb, + GstPESFilterResync resync_cb, + gpointer user_data); + +GstFlowReturn gst_pes_filter_push (GstPESFilter * filter, GstBuffer * buffer); +GstFlowReturn gst_pes_filter_process (GstPESFilter * filter); + +void gst_pes_filter_flush (GstPESFilter * filter); +GstFlowReturn gst_pes_filter_drain (GstPESFilter * filter); + +G_END_DECLS + +#endif /* __GST_PES_FILTER_H__ */ diff --git a/gst/mpegdemux/gstsectionfilter.c b/gst/mpegdemux/gstsectionfilter.c new file mode 100644 index 0000000..7749c7e --- /dev/null +++ b/gst/mpegdemux/gstsectionfilter.c @@ -0,0 +1,161 @@ + /* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "gstsectionfilter.h" + +#ifndef __always_inline +#if (__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) +#define __always_inline inline __attribute__((always_inline)) +#else +#define __always_inline inline +#endif +#endif + +#ifndef DISABLE_INLINE +#define FORCE_INLINE __always_inline +#else +#define FORCE_INLINE +#endif + +GST_DEBUG_CATEGORY (gstflusectionfilter_debug); +#define GST_CAT_DEFAULT (gstflusectionfilter_debug) + +void +gst_section_filter_init (GstSectionFilter * filter) +{ + g_return_if_fail (filter != NULL); + filter->adapter = gst_adapter_new (); + /* continuity counter can at max be 15 + * we make 255 as an indication that + * there is no last continuity counter */ + filter->last_continuity_counter = 255; + filter->section_length = G_MAXUINT16; +} + +void +gst_section_filter_uninit (GstSectionFilter * filter) +{ + g_return_if_fail (filter != NULL); + if (filter->adapter) + g_object_unref (filter->adapter); + filter->adapter = NULL; +} + +void +gst_section_filter_clear (GstSectionFilter * filter) +{ + g_return_if_fail (filter != NULL); + if (filter->adapter) { + gst_adapter_clear (filter->adapter); + filter->last_continuity_counter = 255; + filter->section_length = G_MAXUINT16; + } +} + +static FORCE_INLINE gboolean +gst_section_is_complete (GstSectionFilter * filter) +{ + /* section length measures size of section from 3 bytes into section + * (ie after section length field finished) until end of section) + */ + guint avail_bytes = gst_adapter_available (filter->adapter); + if (filter->section_length == avail_bytes - 3) { + return TRUE; + } else if (filter->section_length < (int) (avail_bytes - 3)) { + GST_DEBUG ("section length seems to be less than available bytes for " + "rest of section."); + return TRUE; + } + return FALSE; +} + +/* returns True when section finished and ready to parse */ +/* FIXME: especially for multi-section tables, we need to handle pusi correctly + * and handle cases where a new section starts in the same transport packet. + */ +gboolean +gst_section_filter_push (GstSectionFilter * filter, gboolean pusi, /* determines whether start or not */ + guint8 continuity_counter, GstBuffer * buf) +{ + g_return_val_if_fail (filter != NULL, FALSE); + + /* check if it's the first packet of a section or + * if it continues the section */ + if (pusi) { + const guint8 *data = GST_BUFFER_DATA (buf); + if (filter->last_continuity_counter != 255) { + GST_WARNING ("section lost, last continuity counter: %d" + "we now have a pusi at continuity counter: %d", + filter->last_continuity_counter, continuity_counter); + gst_section_filter_clear (filter); + } + filter->section_length = GST_READ_UINT16_BE (data + 1); + filter->section_length &= 0x0fff; + if (filter->section_length > 1021) { + GST_DEBUG ("section length too big"); + return FALSE; + } + gst_adapter_push (filter->adapter, buf); + filter->last_continuity_counter = continuity_counter; + return gst_section_is_complete (filter); + } else if (filter->last_continuity_counter == continuity_counter - 1 || + (filter->last_continuity_counter == 15 && continuity_counter == 0)) { + GST_DEBUG ("section still going, no pusi"); + gst_adapter_push (filter->adapter, buf); + filter->last_continuity_counter = continuity_counter; + return gst_section_is_complete (filter); + } + /* we have lost the section and we are not a start + * section, so clear what was in it */ + else { + GST_WARNING ("section lost, last continuity counter: %d" + "new continuity counter but not pusi: %d", + filter->last_continuity_counter, continuity_counter); + gst_section_filter_clear (filter); + return FALSE; + } +} diff --git a/gst/mpegdemux/gstsectionfilter.h b/gst/mpegdemux/gstsectionfilter.h new file mode 100644 index 0000000..e26e3b2 --- /dev/null +++ b/gst/mpegdemux/gstsectionfilter.h @@ -0,0 +1,69 @@ +/* + * This library is licensed under 2 different licenses and you + * can choose to use it under the terms of either one of them. The + * two licenses are the MPL 1.1 and the LGPL. + * + * MPL: + * + * 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. + * + * LGPL: + * + * 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. + * + * 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): Wim Taymans + */ + +#ifndef __GST_SECTION_FILTER_H__ +#define __GST_SECTION_FILTER_H__ + +#include +#include + +G_BEGIN_DECLS + +typedef struct _GstSectionFilter GstSectionFilter; + +struct _GstSectionFilter { + GstAdapter *adapter; + guint8 last_continuity_counter; + guint16 section_length; +}; + +void gst_section_filter_init (GstSectionFilter *filter); +void gst_section_filter_uninit (GstSectionFilter *filter); +gboolean gst_section_filter_push (GstSectionFilter *filter, + gboolean pusi, + guint8 continuity_counter, + GstBuffer *buf); +void gst_section_filter_clear (GstSectionFilter *filter); +G_END_DECLS + +#endif /* __GST_SECTION_FILTER_H__ */ -- 2.7.4