mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-02 14:36:41 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/gst/mpegtsdemux/mpegtsbase.c
Mart Raudsepp 8a2edc6581 tsdemux: Don't trigger a program change when falling back to ignore-pcr behaviour 
Since commit a79a756b79 we could change to ignore-pcr automatically at 500ms
into a live stream when no PCR is seen by then. However the stream counting in
program change detection was wrongly considering ignore-pcr programs to have a
separate PCR PID, even though we are actually ignoring the PCR PID completely,
resulting in an erroneous program switch getting triggered from the different
stream count. This in turn would send an EOS and switch out the pads for what
actually is still the same program, while we intended to simply apply a
workaround for broken encoders.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/3060>
2022-09-28 07:18:45 +00:00

2021 lines
62 KiB
C
Raw Blame History

/*
* mpegtsbase.c -
* Copyright (C) 2007 Alessandro Decina
* 2010 Edward Hervey
* Copyright (C) 2011, Hewlett-Packard Development Company, L.P.
* Author: Youness Alaoui <youness.alaoui@collabora.co.uk>, Collabora Ltd.
* Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>, Collabora Ltd.
* Author: Edward Hervey <bilboed@bilboed.com>, Collabora Ltd.
*
* Authors:
* Alessandro Decina <alessandro@nnva.org>
* Zaheer Abbas Merali <zaheerabbas at merali dot org>
* Edward Hervey <edward.hervey@collabora.co.uk>
*
* 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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <glib/gi18n-lib.h>
#include "mpegtsbase.h"
#include "gstmpegdesc.h"
#define RUNNING_STATUS_RUNNING 4
GST_DEBUG_CATEGORY_STATIC (mpegts_base_debug);
#define GST_CAT_DEFAULT mpegts_base_debug
static GQuark QUARK_PROGRAMS;
static GQuark QUARK_PROGRAM_NUMBER;
static GQuark QUARK_PID;
static GQuark QUARK_PCR_PID;
static GQuark QUARK_STREAMS;
static GQuark QUARK_STREAM_TYPE;
static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("video/mpegts, " "systemstream = (boolean) true ")
);
#define DEFAULT_IGNORE_PCR FALSE
enum
{
PROP_0,
PROP_PARSE_PRIVATE_SECTIONS,
PROP_IGNORE_PCR,
/* FILL ME */
};
static void mpegts_base_dispose (GObject * object);
static void mpegts_base_finalize (GObject * object);
static void mpegts_base_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void mpegts_base_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void mpegts_base_free_program (MpegTSBaseProgram * program);
static void mpegts_base_deactivate_program (MpegTSBase * base,
MpegTSBaseProgram * program);
static gboolean mpegts_base_sink_activate (GstPad * pad, GstObject * parent);
static gboolean mpegts_base_sink_activate_mode (GstPad * pad,
GstObject * parent, GstPadMode mode, gboolean active);
static GstFlowReturn mpegts_base_chain (GstPad * pad, GstObject * parent,
GstBuffer * buf);
static gboolean mpegts_base_sink_event (GstPad * pad, GstObject * parent,
GstEvent * event);
static gboolean mpegts_base_sink_query (GstPad * pad, GstObject * parent,
GstQuery * query);
static gboolean mpegts_base_default_sink_query (MpegTSBase * base,
GstQuery * query);
static GstStateChangeReturn mpegts_base_change_state (GstElement * element,
GstStateChange transition);
static gboolean mpegts_base_get_tags_from_eit (MpegTSBase * base,
GstMpegtsSection * section);
static gboolean mpegts_base_parse_atsc_mgt (MpegTSBase * base,
GstMpegtsSection * section);
static void remove_each_program (MpegTSBaseProgram * program,
MpegTSBase * base);
static void
_extra_init (void)
{
QUARK_PROGRAMS = g_quark_from_string ("programs");
QUARK_PROGRAM_NUMBER = g_quark_from_string ("program-number");
QUARK_PID = g_quark_from_string ("pid");
QUARK_PCR_PID = g_quark_from_string ("pcr-pid");
QUARK_STREAMS = g_quark_from_string ("streams");
QUARK_STREAM_TYPE = g_quark_from_string ("stream-type");
GST_DEBUG_CATEGORY_INIT (mpegts_base_debug, "mpegtsbase", 0,
"MPEG transport stream base class");
gst_mpegts_initialize ();
}
#define mpegts_base_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (MpegTSBase, mpegts_base, GST_TYPE_ELEMENT,
_extra_init ());
/* Default implementation is that mpegtsbase can remove any program */
static gboolean
mpegts_base_can_remove_program (MpegTSBase * base, MpegTSBaseProgram * program)
{
return TRUE;
}
static void
mpegts_base_class_init (MpegTSBaseClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
klass->can_remove_program = mpegts_base_can_remove_program;
element_class = GST_ELEMENT_CLASS (klass);
element_class->change_state = mpegts_base_change_state;
gst_element_class_add_static_pad_template (element_class, &sink_template);
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->dispose = mpegts_base_dispose;
gobject_class->finalize = mpegts_base_finalize;
gobject_class->set_property = mpegts_base_set_property;
gobject_class->get_property = mpegts_base_get_property;
g_object_class_install_property (gobject_class, PROP_PARSE_PRIVATE_SECTIONS,
g_param_spec_boolean ("parse-private-sections", "Parse private sections",
"Parse private sections", FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstMpegtsBase:ignore-pcr:
*
* Ignore PCR (Program Clock Reference) data from MPEG-TS PSI.
* This can help with playback of some broken files.
*
* Since: 1.18
*/
g_object_class_install_property (gobject_class, PROP_IGNORE_PCR,
g_param_spec_boolean ("ignore-pcr", "Ignore PCR stream for timing",
"Ignore PCR stream for timing", DEFAULT_IGNORE_PCR,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
klass->sink_query = GST_DEBUG_FUNCPTR (mpegts_base_default_sink_query);
klass->handle_psi = NULL;
gst_type_mark_as_plugin_api (GST_TYPE_MPEGTS_BASE, 0);
}
static void
mpegts_base_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
MpegTSBase *base = GST_MPEGTS_BASE (object);
switch (prop_id) {
case PROP_PARSE_PRIVATE_SECTIONS:
base->parse_private_sections = g_value_get_boolean (value);
break;
case PROP_IGNORE_PCR:
base->ignore_pcr = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
mpegts_base_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
MpegTSBase *base = GST_MPEGTS_BASE (object);
switch (prop_id) {
case PROP_PARSE_PRIVATE_SECTIONS:
g_value_set_boolean (value, base->parse_private_sections);
break;
case PROP_IGNORE_PCR:
g_value_set_boolean (value, base->ignore_pcr);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
mpegts_base_reset (MpegTSBase * base)
{
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
mpegts_packetizer_clear (base->packetizer);
memset (base->is_pes, 0, 1024);
memset (base->known_psi, 0, 1024);
/* FIXME : Actually these are not *always* know SI streams
* depending on the variant of mpeg-ts being used. */
/* Known PIDs : PAT, TSDT, IPMP CIT */
MPEGTS_BIT_SET (base->known_psi, 0);
MPEGTS_BIT_SET (base->known_psi, 2);
MPEGTS_BIT_SET (base->known_psi, 3);
/* TDT, TOT, ST */
MPEGTS_BIT_SET (base->known_psi, 0x14);
/* network synchronization */
MPEGTS_BIT_SET (base->known_psi, 0x15);
/* ATSC */
MPEGTS_BIT_SET (base->known_psi, 0x1ffb);
if (base->pat) {
g_ptr_array_unref (base->pat);
base->pat = NULL;
}
gst_segment_init (&base->segment, GST_FORMAT_UNDEFINED);
gst_segment_init (&base->out_segment, GST_FORMAT_UNDEFINED);
base->last_seek_seqnum = GST_SEQNUM_INVALID;
base->mode = BASE_MODE_STREAMING;
base->seen_pat = FALSE;
base->seek_offset = -1;
g_ptr_array_foreach (base->programs, (GFunc) remove_each_program, base);
g_ptr_array_remove_range (base->programs, 0, base->programs->len);
base->streams_aware = GST_OBJECT_PARENT (base)
&& GST_OBJECT_FLAG_IS_SET (GST_OBJECT_PARENT (base),
GST_BIN_FLAG_STREAMS_AWARE);
GST_DEBUG_OBJECT (base, "Streams aware : %d", base->streams_aware);
gst_event_replace (&base->seek_event, NULL);
if (klass->reset)
klass->reset (base);
}
static void
mpegts_base_init (MpegTSBase * base)
{
base->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink");
gst_pad_set_activate_function (base->sinkpad, mpegts_base_sink_activate);
gst_pad_set_activatemode_function (base->sinkpad,
mpegts_base_sink_activate_mode);
gst_pad_set_chain_function (base->sinkpad, mpegts_base_chain);
gst_pad_set_event_function (base->sinkpad, mpegts_base_sink_event);
gst_pad_set_query_function (base->sinkpad, mpegts_base_sink_query);
gst_element_add_pad (GST_ELEMENT (base), base->sinkpad);
base->disposed = FALSE;
base->packetizer = mpegts_packetizer_new ();
base->programs =
g_ptr_array_new_full (16, (GDestroyNotify) mpegts_base_free_program);
base->parse_private_sections = FALSE;
base->is_pes = g_new0 (guint8, 1024);
base->known_psi = g_new0 (guint8, 1024);
base->program_size = sizeof (MpegTSBaseProgram);
base->stream_size = sizeof (MpegTSBaseStream);
base->push_data = TRUE;
base->push_section = TRUE;
base->ignore_pcr = DEFAULT_IGNORE_PCR;
mpegts_base_reset (base);
}
static void
mpegts_base_dispose (GObject * object)
{
MpegTSBase *base = GST_MPEGTS_BASE (object);
if (!base->disposed) {
g_object_unref (base->packetizer);
base->disposed = TRUE;
g_free (base->known_psi);
g_free (base->is_pes);
}
if (G_OBJECT_CLASS (parent_class)->dispose)
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
mpegts_base_finalize (GObject * object)
{
MpegTSBase *base = GST_MPEGTS_BASE (object);
if (base->pat) {
g_ptr_array_unref (base->pat);
base->pat = NULL;
}
g_ptr_array_free (base->programs, TRUE);
gst_event_replace (&base->seek_event, NULL);
if (G_OBJECT_CLASS (parent_class)->finalize)
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/* returns NULL if no matching descriptor found *
* otherwise returns a descriptor that needs to *
* be freed */
const GstMpegtsDescriptor *
mpegts_get_descriptor_from_stream (MpegTSBaseStream * stream, guint8 tag)
{
GstMpegtsPMTStream *pmt = stream->stream;
GST_DEBUG ("Searching for tag 0x%02x in stream 0x%04x (stream_type 0x%02x)",
tag, stream->pid, stream->stream_type);
return gst_mpegts_find_descriptor (pmt->descriptors, tag);
}
const GstMpegtsDescriptor *
mpegts_get_descriptor_from_stream_with_extension (MpegTSBaseStream * stream,
guint8 tag, guint8 tag_extension)
{
GstMpegtsPMTStream *pmt = stream->stream;
GST_DEBUG ("Searching for tag 0x%02x tag_extension 0x%02x "
"in stream 0x%04x (stream_type 0x%02x)",
tag, tag_extension, stream->pid, stream->stream_type);
return gst_mpegts_find_descriptor_with_extension (pmt->descriptors, tag,
tag_extension);
}
typedef struct
{
gboolean res;
guint16 pid;
} PIDLookup;
static void
foreach_pid_in_program (MpegTSBaseProgram * program, PIDLookup * lookup)
{
if (!program->active)
return;
if (program->streams[lookup->pid])
lookup->res = TRUE;
}
static gboolean
mpegts_pid_in_active_programs (MpegTSBase * base, guint16 pid)
{
PIDLookup lookup;
lookup.res = FALSE;
lookup.pid = pid;
g_ptr_array_foreach (base->programs, (GFunc) foreach_pid_in_program, &lookup);
return lookup.res;
}
/* returns NULL if no matching descriptor found *
* otherwise returns a descriptor that needs to *
* be freed */
const GstMpegtsDescriptor *
mpegts_get_descriptor_from_program (MpegTSBaseProgram * program, guint8 tag)
{
const GstMpegtsPMT *pmt = program->pmt;
return gst_mpegts_find_descriptor (pmt->descriptors, tag);
}
static gchar *
_get_upstream_id (GstElement * element, GstPad * sinkpad)
{
gchar *upstream_id = gst_pad_get_stream_id (sinkpad);
if (!upstream_id) {
/* Try to create one from the upstream URI, else use a randome number */
GstQuery *query;
gchar *uri = NULL;
/* Try to generate one from the URI query and
* if it fails take a random number instead */
query = gst_query_new_uri ();
if (gst_element_query (element, query)) {
gst_query_parse_uri (query, &uri);
}
if (uri) {
GChecksum *cs;
/* And then generate an SHA256 sum of the URI */
cs = g_checksum_new (G_CHECKSUM_SHA256);
g_checksum_update (cs, (const guchar *) uri, strlen (uri));
g_free (uri);
upstream_id = g_strdup (g_checksum_get_string (cs));
g_checksum_free (cs);
} else {
/* Just get some random number if the URI query fails */
GST_FIXME_OBJECT (element, "Creating random stream-id, consider "
"implementing a deterministic way of creating a stream-id");
upstream_id =
g_strdup_printf ("%08x%08x%08x%08x", g_random_int (), g_random_int (),
g_random_int (), g_random_int ());
}
gst_query_unref (query);
}
return upstream_id;
}
static MpegTSBaseProgram *
mpegts_base_new_program (MpegTSBase * base,
gint program_number, guint16 pmt_pid)
{
MpegTSBaseProgram *program;
gchar *upstream_id, *stream_id;
GST_DEBUG_OBJECT (base, "program_number : %d, pmt_pid : 0x%04x",
program_number, pmt_pid);
program = g_malloc0 (base->program_size);
program->program_number = program_number;
program->pmt_pid = pmt_pid;
program->pcr_pid = G_MAXUINT16;
program->streams = g_new0 (MpegTSBaseStream *, 0x2000);
program->patcount = 0;
upstream_id = _get_upstream_id ((GstElement *) base, base->sinkpad);
stream_id = g_strdup_printf ("%s:%d", upstream_id, program_number);
program->collection = gst_stream_collection_new (stream_id);
g_free (stream_id);
g_free (upstream_id);
return program;
}
MpegTSBaseProgram *
mpegts_base_add_program (MpegTSBase * base,
gint program_number, guint16 pmt_pid)
{
MpegTSBaseProgram *program;
GST_DEBUG_OBJECT (base, "program_number : %d, pmt_pid : 0x%04x",
program_number, pmt_pid);
program = mpegts_base_new_program (base, program_number, pmt_pid);
/* Mark the PMT PID as being a known PSI PID */
if (G_UNLIKELY (MPEGTS_BIT_IS_SET (base->known_psi, pmt_pid))) {
GST_FIXME ("Refcounting. Setting twice a PID (0x%04x) as known PSI",
pmt_pid);
}
MPEGTS_BIT_SET (base->known_psi, pmt_pid);
/* Ensure the PMT PID was not used by some PES stream */
if (G_UNLIKELY (MPEGTS_BIT_IS_SET (base->is_pes, pmt_pid))) {
GST_DEBUG ("New program PMT PID was previously used by a PES stream");
MPEGTS_BIT_UNSET (base->is_pes, pmt_pid);
}
g_ptr_array_add (base->programs, program);
return program;
}
MpegTSBaseProgram *
mpegts_base_get_program (MpegTSBase * base, gint program_number)
{
guint i;
for (i = 0; i < base->programs->len; i++) {
MpegTSBaseProgram *program = g_ptr_array_index (base->programs, i);
if (program->program_number == program_number)
return program;
}
return NULL;
}
static MpegTSBaseProgram *
mpegts_base_steal_program (MpegTSBase * base, gint program_number)
{
guint i;
for (i = 0; i < base->programs->len; i++) {
MpegTSBaseProgram *program = g_ptr_array_index (base->programs, i);
if (program->program_number == program_number) {
return g_ptr_array_steal_index (base->programs, i);
}
}
return NULL;
}
static void
mpegts_base_free_stream (MpegTSBaseStream * stream)
{
if (stream->stream_object)
gst_object_unref (stream->stream_object);
if (stream->stream_id)
g_free (stream->stream_id);
g_free (stream);
}
static void
mpegts_base_free_program (MpegTSBaseProgram * program)
{
GList *tmp;
if (program->recycle) {
program->recycle = FALSE;
return;
}
if (program->pmt) {
gst_mpegts_section_unref (program->section);
program->pmt = NULL;
}
/* FIXME FIXME FIXME FREE STREAM OBJECT ! */
for (tmp = program->stream_list; tmp; tmp = tmp->next)
mpegts_base_free_stream ((MpegTSBaseStream *) tmp->data);
if (program->stream_list)
g_list_free (program->stream_list);
g_free (program->streams);
if (program->tags)
gst_tag_list_unref (program->tags);
if (program->collection)
gst_object_unref (program->collection);
g_free (program);
}
void
mpegts_base_deactivate_and_free_program (MpegTSBase * base,
MpegTSBaseProgram * program)
{
GST_DEBUG_OBJECT (base, "program_number : %d", program->program_number);
mpegts_base_deactivate_program (base, program);
mpegts_base_free_program (program);
}
static void
mpegts_base_remove_program (MpegTSBase * base, MpegTSBaseProgram * program)
{
GST_DEBUG_OBJECT (base, "program_number : %d", program->program_number);
g_ptr_array_remove (base->programs, program);
}
static guint32
get_registration_from_descriptors (GPtrArray * descriptors)
{
const GstMpegtsDescriptor *desc;
if ((desc =
gst_mpegts_find_descriptor (descriptors,
GST_MTS_DESC_REGISTRATION))) {
if (G_UNLIKELY (desc->length < 4)) {
GST_WARNING ("Registration descriptor with length < 4. (Corrupted ?)");
} else
return GST_READ_UINT32_BE (desc->data + 2);
}
return 0;
}
static gboolean
find_registration_in_descriptors (GPtrArray * descriptors,
guint32 registration_id)
{
guint i, nb_desc;
if (!descriptors)
return FALSE;
nb_desc = descriptors->len;
for (i = 0; i < nb_desc; i++) {
GstMpegtsDescriptor *desc = g_ptr_array_index (descriptors, i);
if (desc->tag == GST_MTS_DESC_REGISTRATION) {
guint32 reg_desc = GST_READ_UINT32_BE (desc->data + 2);
if (reg_desc == registration_id)
return TRUE;
}
}
return FALSE;
}
static MpegTSBaseStream *
mpegts_base_program_add_stream (MpegTSBase * base,
MpegTSBaseProgram * program, guint16 pid, guint8 stream_type,
GstMpegtsPMTStream * stream)
{
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
MpegTSBaseStream *bstream;
GST_DEBUG ("pid:0x%04x, stream_type:0x%03x", pid, stream_type);
/* FIXME : PID information/nature might change through time.
* We therefore *do* want to be able to replace an existing stream
* with updated information */
if (G_UNLIKELY (program->streams[pid])) {
if (stream_type != 0xff)
GST_WARNING ("Stream already present !");
return NULL;
}
bstream = g_malloc0 (base->stream_size);
bstream->stream_id =
g_strdup_printf ("%s/%08x",
gst_stream_collection_get_upstream_id (program->collection), pid);
bstream->pid = pid;
bstream->stream_type = stream_type;
bstream->stream = stream;
/* We don't yet know the stream type, subclasses will fill that */
bstream->stream_object = gst_stream_new (bstream->stream_id, NULL,
GST_STREAM_TYPE_UNKNOWN, GST_STREAM_FLAG_NONE);
if (stream) {
bstream->registration_id =
get_registration_from_descriptors (stream->descriptors);
GST_DEBUG ("PID 0x%04x, registration_id %" SAFE_FOURCC_FORMAT,
bstream->pid, SAFE_FOURCC_ARGS (bstream->registration_id));
}
program->streams[pid] = bstream;
program->stream_list = g_list_append (program->stream_list, bstream);
if (klass->stream_added)
if (klass->stream_added (base, bstream, program)) {
gst_stream_collection_add_stream (program->collection,
(GstStream *) gst_object_ref (bstream->stream_object));
bstream->in_collection = TRUE;
}
return bstream;
}
static void
mpegts_base_program_remove_stream (MpegTSBase * base,
MpegTSBaseProgram * program, guint16 pid)
{
MpegTSBaseClass *klass;
MpegTSBaseStream *stream = program->streams[pid];
GST_DEBUG ("pid:0x%04x", pid);
if (G_UNLIKELY (stream == NULL)) {
/* Can happen if the PCR PID is the same as a audio/video PID */
GST_DEBUG ("Stream already removed");
return;
}
klass = GST_MPEGTS_BASE_GET_CLASS (base);
/* If subclass needs it, inform it of the stream we are about to remove */
if (klass->stream_removed)
klass->stream_removed (base, stream);
program->stream_list = g_list_remove_all (program->stream_list, stream);
mpegts_base_free_stream (stream);
program->streams[pid] = NULL;
}
/* Check if pmtstream is already present in the program */
static inline gboolean
_stream_in_pmt (const GstMpegtsPMT * pmt, MpegTSBaseStream * stream)
{
guint i, nbstreams = pmt->streams->len;
for (i = 0; i < nbstreams; i++) {
GstMpegtsPMTStream *pmt_stream = g_ptr_array_index (pmt->streams, i);
if (pmt_stream->pid == stream->pid &&
pmt_stream->stream_type == stream->stream_type)
return TRUE;
}
return FALSE;
}
static inline gboolean
_pmt_stream_in_program (MpegTSBaseProgram * program,
GstMpegtsPMTStream * stream)
{
MpegTSBaseStream *old_stream = program->streams[stream->pid];
if (!old_stream)
return FALSE;
return old_stream->stream_type == stream->stream_type;
}
static gboolean
mpegts_base_update_program (MpegTSBase * base, MpegTSBaseProgram * program,
GstMpegtsSection * section, const GstMpegtsPMT * pmt)
{
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
const gchar *stream_id =
gst_stream_collection_get_upstream_id (program->collection);
GstStreamCollection *collection;
GList *tmp, *toremove;
guint i, nbstreams;
/* Create new collection */
collection = gst_stream_collection_new (stream_id);
gst_object_unref (program->collection);
program->collection = collection;
/* Replace section and pmt with the new one */
gst_mpegts_section_unref (program->section);
program->section = gst_mpegts_section_ref (section);
program->pmt = pmt;
/* Copy over gststream that still exist into the collection */
for (tmp = program->stream_list; tmp; tmp = tmp->next) {
MpegTSBaseStream *stream = (MpegTSBaseStream *) tmp->data;
if (_stream_in_pmt (pmt, stream) && stream->in_collection) {
gst_stream_collection_add_stream (program->collection,
gst_object_ref (stream->stream_object));
}
}
/* Add new streams (will also create and add gststream to the collection) */
nbstreams = pmt->streams->len;
for (i = 0; i < nbstreams; i++) {
GstMpegtsPMTStream *stream = g_ptr_array_index (pmt->streams, i);
if (!_pmt_stream_in_program (program, stream))
mpegts_base_program_add_stream (base, program, stream->pid,
stream->stream_type, stream);
}
/* Call subclass update */
if (klass->update_program)
klass->update_program (base, program);
/* Remove streams no longer present */
toremove = NULL;
for (tmp = program->stream_list; tmp; tmp = tmp->next) {
MpegTSBaseStream *stream = (MpegTSBaseStream *) tmp->data;
if (!_stream_in_pmt (pmt, stream))
toremove = g_list_prepend (toremove, stream);
}
for (tmp = toremove; tmp; tmp = tmp->next) {
MpegTSBaseStream *stream = (MpegTSBaseStream *) tmp->data;
mpegts_base_program_remove_stream (base, program, stream->pid);
}
return TRUE;
}
static gboolean
_stream_is_private_section (const GstMpegtsPMT * pmt,
GstMpegtsPMTStream * stream)
{
switch (stream->stream_type) {
case GST_MPEGTS_STREAM_TYPE_SCTE_DSMCC_DCB:
case GST_MPEGTS_STREAM_TYPE_SCTE_SIGNALING:
{
guint32 registration_id =
get_registration_from_descriptors (stream->descriptors);
/* Not a private section stream */
if (registration_id != DRF_ID_CUEI && registration_id != DRF_ID_ETV1)
return FALSE;
}
case GST_MPEGTS_STREAM_TYPE_PRIVATE_SECTIONS:
case GST_MPEGTS_STREAM_TYPE_MHEG:
case GST_MPEGTS_STREAM_TYPE_DSM_CC:
case GST_MPEGTS_STREAM_TYPE_DSMCC_A:
case GST_MPEGTS_STREAM_TYPE_DSMCC_B:
case GST_MPEGTS_STREAM_TYPE_DSMCC_C:
case GST_MPEGTS_STREAM_TYPE_DSMCC_D:
case GST_MPEGTS_STREAM_TYPE_SL_FLEXMUX_SECTIONS:
case GST_MPEGTS_STREAM_TYPE_METADATA_SECTIONS:
/* known PSI streams */
return TRUE;
case GST_MPEGTS_STREAM_TYPE_SCTE_SIT:
{
/* Not a private section stream */
if (!find_registration_in_descriptors (pmt->descriptors, DRF_ID_CUEI))
return FALSE;
return TRUE;
}
default:
return FALSE;
}
}
/* Return TRUE if programs are equal */
static gboolean
mpegts_base_is_same_program (MpegTSBase * base, MpegTSBaseProgram * oldprogram,
guint16 new_pmt_pid, const GstMpegtsPMT * new_pmt)
{
guint i, nbstreams;
MpegTSBaseStream *oldstream;
gboolean sawpcrpid = FALSE;
if (oldprogram->pmt_pid != new_pmt_pid) {
GST_DEBUG ("Different pmt_pid (new:0x%04x, old:0x%04x)", new_pmt_pid,
oldprogram->pmt_pid);
return FALSE;
}
if (!base->ignore_pcr && oldprogram->pcr_pid != new_pmt->pcr_pid) {
GST_DEBUG ("Different pcr_pid (new:0x%04x, old:0x%04x)",
new_pmt->pcr_pid, oldprogram->pcr_pid);
return FALSE;
}
/* Check the streams */
nbstreams = new_pmt->streams->len;
for (i = 0; i < nbstreams; ++i) {
GstMpegtsPMTStream *stream = g_ptr_array_index (new_pmt->streams, i);
oldstream = oldprogram->streams[stream->pid];
if (!oldstream) {
GST_DEBUG ("New stream 0x%04x not present in old program", stream->pid);
return FALSE;
}
if (oldstream->stream_type != stream->stream_type) {
GST_DEBUG
("New stream 0x%04x has a different stream type (new:%d, old:%d)",
stream->pid, stream->stream_type, oldstream->stream_type);
return FALSE;
}
if (stream->pid == oldprogram->pcr_pid)
sawpcrpid = TRUE;
}
/* If we have a PCR PID and the pcr is not shared with an existing stream, we'll have one extra stream */
if (!sawpcrpid && !base->ignore_pcr)
nbstreams += 1;
if (nbstreams != g_list_length (oldprogram->stream_list)) {
GST_DEBUG ("Different number of streams (new:%d, old:%d)",
nbstreams, g_list_length (oldprogram->stream_list));
return FALSE;
}
GST_DEBUG ("Programs are equal");
return TRUE;
}
/* Return TRUE if program is an update
*
* A program is equal if:
* * The program number is the same (will be if it enters this function)
* * AND The PMT PID is equal to the old one
* * AND It contains at least one stream from the previous program
*
* Changes that are acceptable are therefore:
* * New streams appearing
* * Old streams going away
* * PCR PID changing
*
* Unclear changes:
* * PMT PID being changed ?
* * Properties of elementary stream being changed ? (new tags ? metadata ?)
*/
static gboolean
mpegts_base_is_program_update (MpegTSBase * base,
MpegTSBaseProgram * oldprogram, guint16 new_pmt_pid,
const GstMpegtsPMT * new_pmt)
{
guint i, nbstreams;
MpegTSBaseStream *oldstream;
if (oldprogram->pmt_pid != new_pmt_pid) {
/* FIXME/CHECK: Can a program be updated by just changing its PID
* in the PAT ? */
GST_DEBUG ("Different pmt_pid (new:0x%04x, old:0x%04x)", new_pmt_pid,
oldprogram->pmt_pid);
return FALSE;
}
/* Check if at least one stream from the previous program is still present
* in the new program */
/* Check the streams */
nbstreams = new_pmt->streams->len;
for (i = 0; i < nbstreams; ++i) {
GstMpegtsPMTStream *stream = g_ptr_array_index (new_pmt->streams, i);
oldstream = oldprogram->streams[stream->pid];
if (!oldstream) {
GST_DEBUG ("New stream 0x%04x not present in old program", stream->pid);
} else if (oldstream->stream_type != stream->stream_type) {
GST_DEBUG
("New stream 0x%04x has a different stream type (new:%d, old:%d)",
stream->pid, stream->stream_type, oldstream->stream_type);
} else if (!_stream_is_private_section (new_pmt, stream)) {
/* FIXME : We should actually be checking a bit deeper,
* especially for private streams (where the differentiation is
* done at the registration level) */
GST_DEBUG
("Stream 0x%04x is identical (stream_type %d) ! Program is an update",
stream->pid, stream->stream_type);
return TRUE;
}
}
GST_DEBUG ("Program is not an update of the previous one");
return FALSE;
}
static void
mpegts_base_deactivate_program (MpegTSBase * base, MpegTSBaseProgram * program)
{
gint i;
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
if (G_UNLIKELY (program->active == FALSE))
return;
GST_DEBUG_OBJECT (base, "Deactivating PMT");
program->active = FALSE;
if (program->pmt) {
for (i = 0; i < program->pmt->streams->len; ++i) {
GstMpegtsPMTStream *stream = g_ptr_array_index (program->pmt->streams, i);
mpegts_base_program_remove_stream (base, program, stream->pid);
/* Only unset the is_pes/known_psi bit if the PID isn't used in any other active
* program */
if (!mpegts_pid_in_active_programs (base, stream->pid)) {
if (_stream_is_private_section (program->pmt, stream)) {
if (base->parse_private_sections)
MPEGTS_BIT_UNSET (base->known_psi, stream->pid);
} else {
MPEGTS_BIT_UNSET (base->is_pes, stream->pid);
}
}
}
/* remove pcr stream */
/* FIXME : This might actually be shared with another stream ? */
mpegts_base_program_remove_stream (base, program, program->pcr_pid);
if (!mpegts_pid_in_active_programs (base, program->pcr_pid))
MPEGTS_BIT_UNSET (base->is_pes, program->pcr_pid);
GST_DEBUG ("program stream_list is now %p", program->stream_list);
}
/* Inform subclasses we're deactivating this program */
if (klass->program_stopped)
klass->program_stopped (base, program);
}
static void
mpegts_base_activate_program (MpegTSBase * base, MpegTSBaseProgram * program,
guint16 pmt_pid, GstMpegtsSection * section, const GstMpegtsPMT * pmt,
gboolean initial_program)
{
guint i;
MpegTSBaseClass *klass;
if (G_UNLIKELY (program->active))
return;
GST_DEBUG ("Activating program %d", program->program_number);
/* activate new pmt */
if (program->section)
gst_mpegts_section_unref (program->section);
program->section = gst_mpegts_section_ref (section);
program->pmt = pmt;
program->pmt_pid = pmt_pid;
if (!base->ignore_pcr)
program->pcr_pid = pmt->pcr_pid;
else
program->pcr_pid = 0x1fff;
/* extract top-level registration_id if present */
program->registration_id =
get_registration_from_descriptors (pmt->descriptors);
GST_DEBUG ("program 0x%04x, registration_id %" SAFE_FOURCC_FORMAT,
program->program_number, SAFE_FOURCC_ARGS (program->registration_id));
for (i = 0; i < pmt->streams->len; ++i) {
GstMpegtsPMTStream *stream = g_ptr_array_index (pmt->streams, i);
if (_stream_is_private_section (pmt, stream)) {
if (base->parse_private_sections)
MPEGTS_BIT_SET (base->known_psi, stream->pid);
} else {
if (G_UNLIKELY (MPEGTS_BIT_IS_SET (base->is_pes, stream->pid)))
GST_FIXME
("Refcounting issue. Setting twice a PID (0x%04x) as known PES",
stream->pid);
if (G_UNLIKELY (MPEGTS_BIT_IS_SET (base->known_psi, stream->pid))) {
GST_FIXME
("Refcounting issue. Setting a known PSI PID (0x%04x) as known PES",
stream->pid);
MPEGTS_BIT_UNSET (base->known_psi, stream->pid);
}
MPEGTS_BIT_SET (base->is_pes, stream->pid);
}
mpegts_base_program_add_stream (base, program,
stream->pid, stream->stream_type, stream);
}
/* We add the PCR pid last. If that PID is already used by one of the media
* streams above, no new stream will be created */
mpegts_base_program_add_stream (base, program, program->pcr_pid, -1, NULL);
MPEGTS_BIT_SET (base->is_pes, program->pcr_pid);
program->active = TRUE;
program->initial_program = initial_program;
klass = GST_MPEGTS_BASE_GET_CLASS (base);
if (klass->program_started != NULL)
klass->program_started (base, program);
GST_DEBUG_OBJECT (base, "new pmt activated");
}
static gboolean
mpegts_base_apply_pat (MpegTSBase * base, GstMpegtsSection * section)
{
GPtrArray *pat = gst_mpegts_section_get_pat (section);
GPtrArray *old_pat;
MpegTSBaseProgram *program;
gint i;
if (G_UNLIKELY (pat == NULL))
return FALSE;
GST_INFO_OBJECT (base, "PAT");
/* Applying a new PAT does two things:
* * It adds the new programs to the list of programs this element handles
* and increments at the same time the number of times a program is referenced.
*
* * If there was a previously active PAT, It decrements the reference count
* of all program it used. If a program is no longer needed, it is removed.
*/
old_pat = base->pat;
base->pat = pat;
GST_LOG ("Activating new Program Association Table");
/* activate the new table */
for (i = 0; i < pat->len; ++i) {
GstMpegtsPatProgram *patp = g_ptr_array_index (pat, i);
GST_LOG ("Looking for program %d / 0x%04x", patp->program_number,
patp->network_or_program_map_PID);
program = mpegts_base_get_program (base, patp->program_number);
if (program) {
GST_LOG ("Program exists on pid 0x%04x", program->pmt_pid);
/* If the new PMT PID clashes with an existing known PES stream, we know
* it is not an update */
if (MPEGTS_BIT_IS_SET (base->is_pes, patp->network_or_program_map_PID)) {
GST_LOG ("Program is not an update");
program =
mpegts_base_add_program (base, patp->program_number,
patp->network_or_program_map_PID);
} else if (program->pmt_pid != patp->network_or_program_map_PID) {
/* IF the program already existed, just check if the PMT PID changed */
GST_LOG ("PMT is on a different PID");
if (program->pmt_pid != G_MAXUINT16) {
/* pmt pid changed */
/* FIXME: when this happens it may still be pmt pid of another
* program, so setting to False may make it go through expensive
* path in is_psi unnecessarily */
MPEGTS_BIT_UNSET (base->known_psi, program->pmt_pid);
}
program->pmt_pid = patp->network_or_program_map_PID;
if (G_UNLIKELY (MPEGTS_BIT_IS_SET (base->known_psi, program->pmt_pid)))
GST_FIXME
("Refcounting issue. Setting twice a PMT PID (0x%04x) as know PSI",
program->pmt_pid);
MPEGTS_BIT_SET (base->known_psi, patp->network_or_program_map_PID);
} else {
GST_LOG ("Regular program update");
}
} else {
/* Create a new program */
program =
mpegts_base_add_program (base, patp->program_number,
patp->network_or_program_map_PID);
}
/* We mark this program as being referenced by one PAT */
program->patcount += 1;
}
if (old_pat) {
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
/* deactivate the old table */
GST_LOG ("Deactivating old Program Association Table");
for (i = 0; i < old_pat->len; ++i) {
GstMpegtsPatProgram *patp = g_ptr_array_index (old_pat, i);
program = mpegts_base_get_program (base, patp->program_number);
if (G_UNLIKELY (program == NULL)) {
GST_DEBUG_OBJECT (base, "broken PAT, duplicated entry for program %d",
patp->program_number);
continue;
}
GST_LOG ("Deactivating program %d / 0x%04x", patp->program_number,
patp->network_or_program_map_PID);
if (--program->patcount > 0) {
GST_LOG ("Referenced by new program, keeping");
/* the program has been referenced by the new pat, keep it */
continue;
}
GST_INFO_OBJECT (base, "PAT removing program 0x%04x 0x%04x",
patp->program_number, patp->network_or_program_map_PID);
if (klass->can_remove_program (base, program)) {
mpegts_base_deactivate_program (base, program);
mpegts_base_remove_program (base, program);
} else {
/* sub-class now owns the program and must call
* mpegts_base_deactivate_and_free_program later */
mpegts_base_steal_program (base, patp->program_number);
}
/* FIXME: when this happens it may still be pmt pid of another
* program, so setting to False may make it go through expensive
* path in is_psi unnecessarily */
if (G_UNLIKELY (MPEGTS_BIT_IS_SET (base->known_psi,
patp->network_or_program_map_PID))) {
GST_FIXME
("Program refcounting : Setting twice a pid (0x%04x) as known PSI",
patp->network_or_program_map_PID);
}
MPEGTS_BIT_SET (base->known_psi, patp->network_or_program_map_PID);
mpegts_packetizer_remove_stream (base->packetizer,
patp->network_or_program_map_PID);
}
g_ptr_array_unref (old_pat);
}
return TRUE;
}
static gboolean
mpegts_base_apply_pmt (MpegTSBase * base, GstMpegtsSection * section)
{
const GstMpegtsPMT *pmt;
MpegTSBaseProgram *program, *old_program;
guint program_number;
gboolean initial_program = TRUE;
pmt = gst_mpegts_section_get_pmt (section);
if (G_UNLIKELY (pmt == NULL)) {
GST_ERROR ("Could not get PMT (corrupted ?)");
return FALSE;
}
/* FIXME : not so sure this is valid anymore */
if (G_UNLIKELY (base->seen_pat == FALSE)) {
GST_WARNING ("Got pmt without pat first. Returning");
/* remove the stream since we won't get another PMT otherwise */
mpegts_packetizer_remove_stream (base->packetizer, section->pid);
return TRUE;
}
/* Don't attempt to handle pmt without any streams */
if (G_UNLIKELY (pmt->streams->len == 0)) {
GST_WARNING ("Skipping PMT without any entries");
return TRUE;
}
program_number = section->subtable_extension;
GST_DEBUG ("Applying PMT (program_number:%d, pid:0x%04x)",
program_number, section->pid);
/* In order for stream switching to happen properly in decodebin(2),
* we need to first add the new pads (i.e. activate the new program)
* before removing the old ones (i.e. deactivating the old program)
*/
old_program = mpegts_base_get_program (base, program_number);
if (G_UNLIKELY (old_program == NULL))
goto no_program;
if (base->streams_aware
&& mpegts_base_is_program_update (base, old_program, section->pid, pmt)) {
GST_FIXME ("We are streams_aware and new program is an update");
/* The program is an update, and we can add/remove pads dynamically */
mpegts_base_update_program (base, old_program, section, pmt);
goto beach;
}
if (G_UNLIKELY (mpegts_base_is_same_program (base, old_program, section->pid,
pmt)))
goto same_program;
/* If the current program is active, this means we have a new program */
if (old_program->active) {
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
old_program = mpegts_base_steal_program (base, program_number);
program = mpegts_base_new_program (base, program_number, section->pid);
program->patcount = old_program->patcount;
/* Deactivate the old program */
/* FIXME : THIS IS BREAKING THE STREAM SWITCHING LOGIC !
* */
if (klass->can_remove_program (base, old_program)) {
mpegts_base_deactivate_program (base, old_program);
mpegts_base_free_program (old_program);
} else {
/* sub-class now owns the program and must call
* mpegts_base_deactivate_and_free_program later */
mpegts_base_steal_program (base, old_program->program_number);
}
/* Add new program to the programs we track */
g_ptr_array_add (base->programs, program);
initial_program = FALSE;
} else {
GST_DEBUG ("Program update, re-using same program");
program = old_program;
}
/* activate program */
/* Ownership of pmt_info is given to the program */
mpegts_base_activate_program (base, program, section->pid, section, pmt,
initial_program);
beach:
GST_DEBUG ("Done activating program");
return TRUE;
no_program:
{
GST_ERROR ("Attempted to apply a PMT on a program that wasn't created");
return TRUE;
}
same_program:
{
GST_DEBUG ("Not applying identical program");
return TRUE;
}
}
static void
mpegts_base_handle_psi (MpegTSBase * base, GstMpegtsSection * section)
{
gboolean post_message = TRUE;
GST_DEBUG ("Handling PSI (pid: 0x%04x , table_id: 0x%02x)",
section->pid, section->table_id);
switch (section->section_type) {
case GST_MPEGTS_SECTION_PAT:
post_message = mpegts_base_apply_pat (base, section);
if (base->seen_pat == FALSE) {
base->seen_pat = TRUE;
GST_DEBUG ("First PAT offset: %" G_GUINT64_FORMAT, section->offset);
mpegts_packetizer_set_reference_offset (base->packetizer,
section->offset);
}
break;
case GST_MPEGTS_SECTION_PMT:
post_message = mpegts_base_apply_pmt (base, section);
break;
case GST_MPEGTS_SECTION_EIT:
/* some tag xtraction + posting */
post_message = mpegts_base_get_tags_from_eit (base, section);
break;
case GST_MPEGTS_SECTION_ATSC_MGT:
post_message = mpegts_base_parse_atsc_mgt (base, section);
break;
default:
break;
}
/* Give the subclass a chance to look at the section */
if (GST_MPEGTS_BASE_GET_CLASS (base)->handle_psi)
GST_MPEGTS_BASE_GET_CLASS (base)->handle_psi (base, section);
/* Finally post message (if it wasn't corrupted) */
if (post_message)
gst_element_post_message (GST_ELEMENT_CAST (base),
gst_message_new_mpegts_section (GST_OBJECT (base), section));
gst_mpegts_section_unref (section);
}
static gboolean
mpegts_base_parse_atsc_mgt (MpegTSBase * base, GstMpegtsSection * section)
{
const GstMpegtsAtscMGT *mgt;
gint i;
mgt = gst_mpegts_section_get_atsc_mgt (section);
if (G_UNLIKELY (mgt == NULL))
return FALSE;
for (i = 0; i < mgt->tables->len; ++i) {
GstMpegtsAtscMGTTable *table = g_ptr_array_index (mgt->tables, i);
if ((table->table_type >= GST_MPEGTS_ATSC_MGT_TABLE_TYPE_EIT0 &&
table->table_type <= GST_MPEGTS_ATSC_MGT_TABLE_TYPE_EIT127) ||
(table->table_type >= GST_MPEGTS_ATSC_MGT_TABLE_TYPE_ETT0 &&
table->table_type <= GST_MPEGTS_ATSC_MGT_TABLE_TYPE_ETT127)) {
MPEGTS_BIT_SET (base->known_psi, table->pid);
}
}
return TRUE;
}
static gboolean
mpegts_base_get_tags_from_eit (MpegTSBase * base, GstMpegtsSection * section)
{
const GstMpegtsEIT *eit;
guint i;
MpegTSBaseProgram *program;
/* Early exit if it's not from the present/following table_id */
if (section->table_id != GST_MTS_TABLE_ID_EVENT_INFORMATION_ACTUAL_TS_PRESENT
&& section->table_id !=
GST_MTS_TABLE_ID_EVENT_INFORMATION_OTHER_TS_PRESENT)
return TRUE;
eit = gst_mpegts_section_get_eit (section);
if (G_UNLIKELY (eit == NULL))
return FALSE;
program = mpegts_base_get_program (base, section->subtable_extension);
GST_DEBUG
("program_id:0x%04x, table_id:0x%02x, actual_stream:%d, present_following:%d, program:%p",
section->subtable_extension, section->table_id, eit->actual_stream,
eit->present_following, program);
if (program && eit->present_following) {
for (i = 0; i < eit->events->len; i++) {
GstMpegtsEITEvent *event = g_ptr_array_index (eit->events, i);
const GstMpegtsDescriptor *desc;
if (event->running_status == RUNNING_STATUS_RUNNING) {
program->event_id = event->event_id;
if ((desc =
gst_mpegts_find_descriptor (event->descriptors,
GST_MTS_DESC_DVB_SHORT_EVENT))) {
gchar *name = NULL, *text = NULL;
if (gst_mpegts_descriptor_parse_dvb_short_event (desc, NULL, &name,
&text)) {
if (!program->tags)
program->tags = gst_tag_list_new_empty ();
if (name) {
gst_tag_list_add (program->tags, GST_TAG_MERGE_APPEND,
GST_TAG_TITLE, name, NULL);
g_free (name);
}
if (text) {
gst_tag_list_add (program->tags, GST_TAG_MERGE_APPEND,
GST_TAG_DESCRIPTION, text, NULL);
g_free (text);
}
/* FIXME : Is it correct to post an event duration as a GST_TAG_DURATION ??? */
gst_tag_list_add (program->tags, GST_TAG_MERGE_APPEND,
GST_TAG_DURATION, event->duration * GST_SECOND, NULL);
return TRUE;
}
}
}
}
}
return TRUE;
}
static void
remove_each_program (MpegTSBaseProgram * program, MpegTSBase * base)
{
/* First deactivate it */
mpegts_base_deactivate_program (base, program);
}
static inline GstFlowReturn
mpegts_base_drain (MpegTSBase * base)
{
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
/* Call implementation */
if (klass->drain)
return klass->drain (base);
return GST_FLOW_OK;
}
static inline void
mpegts_base_flush (MpegTSBase * base, gboolean hard)
{
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
/* Call implementation */
if (klass->flush)
klass->flush (base, hard);
}
static gboolean
mpegts_base_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
gboolean res = TRUE;
gboolean hard;
MpegTSBase *base = GST_MPEGTS_BASE (parent);
gboolean is_sticky = GST_EVENT_IS_STICKY (event);
GST_DEBUG_OBJECT (base, "Got event %s",
gst_event_type_get_name (GST_EVENT_TYPE (event)));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEGMENT:
gst_event_copy_segment (event, &base->segment);
GST_DEBUG_OBJECT (base, "Received segment %" GST_SEGMENT_FORMAT,
&base->segment);
/* Check if we need to switch PCR/PTS handling */
if (base->segment.format == GST_FORMAT_TIME) {
base->packetizer->calculate_offset = FALSE;
base->packetizer->calculate_skew = TRUE;
/* Seek was handled upstream */
base->last_seek_seqnum = gst_event_get_seqnum (event);
} else {
base->packetizer->calculate_offset = TRUE;
base->packetizer->calculate_skew = FALSE;
}
res = GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, event);
break;
case GST_EVENT_STREAM_START:
gst_event_unref (event);
break;
case GST_EVENT_CAPS:
/* FIXME, do something */
gst_event_unref (event);
break;
case GST_EVENT_FLUSH_STOP:
res = GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, event);
hard = (base->mode != BASE_MODE_SEEKING);
mpegts_packetizer_flush (base->packetizer, hard);
mpegts_base_flush (base, hard);
gst_segment_init (&base->segment, GST_FORMAT_UNDEFINED);
base->seen_pat = FALSE;
break;
default:
res = GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, event);
}
/* Always return TRUE for sticky events */
if (is_sticky)
res = TRUE;
return res;
}
static gboolean
mpegts_base_default_sink_query (MpegTSBase * base, GstQuery * query)
{
return gst_pad_query_default (base->sinkpad, GST_OBJECT (base), query);
}
static gboolean
mpegts_base_sink_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
MpegTSBase *base = GST_MPEGTS_BASE (parent);
GST_DEBUG_OBJECT (base, "Got query %s",
gst_query_type_get_name (GST_QUERY_TYPE (query)));
return GST_MPEGTS_BASE_GET_CLASS (base)->sink_query (base, query);
}
static GstFlowReturn
mpegts_base_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
{
GstFlowReturn res = GST_FLOW_OK;
MpegTSBase *base;
MpegTSPacketizerPacketReturn pret;
MpegTSPacketizer2 *packetizer;
MpegTSPacketizerPacket packet;
MpegTSBaseClass *klass;
base = GST_MPEGTS_BASE (parent);
klass = GST_MPEGTS_BASE_GET_CLASS (base);
packetizer = base->packetizer;
if (GST_BUFFER_IS_DISCONT (buf)) {
GST_DEBUG_OBJECT (base, "Got DISCONT buffer, flushing");
res = mpegts_base_drain (base);
if (G_UNLIKELY (res != GST_FLOW_OK))
return res;
mpegts_base_flush (base, FALSE);
/* In the case of discontinuities in push-mode with TIME segment
* we want to drop all previous observations (hard:TRUE) from
* the packetizer */
if (base->mode == BASE_MODE_PUSHING
&& base->segment.format == GST_FORMAT_TIME) {
mpegts_packetizer_flush (base->packetizer, TRUE);
mpegts_packetizer_clear (base->packetizer);
} else
mpegts_packetizer_flush (base->packetizer, FALSE);
}
mpegts_packetizer_push (base->packetizer, buf);
while (res == GST_FLOW_OK) {
pret = mpegts_packetizer_next_packet (base->packetizer, &packet);
/* If we don't have enough data, return */
if (G_UNLIKELY (pret == PACKET_NEED_MORE))
break;
if (G_UNLIKELY (pret == PACKET_BAD)) {
/* bad header, skip the packet */
GST_DEBUG_OBJECT (base, "bad packet, skipping");
goto next;
}
if (klass->inspect_packet)
klass->inspect_packet (base, &packet);
/* If it's a known PES, push it */
if (MPEGTS_BIT_IS_SET (base->is_pes, packet.pid)) {
/* push the packet downstream */
if (base->push_data)
res = klass->push (base, &packet, NULL);
} else if (packet.payload
&& MPEGTS_BIT_IS_SET (base->known_psi, packet.pid)) {
/* base PSI data */
GList *others, *tmp;
GstMpegtsSection *section;
section = mpegts_packetizer_push_section (packetizer, &packet, &others);
if (section)
mpegts_base_handle_psi (base, section);
if (G_UNLIKELY (others)) {
for (tmp = others; tmp; tmp = tmp->next)
mpegts_base_handle_psi (base, (GstMpegtsSection *) tmp->data);
g_list_free (others);
}
/* we need to push section packet downstream */
if (base->push_section)
res = klass->push (base, &packet, section);
} else if (base->push_unknown) {
res = klass->push (base, &packet, NULL);
} else if (packet.payload && packet.pid != 0x1fff)
GST_LOG ("PID 0x%04x Saw packet on a pid we don't handle", packet.pid);
next:
mpegts_packetizer_clear_packet (base->packetizer, &packet);
}
if (res == GST_FLOW_OK && klass->input_done)
res = klass->input_done (base);
return res;
}
static GstFlowReturn
mpegts_base_scan (MpegTSBase * base)
{
GstFlowReturn ret = GST_FLOW_OK;
GstBuffer *buf = NULL;
guint i;
gboolean done = FALSE;
MpegTSPacketizerPacketReturn pret;
gint64 tmpval;
gint64 upstream_size, seek_pos, reverse_limit;
GstFormat format;
guint initial_pcr_seen;
GST_DEBUG ("Scanning for initial sync point");
/* Find initial sync point and at least 5 PCR values */
for (i = 0; i < 20 && !done; i++) {
GST_DEBUG ("Grabbing %d => %d", i * 65536, (i + 1) * 65536);
ret = gst_pad_pull_range (base->sinkpad, i * 65536, 65536, &buf);
if (G_UNLIKELY (ret == GST_FLOW_EOS))
break;
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto beach;
/* Push to packetizer */
mpegts_packetizer_push (base->packetizer, buf);
buf = NULL;
if (mpegts_packetizer_has_packets (base->packetizer)) {
if (base->seek_offset == -1) {
/* Mark the initial sync point and remember the packetsize */
base->seek_offset = base->packetizer->offset;
GST_DEBUG ("Sync point is now %" G_GUINT64_FORMAT, base->seek_offset);
base->packetsize = base->packetizer->packet_size;
}
while (1) {
/* Eat up all packets */
pret = mpegts_packetizer_process_next_packet (base->packetizer);
if (pret == PACKET_NEED_MORE)
break;
if (pret != PACKET_BAD && base->packetizer->nb_seen_offsets >= 5) {
GST_DEBUG ("Got enough initial PCR");
done = TRUE;
break;
}
}
}
}
initial_pcr_seen = base->packetizer->nb_seen_offsets;
if (G_UNLIKELY (initial_pcr_seen == 0))
goto no_initial_pcr;
GST_DEBUG ("Seen %d initial PCR", initial_pcr_seen);
/* Now send data from the end */
/* Get the size of upstream */
format = GST_FORMAT_BYTES;
if (!gst_pad_peer_query_duration (base->sinkpad, format, &tmpval))
goto beach;
upstream_size = tmpval;
/* The scanning takes place on the last 2048kB. Considering PCR should
* be present at least every 100ms, this should cope with streams
* up to 160Mbit/s */
reverse_limit = MAX (0, upstream_size - 2097152);
/* Find last PCR value, searching backwards by chunks of 300 MPEG-ts packets */
for (seek_pos = MAX (0, upstream_size - 56400);
seek_pos >= reverse_limit; seek_pos -= 56400) {
mpegts_packetizer_clear (base->packetizer);
GST_DEBUG ("Grabbing %" G_GUINT64_FORMAT " => %" G_GUINT64_FORMAT, seek_pos,
seek_pos + 56400);
ret = gst_pad_pull_range (base->sinkpad, seek_pos, 56400, &buf);
if (G_UNLIKELY (ret == GST_FLOW_EOS))
break;
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto beach;
/* Push to packetizer */
mpegts_packetizer_push (base->packetizer, buf);
buf = NULL;
if (mpegts_packetizer_has_packets (base->packetizer)) {
pret = PACKET_OK;
/* Eat up all packets, really try to get last PCR(s) */
while (pret != PACKET_NEED_MORE)
pret = mpegts_packetizer_process_next_packet (base->packetizer);
if (base->packetizer->nb_seen_offsets > initial_pcr_seen) {
GST_DEBUG ("Got last PCR(s) (total seen:%d)",
base->packetizer->nb_seen_offsets);
break;
}
}
}
beach:
mpegts_packetizer_clear (base->packetizer);
return ret;
no_initial_pcr:
mpegts_packetizer_clear (base->packetizer);
GST_WARNING_OBJECT (base, "Couldn't find any PCR within the first %d bytes",
10 * 65536);
return GST_FLOW_OK;
}
static void
mpegts_base_loop (MpegTSBase * base)
{
GstFlowReturn ret = GST_FLOW_ERROR;
switch (base->mode) {
case BASE_MODE_SCANNING:
/* Find first sync point */
ret = mpegts_base_scan (base);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto error;
base->mode = BASE_MODE_STREAMING;
GST_DEBUG ("Changing to Streaming");
break;
case BASE_MODE_SEEKING:
/* FIXME : unclear if we still need mode_seeking... */
base->mode = BASE_MODE_STREAMING;
break;
case BASE_MODE_STREAMING:
{
GstBuffer *buf = NULL;
GST_DEBUG ("Pulling data from %" G_GUINT64_FORMAT, base->seek_offset);
if (G_UNLIKELY (base->last_seek_seqnum == GST_SEQNUM_INVALID)) {
/* No configured seek, set a valid seqnum */
base->last_seek_seqnum = gst_util_seqnum_next ();
}
ret = gst_pad_pull_range (base->sinkpad, base->seek_offset,
100 * base->packetsize, &buf);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto error;
base->seek_offset += gst_buffer_get_size (buf);
ret = mpegts_base_chain (base->sinkpad, GST_OBJECT_CAST (base), buf);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto error;
}
break;
case BASE_MODE_PUSHING:
GST_WARNING ("wrong BASE_MODE_PUSHING mode in pull loop");
break;
}
return;
error:
{
GST_DEBUG_OBJECT (base, "Pausing task, reason %s", gst_flow_get_name (ret));
if (ret == GST_FLOW_EOS) {
if (!GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base,
gst_event_new_eos ()))
GST_ELEMENT_ERROR (base, STREAM, FAILED,
(_("Internal data stream error.")),
("No program activated before EOS"));
} else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
GST_ELEMENT_FLOW_ERROR (base, ret);
GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, gst_event_new_eos ());
}
gst_pad_pause_task (base->sinkpad);
}
}
gboolean
mpegts_base_handle_seek_event (MpegTSBase * base, GstPad * pad,
GstEvent * event)
{
MpegTSBaseClass *klass = GST_MPEGTS_BASE_GET_CLASS (base);
GstFlowReturn ret = GST_FLOW_ERROR;
gdouble rate;
gboolean flush, instant_rate_change;
GstFormat format;
GstSeekFlags flags;
GstSeekType start_type, stop_type;
gint64 start, stop;
GstEvent *flush_event = NULL;
gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
&stop_type, &stop);
if (format != GST_FORMAT_TIME)
return FALSE;
if (GST_EVENT_SEQNUM (event) == base->last_seek_seqnum) {
GST_DEBUG_OBJECT (base, "Skipping already handled seek");
return TRUE;
}
if (base->mode == BASE_MODE_PUSHING) {
/* First try if upstream supports seeking in TIME format */
if (gst_pad_push_event (base->sinkpad, gst_event_ref (event))) {
GST_DEBUG ("upstream handled SEEK event");
return TRUE;
}
/* If the subclass can seek, do that */
if (klass->seek) {
ret = klass->seek (base, event);
if (G_UNLIKELY (ret != GST_FLOW_OK))
GST_WARNING ("seeking failed %s", gst_flow_get_name (ret));
else {
GstEvent *new_seek;
if (GST_CLOCK_TIME_IS_VALID (base->seek_offset)) {
base->mode = BASE_MODE_SEEKING;
new_seek = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags,
GST_SEEK_TYPE_SET, base->seek_offset, GST_SEEK_TYPE_NONE, -1);
gst_event_set_seqnum (new_seek, GST_EVENT_SEQNUM (event));
if (!gst_pad_push_event (base->sinkpad, new_seek))
ret = GST_FLOW_ERROR;
else
base->last_seek_seqnum = GST_EVENT_SEQNUM (event);
}
base->mode = BASE_MODE_PUSHING;
}
} else {
GST_WARNING ("subclass has no seek implementation");
}
return ret == GST_FLOW_OK;
}
if (!klass->seek) {
GST_WARNING ("subclass has no seek implementation");
return FALSE;
}
if (rate <= 0.0) {
GST_WARNING ("Negative rate not supported");
return FALSE;
}
GST_DEBUG ("seek event, rate: %f start: %" GST_TIME_FORMAT
" stop: %" GST_TIME_FORMAT, rate, GST_TIME_ARGS (start),
GST_TIME_ARGS (stop));
flush = ! !(flags & GST_SEEK_FLAG_FLUSH);
instant_rate_change = ! !(flags & GST_SEEK_FLAG_INSTANT_RATE_CHANGE);
/* Directly send the instant-rate-change event here before taking the
* stream-lock so that it can be applied as soon as possible */
if (base->mode != BASE_MODE_PUSHING && instant_rate_change) {
GstEvent *ev;
/* instant rate change only supported if direction does not change. All
* other requirements are already checked before creating the seek event
* but let's double-check here to be sure */
if ((rate > 0 && base->out_segment.rate < 0) ||
(rate < 0 && base->out_segment.rate > 0) ||
start_type != GST_SEEK_TYPE_NONE ||
stop_type != GST_SEEK_TYPE_NONE || flush) {
GST_ERROR_OBJECT (base,
"Instant rate change seeks only supported in the "
"same direction, without flushing and position change");
return FALSE;
}
ev = gst_event_new_instant_rate_change (rate / base->out_segment.rate,
(GstSegmentFlags) (flags));
gst_event_set_seqnum (ev, GST_EVENT_SEQNUM (event));
GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, ev);
return TRUE;
}
/* stop streaming, either by flushing or by pausing the task */
base->mode = BASE_MODE_SEEKING;
if (flush) {
GST_DEBUG_OBJECT (base, "sending flush start");
flush_event = gst_event_new_flush_start ();
gst_event_set_seqnum (flush_event, GST_EVENT_SEQNUM (event));
gst_pad_push_event (base->sinkpad, gst_event_ref (flush_event));
GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, flush_event);
} else
gst_pad_pause_task (base->sinkpad);
/* wait for streaming to finish */
GST_PAD_STREAM_LOCK (base->sinkpad);
if (flush) {
/* send a FLUSH_STOP for the sinkpad, since we need data for seeking */
GST_DEBUG_OBJECT (base, "sending flush stop");
flush_event = gst_event_new_flush_stop (TRUE);
gst_event_set_seqnum (flush_event, GST_EVENT_SEQNUM (event));
/* ref for it to be reused later */
gst_pad_push_event (base->sinkpad, gst_event_ref (flush_event));
/* And actually flush our pending data but allow to preserve some info
* to perform the seek */
mpegts_base_flush (base, FALSE);
mpegts_packetizer_flush (base->packetizer, FALSE);
}
if (flags & (GST_SEEK_FLAG_SEGMENT)) {
GST_WARNING ("seek flags 0x%x are not supported", (int) flags);
goto done;
}
/* If the subclass can seek, do that */
ret = klass->seek (base, event);
if (G_UNLIKELY (ret != GST_FLOW_OK))
GST_WARNING ("seeking failed %s", gst_flow_get_name (ret));
else
base->last_seek_seqnum = GST_EVENT_SEQNUM (event);
if (flush_event) {
/* if we sent a FLUSH_START, we now send a FLUSH_STOP */
GST_DEBUG_OBJECT (base, "sending flush stop");
GST_MPEGTS_BASE_GET_CLASS (base)->push_event (base, flush_event);
flush_event = NULL;
}
done:
if (flush_event)
gst_event_unref (flush_event);
gst_pad_start_task (base->sinkpad, (GstTaskFunction) mpegts_base_loop, base,
NULL);
GST_PAD_STREAM_UNLOCK (base->sinkpad);
return ret == GST_FLOW_OK;
}
static gboolean
mpegts_base_sink_activate (GstPad * sinkpad, GstObject * parent)
{
GstQuery *query;
gboolean pull_mode;
query = gst_query_new_scheduling ();
if (!gst_pad_peer_query (sinkpad, query)) {
gst_query_unref (query);
goto activate_push;
}
pull_mode = gst_query_has_scheduling_mode_with_flags (query,
GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
gst_query_unref (query);
if (!pull_mode)
goto activate_push;
GST_DEBUG_OBJECT (sinkpad, "activating pull");
return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
activate_push:
{
GST_DEBUG_OBJECT (sinkpad, "activating push");
return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
}
}
static gboolean
mpegts_base_sink_activate_mode (GstPad * pad, GstObject * parent,
GstPadMode mode, gboolean active)
{
gboolean res;
MpegTSBase *base = GST_MPEGTS_BASE (parent);
switch (mode) {
case GST_PAD_MODE_PUSH:
base->mode = BASE_MODE_PUSHING;
res = TRUE;
break;
case GST_PAD_MODE_PULL:
if (active) {
base->mode = BASE_MODE_SCANNING;
/* When working pull-based, we always use offsets for estimation */
base->packetizer->calculate_offset = TRUE;
base->packetizer->calculate_skew = FALSE;
gst_segment_init (&base->segment, GST_FORMAT_BYTES);
res =
gst_pad_start_task (pad, (GstTaskFunction) mpegts_base_loop, base,
NULL);
} else
res = gst_pad_stop_task (pad);
break;
default:
res = FALSE;
break;
}
return res;
}
static GstStateChangeReturn
mpegts_base_change_state (GstElement * element, GstStateChange transition)
{
MpegTSBase *base;
GstStateChangeReturn ret;
base = GST_MPEGTS_BASE (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
mpegts_base_reset (base);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
mpegts_base_reset (base);
if (base->mode != BASE_MODE_PUSHING)
base->mode = BASE_MODE_SCANNING;
break;
default:
break;
}
return ret;
}
gboolean
gst_mpegtsbase_plugin_init (GstPlugin * plugin)
{
GST_DEBUG_CATEGORY_INIT (mpegts_base_debug, "mpegtsbase", 0,
"MPEG transport stream base class");
return TRUE;
}
Reference in a new issue View git blame Copy permalink