gstreamer/gst/mpegtsdemux/tsdemux.c
2012-01-25 14:51:25 +01:00

2458 lines
77 KiB
C

/*
* tsdemux.c
* Copyright (C) 2009 Zaheer Abbas Merali
* 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:
* 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., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "mpegtsbase.h"
#include "tsdemux.h"
#include "gstmpegdesc.h"
#include "gstmpegdefs.h"
#include "mpegtspacketizer.h"
#include "payload_parsers.h"
#include "pesparse.h"
/*
* tsdemux
*
* See TODO for explanations on improvements needed
*/
/* latency in mseconds */
#define TS_LATENCY 700
#define TABLE_ID_UNSET 0xFF
/* Size of the pendingbuffers array. */
#define TS_MAX_PENDING_BUFFERS 256
#define PCR_WRAP_SIZE_128KBPS (((gint64)1490)*(1024*1024))
/* small PCR for wrap detection */
#define PCR_SMALL 17775000
/* maximal PCR time */
#define PCR_MAX_VALUE (((((guint64)1)<<33) * 300) + 298)
#define PTS_DTS_MAX_VALUE (((guint64)1) << 33)
/* seek to SEEK_TIMESTAMP_OFFSET before the desired offset and search then
* either accurately or for the next timestamp
*/
#define SEEK_TIMESTAMP_OFFSET (1000 * GST_MSECOND)
GST_DEBUG_CATEGORY_STATIC (ts_demux_debug);
#define GST_CAT_DEFAULT ts_demux_debug
#define ABSDIFF(a,b) (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
static GQuark QUARK_TSDEMUX;
static GQuark QUARK_PID;
static GQuark QUARK_PCR;
static GQuark QUARK_OPCR;
static GQuark QUARK_PTS;
static GQuark QUARK_DTS;
static GQuark QUARK_OFFSET;
typedef enum
{
PENDING_PACKET_EMPTY = 0, /* No pending packet/buffer
* Push incoming buffers to the array */
PENDING_PACKET_HEADER, /* PES header needs to be parsed
* Push incoming buffers to the array */
PENDING_PACKET_BUFFER, /* Currently filling up output buffer
* Push incoming buffers to the bufferlist */
PENDING_PACKET_DISCONT /* Discontinuity in incoming packets
* Drop all incoming buffers */
} PendingPacketState;
typedef struct _TSDemuxStream TSDemuxStream;
struct _TSDemuxStream
{
MpegTSBaseStream stream;
GstPad *pad;
/* the return of the latest push */
GstFlowReturn flow_return;
/* Output data */
PendingPacketState state;
/* Pending buffers array. */
/* These buffers are stored in this array until the PES header (if needed)
* is succesfully parsed. */
GstBuffer *pendingbuffers[TS_MAX_PENDING_BUFFERS];
guint8 nbpending;
/* Current data to be pushed out */
GList *currentlist;
/* Current PTS/DTS for this stream */
GstClockTime pts;
GstClockTime dts;
/* Raw value of current PTS/DTS */
guint64 raw_pts;
guint64 raw_dts;
/* Number of rollover seen for PTS/DTS (default:0) */
guint nb_pts_rollover;
guint nb_dts_rollover;
};
#define VIDEO_CAPS \
GST_STATIC_CAPS (\
"video/mpeg, " \
"mpegversion = (int) { 1, 2, 4 }, " \
"systemstream = (boolean) FALSE; " \
"video/x-h264,stream-format=(string)byte-stream," \
"alignment=(string)nal;" \
"video/x-dirac;" \
"video/x-wmv," \
"wmvversion = (int) 3, " \
"format = (string) WVC1" \
)
#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-eac3;" \
"audio/x-dts;" \
"audio/x-private-ts-lpcm" \
)
/* Can also use the subpicture pads for text subtitles? */
#define SUBPICTURE_CAPS \
GST_STATIC_CAPS ("subpicture/x-pgs; video/x-dvd-subpicture")
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 subpicture_template =
GST_STATIC_PAD_TEMPLATE ("subpicture_%04x",
GST_PAD_SRC,
GST_PAD_SOMETIMES,
SUBPICTURE_CAPS);
static GstStaticPadTemplate private_template =
GST_STATIC_PAD_TEMPLATE ("private_%04x",
GST_PAD_SRC,
GST_PAD_SOMETIMES,
GST_STATIC_CAPS_ANY);
enum
{
ARG_0,
PROP_PROGRAM_NUMBER,
PROP_EMIT_STATS,
/* FILL ME */
};
/* Pad functions */
static gboolean gst_ts_demux_srcpad_query (GstPad * pad, GstObject * parent,
GstQuery * query);
/* mpegtsbase methods */
static void
gst_ts_demux_program_started (MpegTSBase * base, MpegTSBaseProgram * program);
static void gst_ts_demux_reset (MpegTSBase * base);
static GstFlowReturn
gst_ts_demux_push (MpegTSBase * base, MpegTSPacketizerPacket * packet,
MpegTSPacketizerSection * section);
static void gst_ts_demux_flush (MpegTSBase * base);
static void
gst_ts_demux_stream_added (MpegTSBase * base, MpegTSBaseStream * stream,
MpegTSBaseProgram * program);
static void
gst_ts_demux_stream_removed (MpegTSBase * base, MpegTSBaseStream * stream);
static GstFlowReturn gst_ts_demux_do_seek (MpegTSBase * base, GstEvent * event,
guint16 pid);
static GstFlowReturn find_pcr_packet (MpegTSBase * base, guint64 offset,
gint64 length, TSPcrOffset * pcroffset);
static GstFlowReturn find_timestamps (MpegTSBase * base, guint64 initoff,
guint64 * offset);
static void gst_ts_demux_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_ts_demux_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_ts_demux_finalize (GObject * object);
static GstFlowReturn
process_pcr (MpegTSBase * base, guint64 initoff, TSPcrOffset * pcroffset,
guint numpcr, gboolean isinitial);
static void gst_ts_demux_flush_streams (GstTSDemux * tsdemux);
static GstFlowReturn
gst_ts_demux_push_pending_data (GstTSDemux * demux, TSDemuxStream * stream);
static gboolean push_event (MpegTSBase * base, GstEvent * event);
static void
_extra_init (void)
{
QUARK_TSDEMUX = g_quark_from_string ("tsdemux");
QUARK_PID = g_quark_from_string ("pid");
QUARK_PCR = g_quark_from_string ("pcr");
QUARK_OPCR = g_quark_from_string ("opcr");
QUARK_PTS = g_quark_from_string ("pts");
QUARK_DTS = g_quark_from_string ("dts");
QUARK_OFFSET = g_quark_from_string ("offset");
}
#define gst_ts_demux_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstTSDemux, gst_ts_demux, GST_TYPE_MPEGTS_BASE,
_extra_init ());
static void
gst_ts_demux_class_init (GstTSDemuxClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
MpegTSBaseClass *ts_class;
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = gst_ts_demux_set_property;
gobject_class->get_property = gst_ts_demux_get_property;
gobject_class->finalize = gst_ts_demux_finalize;
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,
-1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_EMIT_STATS,
g_param_spec_boolean ("emit-stats", "Emit statistics",
"Emit messages for every pcr/opcr/pts/dts", FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
element_class = GST_ELEMENT_CLASS (klass);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&video_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&audio_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&subpicture_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&private_template));
gst_element_class_set_details_simple (element_class,
"MPEG transport stream demuxer",
"Codec/Demuxer",
"Demuxes MPEG2 transport streams",
"Zaheer Abbas Merali <zaheerabbas at merali dot org>\n"
"Edward Hervey <edward.hervey@collabora.co.uk>");
ts_class = GST_MPEGTS_BASE_CLASS (klass);
ts_class->reset = GST_DEBUG_FUNCPTR (gst_ts_demux_reset);
ts_class->push = GST_DEBUG_FUNCPTR (gst_ts_demux_push);
ts_class->push_event = GST_DEBUG_FUNCPTR (push_event);
ts_class->program_started = GST_DEBUG_FUNCPTR (gst_ts_demux_program_started);
ts_class->stream_added = gst_ts_demux_stream_added;
ts_class->stream_removed = gst_ts_demux_stream_removed;
ts_class->find_timestamps = GST_DEBUG_FUNCPTR (find_timestamps);
ts_class->seek = GST_DEBUG_FUNCPTR (gst_ts_demux_do_seek);
ts_class->flush = GST_DEBUG_FUNCPTR (gst_ts_demux_flush);
}
static void
gst_ts_demux_init (GstTSDemux * demux)
{
demux->need_newsegment = TRUE;
demux->program_number = -1;
demux->duration = GST_CLOCK_TIME_NONE;
demux->pts_delta = GST_CLOCK_TIME_NONE;
GST_MPEGTS_BASE (demux)->stream_size = sizeof (TSDemuxStream);
gst_segment_init (&demux->segment, GST_FORMAT_TIME);
demux->first_pcr = (TSPcrOffset) {
GST_CLOCK_TIME_NONE, 0, 0};
demux->cur_pcr = (TSPcrOffset) {
0};
demux->last_pcr = (TSPcrOffset) {
0};
}
static void
gst_ts_demux_reset (MpegTSBase * base)
{
GstTSDemux *demux = (GstTSDemux *) base;
if (demux->index) {
g_array_free (demux->index, TRUE);
demux->index = NULL;
}
demux->index_size = 0;
demux->need_newsegment = TRUE;
demux->program_number = -1;
demux->duration = GST_CLOCK_TIME_NONE;
demux->pts_delta = GST_CLOCK_TIME_NONE;
gst_segment_init (&demux->segment, GST_FORMAT_TIME);
demux->first_pcr = (TSPcrOffset) {
GST_CLOCK_TIME_NONE, 0, 0};
demux->cur_pcr = (TSPcrOffset) {
0};
demux->last_pcr = (TSPcrOffset) {
0};
}
static void
gst_ts_demux_finalize (GObject * object)
{
if (G_OBJECT_CLASS (parent_class)->finalize)
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_ts_demux_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstTSDemux *demux = GST_TS_DEMUX (object);
switch (prop_id) {
case PROP_PROGRAM_NUMBER:
/* FIXME: do something if program is switched as opposed to set at
* beginning */
demux->program_number = g_value_get_int (value);
break;
case PROP_EMIT_STATS:
demux->emit_statistics = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
gst_ts_demux_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstTSDemux *demux = GST_TS_DEMUX (object);
switch (prop_id) {
case PROP_PROGRAM_NUMBER:
g_value_set_int (value, demux->program_number);
break;
case PROP_EMIT_STATS:
g_value_set_boolean (value, demux->emit_statistics);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static gboolean
gst_ts_demux_srcpad_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
gboolean res = TRUE;
GstFormat format;
GstTSDemux *demux;
MpegTSBase *base;
demux = GST_TS_DEMUX (parent);
base = GST_MPEGTS_BASE (demux);
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:
GST_DEBUG ("query duration");
gst_query_parse_duration (query, &format, NULL);
if (format == GST_FORMAT_TIME) {
if (!gst_pad_peer_query (base->sinkpad, query))
gst_query_set_duration (query, GST_FORMAT_TIME,
demux->segment.duration);
} else {
GST_DEBUG_OBJECT (demux, "only query duration on TIME is supported");
res = FALSE;
}
break;
case GST_QUERY_LATENCY:
{
GST_DEBUG ("query latency");
res = gst_pad_peer_query (base->sinkpad, query);
if (res && base->upstream_live) {
GstClockTime min_lat, max_lat;
gboolean live;
/* According to H.222.0
Annex D.0.3 (System Time Clock recovery in the decoder)
and D.0.2 (Audio and video presentation synchronization)
We can end up with an interval of up to 700ms between valid
PCR/SCR. We therefore allow a latency of 700ms for that.
*/
gst_query_parse_latency (query, &live, &min_lat, &max_lat);
if (min_lat != -1)
min_lat += 700 * GST_MSECOND;
if (max_lat != -1)
max_lat += 700 * GST_MSECOND;
gst_query_set_latency (query, live, min_lat, max_lat);
}
}
break;
case GST_QUERY_SEEKING:
GST_DEBUG ("query seeking");
gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
if (format == GST_FORMAT_TIME) {
gboolean seekable = FALSE;
if (gst_pad_peer_query (base->sinkpad, query))
gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
/* If upstream is not seekable in TIME format we use
* our own values here */
if (!seekable)
gst_query_set_seeking (query, GST_FORMAT_TIME,
demux->parent.mode != BASE_MODE_PUSHING, 0,
demux->segment.duration);
} else {
GST_DEBUG_OBJECT (demux, "only TIME is supported for query seeking");
res = FALSE;
}
break;
default:
res = gst_pad_query_default (pad, parent, query);
}
return res;
}
static inline GstClockTime
calculate_gsttime (TSPcrOffset * start, guint64 pcr)
{
GstClockTime time = start->gsttime;
if (start->pcr > pcr)
time += PCRTIME_TO_GSTTIME (PCR_MAX_VALUE - start->pcr) +
PCRTIME_TO_GSTTIME (pcr);
else
time += PCRTIME_TO_GSTTIME (pcr - start->pcr);
return time;
}
static GstFlowReturn
gst_ts_demux_parse_pes_header_pts (GstTSDemux * demux,
MpegTSPacketizerPacket * packet, guint64 * time)
{
PESHeader header;
gint offset = 0;
if (mpegts_parse_pes_header (packet->payload,
packet->data_end - packet->payload, &header, &offset))
return GST_FLOW_ERROR;
*time = header.PTS;
return GST_FLOW_OK;
}
/* performs a accurate/key_unit seek */
static GstFlowReturn
gst_ts_demux_perform_auxiliary_seek (MpegTSBase * base, GstClockTime seektime,
TSPcrOffset * pcroffset, gint64 length, gint16 pid, GstSeekFlags flags,
payload_parse_keyframe auxiliary_seek_fn)
{
GstTSDemux *demux = (GstTSDemux *) base;
GstFlowReturn res = GST_FLOW_ERROR;
gboolean done = FALSE;
gboolean found_keyframe = FALSE, found_accurate = FALSE, need_more = TRUE;
GstBuffer *buf;
MpegTSPacketizerPacket packet;
MpegTSPacketizerPacketReturn pret;
gint64 offset = pcroffset->offset;
gint64 scan_offset = MIN (length, 50 * MPEGTS_MAX_PACKETSIZE);
guint32 state = 0xffffffff;
TSPcrOffset key_pos = { 0 };
GST_DEBUG ("auxiliary seek for %" GST_TIME_FORMAT " from offset: %"
G_GINT64_FORMAT " in %" G_GINT64_FORMAT " bytes for PID: %d "
"%s %s", GST_TIME_ARGS (seektime), pcroffset->offset, length, pid,
(flags & GST_SEEK_FLAG_ACCURATE) ? "accurate" : "",
(flags & GST_SEEK_FLAG_KEY_UNIT) ? "key_unit" : "");
mpegts_packetizer_flush (base->packetizer);
if (base->packetizer->packet_size == MPEGTS_M2TS_PACKETSIZE)
offset -= 4;
while (!done && scan_offset <= length) {
res =
gst_pad_pull_range (base->sinkpad, offset + scan_offset,
50 * MPEGTS_MAX_PACKETSIZE, &buf);
if (res != GST_FLOW_OK)
goto beach;
mpegts_packetizer_push (base->packetizer, buf);
while ((!done)
&& ((pret =
mpegts_packetizer_next_packet (base->packetizer,
&packet)) != PACKET_NEED_MORE)) {
if (G_UNLIKELY (pret == PACKET_BAD))
/* bad header, skip the packet */
goto next;
if (packet.payload_unit_start_indicator)
GST_DEBUG ("found packet for PID: %d with pcr: %" GST_TIME_FORMAT
" at offset: %" G_GINT64_FORMAT, packet.pid,
GST_TIME_ARGS (packet.pcr), packet.offset);
if (packet.payload != NULL && packet.pid == pid) {
if (packet.payload_unit_start_indicator) {
guint64 pts = 0;
GstFlowReturn ok =
gst_ts_demux_parse_pes_header_pts (demux, &packet, &pts);
if (ok == GST_FLOW_OK) {
GstClockTime time = calculate_gsttime (pcroffset, pts * 300);
GST_DEBUG ("packet has PTS: %" GST_TIME_FORMAT,
GST_TIME_ARGS (time));
if (time <= seektime) {
pcroffset->gsttime = time;
pcroffset->pcr = packet.pcr;
pcroffset->offset = packet.offset;
} else
found_accurate = TRUE;
} else
goto next;
/* reset state for new packet */
state = 0xffffffff;
need_more = TRUE;
}
if (auxiliary_seek_fn) {
if (need_more) {
if (auxiliary_seek_fn (&state, &packet, &need_more)) {
found_keyframe = TRUE;
key_pos = *pcroffset;
GST_DEBUG ("found keyframe: time: %" GST_TIME_FORMAT " pcr: %"
GST_TIME_FORMAT " offset %" G_GINT64_FORMAT,
GST_TIME_ARGS (pcroffset->gsttime),
GST_TIME_ARGS (pcroffset->pcr), pcroffset->offset);
}
}
} else {
/* if we don't have a payload parsing function
* every frame is a keyframe */
found_keyframe = TRUE;
}
}
if (flags & GST_SEEK_FLAG_ACCURATE)
done = found_accurate && found_keyframe;
else
done = found_keyframe;
if (done)
*pcroffset = key_pos;
next:
mpegts_packetizer_clear_packet (base->packetizer, &packet);
}
scan_offset += 50 * MPEGTS_MAX_PACKETSIZE;
}
beach:
if (done)
res = GST_FLOW_OK;
else if (GST_FLOW_OK == res)
res = GST_FLOW_CUSTOM_ERROR_1;
mpegts_packetizer_flush (base->packetizer);
return res;
}
static gint
TSPcrOffset_find (gconstpointer a, gconstpointer b, gpointer user_data)
{
/* GST_INFO ("a: %" GST_TIME_FORMAT " offset: %" G_GINT64_FORMAT, */
/* GST_TIME_ARGS (((TSPcrOffset *) a)->gsttime), ((TSPcrOffset *) a)->offset); */
/* GST_INFO ("b: %" GST_TIME_FORMAT " offset: %" G_GINT64_FORMAT, */
/* GST_TIME_ARGS (((TSPcrOffset *) b)->gsttime), ((TSPcrOffset *) b)->offset); */
if (((TSPcrOffset *) a)->gsttime < ((TSPcrOffset *) b)->gsttime)
return -1;
else if (((TSPcrOffset *) a)->gsttime > ((TSPcrOffset *) b)->gsttime)
return 1;
else
return 0;
}
static GstFlowReturn
gst_ts_demux_perform_seek (MpegTSBase * base, GstSegment * segment, guint16 pid)
{
GstTSDemux *demux = (GstTSDemux *) base;
GstFlowReturn res = GST_FLOW_ERROR;
int max_loop_cnt, loop_cnt = 0;
gint64 seekpos = 0;
gint64 time_diff;
GstClockTime seektime;
TSPcrOffset seekpcroffset, pcr_start, pcr_stop, *tmp;
max_loop_cnt = (segment->flags & GST_SEEK_FLAG_ACCURATE) ? 25 : 10;
seektime =
MAX (0, segment->stop - SEEK_TIMESTAMP_OFFSET) + demux->first_pcr.gsttime;
seekpcroffset.gsttime = seektime;
GST_DEBUG ("seeking to %" GST_TIME_FORMAT, GST_TIME_ARGS (seektime));
gst_ts_demux_flush_streams (demux);
if (G_UNLIKELY (!demux->index)) {
GST_ERROR ("no index");
goto done;
}
/* get the first index entry before the seek position */
tmp = gst_util_array_binary_search (demux->index->data, demux->index_size,
sizeof (*tmp), TSPcrOffset_find, GST_SEARCH_MODE_BEFORE, &seekpcroffset,
NULL);
if (G_UNLIKELY (!tmp)) {
GST_ERROR ("value not found");
goto done;
}
pcr_start = *tmp;
pcr_stop = *(++tmp);
if (G_UNLIKELY (!pcr_stop.offset)) {
GST_ERROR ("invalid entry");
goto done;
}
/* check if the last recorded pcr can be used */
if (pcr_start.offset < demux->cur_pcr.offset
&& demux->cur_pcr.offset < pcr_stop.offset) {
demux->cur_pcr.gsttime = calculate_gsttime (&pcr_start, demux->cur_pcr.pcr);
if (demux->cur_pcr.gsttime < seekpcroffset.gsttime)
pcr_start = demux->cur_pcr;
else
pcr_stop = demux->cur_pcr;
}
GST_DEBUG ("start %" GST_TIME_FORMAT " offset: %" G_GINT64_FORMAT,
GST_TIME_ARGS (pcr_start.gsttime), pcr_start.offset);
GST_DEBUG ("stop %" GST_TIME_FORMAT " offset: %" G_GINT64_FORMAT,
GST_TIME_ARGS (pcr_stop.gsttime), pcr_stop.offset);
time_diff = seektime - pcr_start.gsttime;
seekpcroffset = pcr_start;
GST_DEBUG ("cur %" GST_TIME_FORMAT " offset: %" G_GINT64_FORMAT
" time diff: %" G_GINT64_FORMAT,
GST_TIME_ARGS (demux->cur_pcr.gsttime), demux->cur_pcr.offset, time_diff);
/* seek loop */
while (loop_cnt++ < max_loop_cnt && (time_diff > SEEK_TIMESTAMP_OFFSET >> 1)
&& (pcr_stop.gsttime - pcr_start.gsttime > SEEK_TIMESTAMP_OFFSET)) {
gint64 duration = pcr_stop.gsttime - pcr_start.gsttime;
gint64 size = pcr_stop.offset - pcr_start.offset;
if (loop_cnt & 1)
seekpos = pcr_start.offset + (size >> 1);
else
seekpos =
pcr_start.offset + size * ((double) (seektime -
pcr_start.gsttime) / duration);
/* look a litle bit behind */
seekpos =
MAX (pcr_start.offset + 188, seekpos - 55 * MPEGTS_MAX_PACKETSIZE);
GST_DEBUG ("looking for time: %" GST_TIME_FORMAT " .. %" GST_TIME_FORMAT
" .. %" GST_TIME_FORMAT,
GST_TIME_ARGS (pcr_start.gsttime),
GST_TIME_ARGS (seektime), GST_TIME_ARGS (pcr_stop.gsttime));
GST_DEBUG ("looking in bytes: %" G_GINT64_FORMAT " .. %" G_GINT64_FORMAT
" .. %" G_GINT64_FORMAT, pcr_start.offset, seekpos, pcr_stop.offset);
res =
find_pcr_packet (&demux->parent, seekpos, 4000 * MPEGTS_MAX_PACKETSIZE,
&seekpcroffset);
if (G_UNLIKELY (res == GST_FLOW_EOS)) {
seekpos =
MAX ((gint64) pcr_start.offset,
seekpos - 2000 * MPEGTS_MAX_PACKETSIZE) + 188;
res =
find_pcr_packet (&demux->parent, seekpos,
8000 * MPEGTS_MAX_PACKETSIZE, &seekpcroffset);
}
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING ("seeking failed %s", gst_flow_get_name (res));
goto done;
}
seekpcroffset.gsttime = calculate_gsttime (&pcr_start, seekpcroffset.pcr);
/* validate */
if (G_UNLIKELY ((seekpcroffset.gsttime < pcr_start.gsttime) ||
(seekpcroffset.gsttime > pcr_stop.gsttime))) {
GST_ERROR ("Unexpected timestamp found, seeking failed! %"
GST_TIME_FORMAT, GST_TIME_ARGS (seekpcroffset.gsttime));
res = GST_FLOW_ERROR;
goto done;
}
if (seekpcroffset.gsttime > seektime) {
pcr_stop = seekpcroffset;
} else {
pcr_start = seekpcroffset;
}
time_diff = seektime - pcr_start.gsttime;
GST_DEBUG ("seeking: %" GST_TIME_FORMAT " found: %" GST_TIME_FORMAT
" diff = %" G_GINT64_FORMAT, GST_TIME_ARGS (seektime),
GST_TIME_ARGS (seekpcroffset.gsttime), time_diff);
}
GST_DEBUG ("seeking finished after %d loops", loop_cnt);
/* use correct seek position for the auxiliary search */
seektime += SEEK_TIMESTAMP_OFFSET;
{
payload_parse_keyframe keyframe_seek = NULL;
MpegTSBaseProgram *program = demux->program;
guint64 avg_bitrate, length;
if (program->streams[pid]) {
switch (program->streams[pid]->stream_type) {
case ST_VIDEO_MPEG1:
case ST_VIDEO_MPEG2:
keyframe_seek = gst_tsdemux_has_mpeg2_keyframe;
break;
case ST_VIDEO_H264:
keyframe_seek = gst_tsdemux_has_h264_keyframe;
break;
case ST_VIDEO_MPEG4:
case ST_VIDEO_DIRAC:
GST_WARNING ("no payload parser for stream 0x%04x type: 0x%02x", pid,
program->streams[pid]->stream_type);
break;
}
} else
GST_WARNING ("no stream info for PID: 0x%04x", pid);
avg_bitrate =
(pcr_stop.offset -
pcr_start.offset) * 1000 * GST_MSECOND / (pcr_stop.gsttime -
pcr_start.gsttime);
seekpcroffset = pcr_start;
/* search in 2500ms for a keyframe */
length =
MIN (demux->last_pcr.offset - pcr_start.offset,
(avg_bitrate * 25) / 10);
res =
gst_ts_demux_perform_auxiliary_seek (base, seektime, &seekpcroffset,
length, pid, segment->flags, keyframe_seek);
if (res == GST_FLOW_CUSTOM_ERROR_1) {
GST_ERROR ("no keyframe found in %" G_GUINT64_FORMAT
" bytes starting from %" G_GUINT64_FORMAT, length,
seekpcroffset.offset);
res = GST_FLOW_ERROR;
}
if (res != GST_FLOW_OK)
goto done;
}
/* update seektime to the actual timestamp of the found keyframe */
if (segment->flags & GST_SEEK_FLAG_KEY_UNIT)
seektime = seekpcroffset.gsttime;
seektime -= demux->first_pcr.gsttime;
#if 0
segment->last_stop = seektime;
#endif
segment->time = seektime;
/* we stop at the end */
if (segment->stop == -1)
segment->stop = demux->first_pcr.gsttime + segment->duration;
demux->need_newsegment = TRUE;
demux->parent.seek_offset = seekpcroffset.offset;
GST_DEBUG ("seeked to postion:%" GST_TIME_FORMAT, GST_TIME_ARGS (seektime));
res = GST_FLOW_OK;
done:
return res;
}
static GstFlowReturn
gst_ts_demux_do_seek (MpegTSBase * base, GstEvent * event, guint16 pid)
{
GstTSDemux *demux = (GstTSDemux *) base;
GstFlowReturn res = GST_FLOW_ERROR;
gdouble rate;
GstFormat format;
GstSeekFlags flags;
GstSeekType start_type, stop_type;
gint64 start, stop;
GstSegment seeksegment;
gboolean update;
gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
&stop_type, &stop);
if (format != GST_FORMAT_TIME) {
goto done;
}
GST_DEBUG ("seek event, rate: %f start: %" GST_TIME_FORMAT
" stop: %" GST_TIME_FORMAT, rate, GST_TIME_ARGS (start),
GST_TIME_ARGS (stop));
if (flags & (GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_SKIP)) {
GST_WARNING ("seek flags 0x%x are not supported", (int) flags);
goto done;
}
/* copy segment, we need this because we still need the old
* segment when we close the current segment. */
memcpy (&seeksegment, &demux->segment, sizeof (GstSegment));
/* configure the segment with the seek variables */
GST_DEBUG_OBJECT (demux, "configuring seek");
GST_DEBUG ("seeksegment: start: %" GST_TIME_FORMAT " stop: %"
GST_TIME_FORMAT " time: %" GST_TIME_FORMAT
" duration: %" GST_TIME_FORMAT,
GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (seeksegment.stop),
GST_TIME_ARGS (seeksegment.time), GST_TIME_ARGS (seeksegment.duration));
gst_segment_do_seek (&seeksegment, rate, format, flags, start_type, start,
stop_type, stop, &update);
GST_DEBUG ("seeksegment: start: %" GST_TIME_FORMAT " stop: %"
GST_TIME_FORMAT " time: %" GST_TIME_FORMAT
" duration: %" GST_TIME_FORMAT,
GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (seeksegment.stop),
GST_TIME_ARGS (seeksegment.time), GST_TIME_ARGS (seeksegment.duration));
res = gst_ts_demux_perform_seek (base, &seeksegment, pid);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING ("seeking failed %s", gst_flow_get_name (res));
goto done;
}
/* commit the new segment */
memcpy (&demux->segment, &seeksegment, sizeof (GstSegment));
if (demux->segment.flags & GST_SEEK_FLAG_SEGMENT) {
gst_element_post_message (GST_ELEMENT_CAST (demux),
gst_message_new_segment_start (GST_OBJECT_CAST (demux),
demux->segment.format, demux->segment.stop));
}
done:
return res;
}
static gboolean
gst_ts_demux_srcpad_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
gboolean res = TRUE;
GstTSDemux *demux = GST_TS_DEMUX (parent);
GST_DEBUG_OBJECT (pad, "Got event %s",
gst_event_type_get_name (GST_EVENT_TYPE (event)));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEEK:
res = mpegts_base_handle_seek_event ((MpegTSBase *) demux, pad, event);
if (!res)
GST_WARNING ("seeking failed");
gst_event_unref (event);
break;
default:
res = gst_pad_event_default (pad, parent, event);
}
return res;
}
static gboolean
push_event (MpegTSBase * base, GstEvent * event)
{
GstTSDemux *demux = (GstTSDemux *) base;
GList *tmp;
if (G_UNLIKELY (demux->program == NULL))
return FALSE;
for (tmp = demux->program->stream_list; tmp; tmp = tmp->next) {
TSDemuxStream *stream = (TSDemuxStream *) tmp->data;
if (stream->pad) {
gst_event_ref (event);
gst_pad_push_event (stream->pad, event);
}
}
gst_event_unref (event);
return TRUE;
}
static GstFlowReturn
tsdemux_combine_flows (GstTSDemux * demux, TSDemuxStream * stream,
GstFlowReturn ret)
{
GList *tmp;
/* Store the value */
stream->flow_return = ret;
/* 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 (tmp = demux->program->stream_list; tmp; tmp = tmp->next) {
stream = (TSDemuxStream *) tmp->data;
if (stream->pad) {
ret = stream->flow_return;
/* some other return value (must be SUCCESS but we can return
* other values as well) */
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 GstPad *
create_pad_for_stream (MpegTSBase * base, MpegTSBaseStream * bstream,
MpegTSBaseProgram * program)
{
TSDemuxStream *stream = (TSDemuxStream *) bstream;
gchar *name = NULL;
GstCaps *caps = NULL;
GstPadTemplate *template = NULL;
guint8 *desc = NULL;
GstPad *pad = NULL;
GST_LOG ("Attempting to create pad for stream 0x%04x with stream_type %d",
bstream->pid, bstream->stream_type);
switch (bstream->stream_type) {
case ST_VIDEO_MPEG1:
case ST_VIDEO_MPEG2:
GST_LOG ("mpeg video");
template = gst_static_pad_template_get (&video_template);
name = g_strdup_printf ("video_%04x", bstream->pid);
caps = gst_caps_new_simple ("video/mpeg",
"mpegversion", G_TYPE_INT,
bstream->stream_type == ST_VIDEO_MPEG1 ? 1 : 2, "systemstream",
G_TYPE_BOOLEAN, FALSE, NULL);
break;
case ST_AUDIO_MPEG1:
case ST_AUDIO_MPEG2:
GST_LOG ("mpeg audio");
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps =
gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 1,
NULL);
break;
case ST_PRIVATE_DATA:
GST_LOG ("private data");
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_DVB_AC3);
if (desc) {
GST_LOG ("ac3 audio");
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-ac3");
g_free (desc);
break;
}
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_DVB_ENHANCED_AC3);
if (desc) {
GST_LOG ("ac3 audio");
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-eac3");
g_free (desc);
break;
}
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_DVB_TELETEXT);
if (desc) {
GST_LOG ("teletext");
template = gst_static_pad_template_get (&private_template);
name = g_strdup_printf ("private_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("private/teletext");
g_free (desc);
break;
}
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_DVB_SUBTITLING);
if (desc) {
GST_LOG ("subtitling");
template = gst_static_pad_template_get (&private_template);
name = g_strdup_printf ("private_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("subpicture/x-dvb");
g_free (desc);
break;
}
/* hack for itv hd (sid 10510, video pid 3401 */
if (program->program_number == 10510 && bstream->pid == 3401) {
template = gst_static_pad_template_get (&video_template);
name = g_strdup_printf ("video_%04x", bstream->pid);
caps = gst_caps_new_simple ("video/x-h264",
"stream-format", G_TYPE_STRING, "byte-stream",
"alignment", G_TYPE_STRING, "nal", NULL);
}
break;
case ST_HDV_AUX_V:
/* We don't expose those streams since they're only helper streams */
/* template = gst_static_pad_template_get (&private_template); */
/* name = g_strdup_printf ("private_%04x", bstream->pid); */
/* caps = gst_caps_new_simple ("hdv/aux-v", NULL); */
break;
case ST_HDV_AUX_A:
/* We don't expose those streams since they're only helper streams */
/* template = gst_static_pad_template_get (&private_template); */
/* name = g_strdup_printf ("private_%04x", bstream->pid); */
/* caps = gst_caps_new_simple ("hdv/aux-a", NULL); */
break;
case ST_PRIVATE_SECTIONS:
case ST_MHEG:
case ST_DSMCC:
case ST_DSMCC_A:
case ST_DSMCC_B:
case ST_DSMCC_C:
case ST_DSMCC_D:
MPEGTS_BIT_UNSET (base->is_pes, bstream->pid);
break;
case ST_AUDIO_AAC:
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_simple ("audio/mpeg",
"mpegversion", G_TYPE_INT, 4, NULL);
break;
case ST_VIDEO_MPEG4:
template = gst_static_pad_template_get (&video_template);
name = g_strdup_printf ("video_%04x", bstream->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 = gst_static_pad_template_get (&video_template);
name = g_strdup_printf ("video_%04x", bstream->pid);
caps = gst_caps_new_simple ("video/x-h264",
"stream-format", G_TYPE_STRING, "byte-stream",
"alignment", G_TYPE_STRING, "nal", NULL);
break;
case ST_VIDEO_DIRAC:
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_REGISTRATION);
if (desc) {
if (DESC_LENGTH (desc) >= 4) {
if (DESC_REGISTRATION_format_identifier (desc) == 0x64726163) {
GST_LOG ("dirac");
/* dirac in hex */
template = gst_static_pad_template_get (&video_template);
name = g_strdup_printf ("video_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("video/x-dirac");
}
}
g_free (desc);
}
break;
case ST_PRIVATE_EA: /* Try to detect a VC1 stream */
{
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_REGISTRATION);
if (desc) {
if (DESC_LENGTH (desc) >= 4) {
if (DESC_REGISTRATION_format_identifier (desc) == DRF_ID_VC1) {
GST_WARNING ("0xea private stream type found but no descriptor "
"for VC1. Assuming plain VC1.");
template = gst_static_pad_template_get (&video_template);
name = g_strdup_printf ("video_%04x", bstream->pid);
caps = gst_caps_new_simple ("video/x-wmv",
"wmvversion", G_TYPE_INT, 3,
"format", G_TYPE_STRING, "WVC1", NULL);
}
}
g_free (desc);
}
break;
}
case ST_BD_AUDIO_AC3:
{
/* REGISTRATION DRF_ID_HDMV */
desc = mpegts_get_descriptor_from_program (program, DESC_REGISTRATION);
if (desc) {
if (DESC_REGISTRATION_format_identifier (desc) == DRF_ID_HDMV) {
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-eac3");
}
g_free (desc);
}
if (template)
break;
/* DVB_ENHANCED_AC3 */
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_DVB_ENHANCED_AC3);
if (desc) {
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-eac3");
g_free (desc);
break;
}
/* DVB_AC3 */
desc =
mpegts_get_descriptor_from_stream ((MpegTSBaseStream *) stream,
DESC_DVB_AC3);
if (!desc)
GST_WARNING ("AC3 stream type found but no corresponding "
"descriptor to differentiate between AC3 and EAC3. "
"Assuming plain AC3.");
else
g_free (desc);
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-ac3");
break;
}
case ST_BD_AUDIO_EAC3:
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-eac3");
break;
case ST_PS_AUDIO_DTS:
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-dts");
break;
case ST_PS_AUDIO_LPCM:
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-lpcm");
break;
case ST_BD_AUDIO_LPCM:
template = gst_static_pad_template_get (&audio_template);
name = g_strdup_printf ("audio_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("audio/x-private-ts-lpcm");
break;
case ST_PS_DVD_SUBPICTURE:
template = gst_static_pad_template_get (&subpicture_template);
name = g_strdup_printf ("subpicture_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("video/x-dvd-subpicture");
break;
case ST_BD_PGS_SUBPICTURE:
template = gst_static_pad_template_get (&subpicture_template);
name = g_strdup_printf ("subpicture_%04x", bstream->pid);
caps = gst_caps_new_empty_simple ("subpicture/x-pgs");
break;
default:
GST_WARNING ("Non-media stream (stream_type:0x%x). Not creating pad",
bstream->stream_type);
break;
}
if (template && name && caps) {
GST_LOG ("stream:%p creating pad with name %s and caps %s", stream, name,
gst_caps_to_string (caps));
pad = gst_pad_new_from_template (template, name);
gst_pad_set_active (pad, TRUE);
gst_pad_use_fixed_caps (pad);
gst_pad_set_caps (pad, caps);
gst_pad_set_query_function (pad, gst_ts_demux_srcpad_query);
gst_pad_set_event_function (pad, gst_ts_demux_srcpad_event);
}
if (name)
g_free (name);
if (template)
gst_object_unref (template);
if (caps)
gst_caps_unref (caps);
return pad;
}
static void
gst_ts_demux_stream_added (MpegTSBase * base, MpegTSBaseStream * bstream,
MpegTSBaseProgram * program)
{
TSDemuxStream *stream = (TSDemuxStream *) bstream;
if (!stream->pad) {
/* Create the pad */
if (bstream->stream_type != 0xff)
stream->pad = create_pad_for_stream (base, bstream, program);
stream->pts = GST_CLOCK_TIME_NONE;
stream->dts = GST_CLOCK_TIME_NONE;
stream->raw_pts = 0;
stream->raw_dts = 0;
stream->nb_pts_rollover = 0;
stream->nb_dts_rollover = 0;
}
stream->flow_return = GST_FLOW_OK;
}
static void
gst_ts_demux_stream_removed (MpegTSBase * base, MpegTSBaseStream * bstream)
{
GstTSDemux *demux = GST_TS_DEMUX (base);
TSDemuxStream *stream = (TSDemuxStream *) bstream;
if (stream->pad) {
if (gst_pad_is_active (stream->pad)) {
gboolean need_newsegment = demux->need_newsegment;
/* We must not send the newsegment when flushing the pending data
on the removed stream. We should only push it when the newly added
stream finishes parsing its PTS */
demux->need_newsegment = FALSE;
/* Flush out all data */
GST_DEBUG_OBJECT (stream->pad, "Flushing out pending data");
gst_ts_demux_push_pending_data ((GstTSDemux *) base, stream);
demux->need_newsegment = need_newsegment;
GST_DEBUG_OBJECT (stream->pad, "Pushing out EOS");
gst_pad_push_event (stream->pad, gst_event_new_eos ());
GST_DEBUG_OBJECT (stream->pad, "Deactivating and removing pad");
gst_pad_set_active (stream->pad, FALSE);
gst_element_remove_pad (GST_ELEMENT_CAST (base), stream->pad);
}
stream->pad = NULL;
}
stream->flow_return = GST_FLOW_NOT_LINKED;
}
static void
activate_pad_for_stream (GstTSDemux * tsdemux, TSDemuxStream * stream)
{
if (stream->pad) {
GST_DEBUG_OBJECT (tsdemux, "Activating pad %s:%s for stream %p",
GST_DEBUG_PAD_NAME (stream->pad), stream);
gst_element_add_pad ((GstElement *) tsdemux, stream->pad);
GST_DEBUG_OBJECT (stream->pad, "done adding pad");
} else
GST_WARNING_OBJECT (tsdemux,
"stream %p (pid 0x%04x, type:0x%03x) has no pad", stream,
((MpegTSBaseStream *) stream)->pid,
((MpegTSBaseStream *) stream)->stream_type);
}
static void
gst_ts_demux_stream_flush (TSDemuxStream * stream)
{
gint i;
stream->pts = GST_CLOCK_TIME_NONE;
for (i = 0; i < stream->nbpending; i++)
gst_buffer_unref (stream->pendingbuffers[i]);
memset (stream->pendingbuffers, 0, TS_MAX_PENDING_BUFFERS);
stream->nbpending = 0;
}
static void
gst_ts_demux_flush_streams (GstTSDemux * demux)
{
g_list_foreach (demux->program->stream_list,
(GFunc) gst_ts_demux_stream_flush, NULL);
}
static void
gst_ts_demux_program_started (MpegTSBase * base, MpegTSBaseProgram * program)
{
GstTSDemux *demux = GST_TS_DEMUX (base);
GST_DEBUG ("Current program %d, new program %d",
demux->program_number, program->program_number);
if (demux->program_number == -1 ||
demux->program_number == program->program_number) {
GList *tmp;
GST_LOG ("program %d started", program->program_number);
demux->program_number = program->program_number;
demux->program = program;
/* Activate all stream pads, pads will already have been created */
if (base->mode != BASE_MODE_SCANNING) {
for (tmp = program->stream_list; tmp; tmp = tmp->next)
activate_pad_for_stream (demux, (TSDemuxStream *) tmp->data);
gst_element_no_more_pads ((GstElement *) demux);
}
/* Inform scanner we have got our program */
demux->current_program_number = program->program_number;
demux->need_newsegment = TRUE;
}
}
static gboolean
process_section (MpegTSBase * base)
{
GstTSDemux *demux = GST_TS_DEMUX (base);
gboolean based;
gboolean done = FALSE;
MpegTSPacketizerPacket packet;
MpegTSPacketizerPacketReturn pret;
while ((!done)
&& ((pret =
mpegts_packetizer_next_packet (base->packetizer,
&packet)) != PACKET_NEED_MORE)) {
if (G_UNLIKELY (pret == PACKET_BAD))
/* bad header, skip the packet */
goto next;
/* base PSI data */
if (packet.payload != NULL && mpegts_base_is_psi (base, &packet)) {
MpegTSPacketizerSection section;
based =
mpegts_packetizer_push_section (base->packetizer, &packet, &section);
if (G_UNLIKELY (!based))
/* bad section data */
goto next;
if (G_LIKELY (section.complete)) {
/* section complete */
GST_DEBUG ("Section Complete");
based = mpegts_base_handle_psi (base, &section);
gst_buffer_unref (section.buffer);
if (G_UNLIKELY (!based))
/* bad PSI table */
goto next;
}
if (demux->program != NULL) {
GST_DEBUG ("Got Program");
done = TRUE;
}
}
next:
mpegts_packetizer_clear_packet (base->packetizer, &packet);
}
return done;
}
static gboolean
process_pes (MpegTSBase * base, TSPcrOffset * pcroffset)
{
gboolean based, done = FALSE;
MpegTSPacketizerPacket packet;
MpegTSPacketizerPacketReturn pret;
GstTSDemux *demux = GST_TS_DEMUX (base);
guint16 pcr_pid = 0;
while ((!done)
&& ((pret =
mpegts_packetizer_next_packet (base->packetizer,
&packet)) != PACKET_NEED_MORE)) {
if (G_UNLIKELY (pret == PACKET_BAD))
/* bad header, skip the packet */
goto next;
if (demux->program != NULL) {
pcr_pid = demux->program->pcr_pid;
}
/* base PSI data */
if (packet.payload != NULL && mpegts_base_is_psi (base, &packet)) {
MpegTSPacketizerSection section;
based =
mpegts_packetizer_push_section (base->packetizer, &packet, &section);
if (G_UNLIKELY (!based))
/* bad section data */
goto next;
if (G_LIKELY (section.complete)) {
/* section complete */
GST_DEBUG ("Section Complete");
based = mpegts_base_handle_psi (base, &section);
gst_buffer_unref (section.buffer);
if (G_UNLIKELY (!based))
/* bad PSI table */
goto next;
}
}
if (packet.pid == pcr_pid && (packet.adaptation_field_control & 0x02)
&& (packet.afc_flags & MPEGTS_AFC_PCR_FLAG)) {
GST_DEBUG ("PCR[0x%x]: %" G_GINT64_FORMAT, packet.pid, packet.pcr);
pcroffset->pcr = packet.pcr;
pcroffset->offset = packet.offset;
done = TRUE;
}
next:
mpegts_packetizer_clear_packet (base->packetizer, &packet);
}
return done;
}
static GstFlowReturn
find_pcr_packet (MpegTSBase * base, guint64 offset, gint64 length,
TSPcrOffset * pcroffset)
{
GstFlowReturn ret = GST_FLOW_OK;
GstTSDemux *demux = GST_TS_DEMUX (base);
MpegTSBaseProgram *program;
GstBuffer *buf;
gboolean done = FALSE;
guint64 scan_offset = 0;
GST_DEBUG ("Scanning for PCR between:%" G_GINT64_FORMAT
" and the end:%" G_GINT64_FORMAT, offset, offset + length);
/* Get the program */
program = demux->program;
if (G_UNLIKELY (program == NULL))
return GST_FLOW_ERROR;
mpegts_packetizer_flush (base->packetizer);
if (offset >= 4 && base->packetizer->packet_size == MPEGTS_M2TS_PACKETSIZE)
offset -= 4;
while (!done && scan_offset < length) {
ret =
gst_pad_pull_range (base->sinkpad, offset + scan_offset,
50 * MPEGTS_MAX_PACKETSIZE, &buf);
if (ret != GST_FLOW_OK)
goto beach;
mpegts_packetizer_push (base->packetizer, buf);
done = process_pes (base, pcroffset);
scan_offset += 50 * MPEGTS_MAX_PACKETSIZE;
}
if (!done || scan_offset >= length) {
GST_WARNING ("No PCR found!");
ret = GST_FLOW_ERROR;
goto beach;
}
beach:
mpegts_packetizer_flush (base->packetizer);
return ret;
}
static gboolean
verify_timestamps (MpegTSBase * base, TSPcrOffset * first, TSPcrOffset * last)
{
GstTSDemux *demux = GST_TS_DEMUX (base);
guint64 length = 4000 * MPEGTS_MAX_PACKETSIZE;
guint64 offset = PCR_WRAP_SIZE_128KBPS;
demux->index =
g_array_sized_new (TRUE, TRUE, sizeof (*first),
2 + 1 + ((last->offset - first->offset) / PCR_WRAP_SIZE_128KBPS));
first->gsttime = PCRTIME_TO_GSTTIME (first->pcr);
demux->index = g_array_append_val (demux->index, *first);
demux->index_size++;
demux->first_pcr = *first;
demux->index_pcr = *first;
GST_DEBUG ("first time: %" GST_TIME_FORMAT " pcr: %" GST_TIME_FORMAT
" offset: %" G_GINT64_FORMAT
" last pcr: %" GST_TIME_FORMAT " offset: %" G_GINT64_FORMAT,
GST_TIME_ARGS (first->gsttime),
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (first->pcr)), first->offset,
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (last->pcr)), last->offset);
while (offset + length < last->offset) {
TSPcrOffset half;
GstFlowReturn ret;
gint tries = 0;
retry:
ret = find_pcr_packet (base, offset, length, &half);
if (G_UNLIKELY (ret != GST_FLOW_OK)) {
GST_WARNING ("no pcr found, retrying");
if (tries++ < 3) {
offset += length;
length *= 2;
goto retry;
}
return FALSE;
}
half.gsttime = calculate_gsttime (first, half.pcr);
GST_DEBUG ("add half time: %" GST_TIME_FORMAT " pcr: %" GST_TIME_FORMAT
" offset: %" G_GINT64_FORMAT,
GST_TIME_ARGS (half.gsttime),
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (half.pcr)), half.offset);
demux->index = g_array_append_val (demux->index, half);
demux->index_size++;
length = 4000 * MPEGTS_MAX_PACKETSIZE;
offset += PCR_WRAP_SIZE_128KBPS;
*first = half;
}
last->gsttime = calculate_gsttime (first, last->pcr);
GST_DEBUG ("add last time: %" GST_TIME_FORMAT " pcr: %" GST_TIME_FORMAT
" offset: %" G_GINT64_FORMAT,
GST_TIME_ARGS (last->gsttime),
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (last->pcr)), last->offset);
demux->index = g_array_append_val (demux->index, *last);
demux->index_size++;
demux->last_pcr = *last;
return TRUE;
}
static GstFlowReturn
find_timestamps (MpegTSBase * base, guint64 initoff, guint64 * offset)
{
GstFlowReturn ret = GST_FLOW_OK;
GstBuffer *buf;
gboolean done = FALSE;
gint64 total_bytes;
guint64 scan_offset;
guint i = 0;
TSPcrOffset initial, final;
GstTSDemux *demux = GST_TS_DEMUX (base);
GST_DEBUG ("Scanning for timestamps");
/* Flush what remained from before */
mpegts_packetizer_clear (base->packetizer);
/* Start scanning from know PAT offset */
while (!done) {
ret =
gst_pad_pull_range (base->sinkpad, i * 50 * MPEGTS_MAX_PACKETSIZE,
50 * MPEGTS_MAX_PACKETSIZE, &buf);
if (ret != GST_FLOW_OK)
goto beach;
mpegts_packetizer_push (base->packetizer, buf);
done = process_section (base);
i++;
}
mpegts_packetizer_clear (base->packetizer);
done = FALSE;
i = 1;
*offset = base->seek_offset;
/* Search for the first PCRs */
ret = process_pcr (base, base->first_pat_offset, &initial, 10, TRUE);
if (ret != GST_FLOW_OK && ret != GST_FLOW_EOS) {
GST_WARNING ("Problem getting initial PCRs");
goto beach;
}
mpegts_packetizer_clear (base->packetizer);
/* Remove current program so we ensure looking for a PAT when scanning the
* for the final PCR */
gst_structure_free (base->pat);
base->pat = NULL;
mpegts_base_remove_program (base, demux->current_program_number);
demux->program = NULL;
/* Find end position */
if (G_UNLIKELY (!gst_pad_peer_query_duration (base->sinkpad, GST_FORMAT_BYTES,
&total_bytes))) {
GST_WARNING_OBJECT (base, "Couldn't get upstream size in bytes");
ret = GST_FLOW_ERROR;
mpegts_packetizer_clear (base->packetizer);
return ret;
}
GST_DEBUG ("Upstream is %" G_GINT64_FORMAT " bytes", total_bytes);
/* Let's start scanning 4000 packets from the end */
scan_offset = MAX (188, total_bytes - 4000 * MPEGTS_MAX_PACKETSIZE);
GST_DEBUG ("Scanning for last sync point between:%" G_GINT64_FORMAT
" and the end:%" G_GINT64_FORMAT, scan_offset, total_bytes);
while ((!done) && (scan_offset < total_bytes)) {
ret =
gst_pad_pull_range (base->sinkpad,
scan_offset, 50 * MPEGTS_MAX_PACKETSIZE, &buf);
if (ret != GST_FLOW_OK)
goto beach;
mpegts_packetizer_push (base->packetizer, buf);
done = process_section (base);
scan_offset += 50 * MPEGTS_MAX_PACKETSIZE;
}
mpegts_packetizer_clear (base->packetizer);
GST_DEBUG ("Searching PCR");
ret =
process_pcr (base, scan_offset - 50 * MPEGTS_MAX_PACKETSIZE, &final, 10,
FALSE);
if (ret != GST_FLOW_OK) {
GST_DEBUG ("Problem getting last PCRs");
goto beach;
}
verify_timestamps (base, &initial, &final);
demux->duration = demux->segment.duration =
demux->last_pcr.gsttime - demux->first_pcr.gsttime;
GST_DEBUG ("Done, duration:%" GST_TIME_FORMAT,
GST_TIME_ARGS (demux->duration));
beach:
mpegts_packetizer_clear (base->packetizer);
/* Remove current program */
if (base->pat) {
gst_structure_free (base->pat);
base->pat = NULL;
}
mpegts_base_remove_program (base, demux->current_program_number);
demux->program = NULL;
return ret;
}
static GstFlowReturn
process_pcr (MpegTSBase * base, guint64 initoff, TSPcrOffset * pcroffset,
guint numpcr, gboolean isinitial)
{
GstTSDemux *demux = GST_TS_DEMUX (base);
GstFlowReturn ret = GST_FLOW_OK;
MpegTSBaseProgram *program;
GstBuffer *buf;
guint nbpcr, i = 0;
guint32 pcrmask, pcrpattern;
guint64 pcrs[50];
guint64 pcroffs[50];
GstByteReader br;
GST_DEBUG ("initoff:%" G_GUINT64_FORMAT ", numpcr:%d, isinitial:%d",
initoff, numpcr, isinitial);
/* Get the program */
program = demux->program;
if (G_UNLIKELY (program == NULL))
return GST_FLOW_ERROR;
/* First find the first X PCR */
nbpcr = 0;
/* Mask/pattern is PID:PCR_PID, AFC&0x02 */
/* sync_byte (0x47) : 8bits => 0xff
* transport_error_indicator : 1bit ACTIVATE
* payload_unit_start_indicator : 1bit IGNORE
* transport_priority : 1bit IGNORE
* PID : 13bit => 0x9f 0xff
* transport_scrambling_control : 2bit
* adaptation_field_control : 2bit
* continuity_counter : 4bit => 0x30
*/
pcrmask = 0xff9fff20;
pcrpattern = 0x47000020 | ((program->pcr_pid & 0x1fff) << 8);
for (i = 0; (i < 20) && (nbpcr < numpcr); i++) {
guint offset;
GstMapInfo map;
gsize size;
ret =
gst_pad_pull_range (base->sinkpad,
initoff + i * 500 * base->packetsize, 500 * base->packetsize, &buf);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto beach;
gst_buffer_map (buf, &map, GST_MAP_READ);
size = map.size;
gst_byte_reader_init (&br, map.data, map.size);
offset = 0;
resync:
offset = gst_byte_reader_masked_scan_uint32 (&br, 0xff000000, 0x47000000,
0, base->packetsize);
if (offset == -1) {
gst_buffer_unmap (buf, &map);
continue;
}
while ((nbpcr < numpcr) && (size >= base->packetsize)) {
guint32 header = GST_READ_UINT32_BE (br.data + offset);
if ((header >> 24) != 0x47)
goto resync;
if ((header & pcrmask) != pcrpattern) {
/* Move offset forward by 1 packet */
size -= base->packetsize;
offset += base->packetsize;
continue;
}
/* Potential PCR */
/* GST_DEBUG ("offset %" G_GUINT64_FORMAT, GST_BUFFER_OFFSET (buf) + offset);
GST_MEMDUMP ("something", GST_BUFFER_DATA (buf) + offset, 16);*/
if ((*(br.data + offset + 5)) & MPEGTS_AFC_PCR_FLAG) {
guint64 lpcr = mpegts_packetizer_compute_pcr (br.data + offset + 6);
GST_INFO ("Found PCR %" G_GUINT64_FORMAT " %" GST_TIME_FORMAT
" at offset %" G_GUINT64_FORMAT, lpcr,
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (lpcr)),
GST_BUFFER_OFFSET (buf) + offset);
pcrs[nbpcr] = lpcr;
pcroffs[nbpcr] = GST_BUFFER_OFFSET (buf) + offset;
/* Safeguard against bogus PCR (by detecting if it's the same as the
* previous one or wheter the difference with the previous one is
* greater than 10mins */
if (nbpcr > 1) {
if (pcrs[nbpcr] == pcrs[nbpcr - 1]) {
GST_WARNING ("Found same PCR at different offset");
} else if (pcrs[nbpcr] < pcrs[nbpcr - 1]) {
GST_WARNING ("Found PCR wraparound");
nbpcr += 1;
} else if ((pcrs[nbpcr] - pcrs[nbpcr - 1]) >
(guint64) 10 * 60 * 27000000) {
GST_WARNING ("PCR differs with previous PCR by more than 10 mins");
} else
nbpcr += 1;
} else
nbpcr += 1;
}
/* Move offset forward by 1 packet */
size -= base->packetsize;
offset += base->packetsize;
}
gst_buffer_unmap (buf, &map);
}
beach:
GST_DEBUG ("Found %d PCR", nbpcr);
if (nbpcr) {
if (isinitial) {
pcroffset->pcr = pcrs[0];
pcroffset->offset = pcroffs[0];
} else {
pcroffset->pcr = pcrs[nbpcr - 1];
pcroffset->offset = pcroffs[nbpcr - 1];
}
if (nbpcr > 1) {
GST_DEBUG ("pcrdiff:%" GST_TIME_FORMAT " offsetdiff %" G_GUINT64_FORMAT,
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (pcrs[nbpcr - 1] - pcrs[0])),
pcroffs[nbpcr - 1] - pcroffs[0]);
GST_DEBUG ("Estimated bitrate %" G_GUINT64_FORMAT,
gst_util_uint64_scale (GST_SECOND, pcroffs[nbpcr - 1] - pcroffs[0],
PCRTIME_TO_GSTTIME (pcrs[nbpcr - 1] - pcrs[0])));
GST_DEBUG ("Average PCR interval %" G_GUINT64_FORMAT,
(pcroffs[nbpcr - 1] - pcroffs[0]) / nbpcr);
}
}
/* Swallow any errors if it happened during the end scanning */
if (!isinitial)
ret = GST_FLOW_OK;
return ret;
}
static inline void
gst_ts_demux_record_pcr (GstTSDemux * demux, TSDemuxStream * stream,
guint64 pcr, guint64 offset)
{
MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
GST_LOG ("pid 0x%04x pcr:%" GST_TIME_FORMAT " at offset %"
G_GUINT64_FORMAT, bs->pid,
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (pcr)), offset);
if (G_LIKELY (bs->pid == demux->program->pcr_pid)) {
demux->cur_pcr.gsttime = GST_CLOCK_TIME_NONE;
demux->cur_pcr.offset = offset;
demux->cur_pcr.pcr = pcr;
/* set first_pcr in push mode */
if (G_UNLIKELY (!demux->first_pcr.gsttime == GST_CLOCK_TIME_NONE)) {
demux->first_pcr.gsttime = PCRTIME_TO_GSTTIME (pcr);
demux->first_pcr.offset = offset;
demux->first_pcr.pcr = pcr;
}
}
if (G_UNLIKELY (demux->emit_statistics)) {
GstStructure *st;
st = gst_structure_new_id_empty (QUARK_TSDEMUX);
gst_structure_id_set (st,
QUARK_PID, G_TYPE_UINT, bs->pid,
QUARK_OFFSET, G_TYPE_UINT64, offset, QUARK_PCR, G_TYPE_UINT64, pcr,
NULL);
gst_element_post_message (GST_ELEMENT_CAST (demux),
gst_message_new_element (GST_OBJECT (demux), st));
}
}
static inline void
gst_ts_demux_record_opcr (GstTSDemux * demux, TSDemuxStream * stream,
guint64 opcr, guint64 offset)
{
MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
GST_LOG ("pid 0x%04x opcr:%" GST_TIME_FORMAT " at offset %"
G_GUINT64_FORMAT, bs->pid,
GST_TIME_ARGS (PCRTIME_TO_GSTTIME (opcr)), offset);
if (G_UNLIKELY (demux->emit_statistics)) {
GstStructure *st;
st = gst_structure_new_id_empty (QUARK_TSDEMUX);
gst_structure_id_set (st,
QUARK_PID, G_TYPE_UINT, bs->pid,
QUARK_OFFSET, G_TYPE_UINT64, offset,
QUARK_OPCR, G_TYPE_UINT64, opcr, NULL);
gst_element_post_message (GST_ELEMENT_CAST (demux),
gst_message_new_element (GST_OBJECT (demux), st));
}
}
static inline void
gst_ts_demux_record_pts (GstTSDemux * demux, TSDemuxStream * stream,
guint64 pts, guint64 offset)
{
MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
GST_LOG ("pid 0x%04x pts:%" G_GUINT64_FORMAT " at offset %"
G_GUINT64_FORMAT, bs->pid, pts, offset);
if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (stream->pts) &&
ABSDIFF (stream->raw_pts, pts) > 900000)) {
/* Detect rollover if diff > 10s */
GST_LOG ("Detected rollover (previous:%" G_GUINT64_FORMAT " new:%"
G_GUINT64_FORMAT ")", stream->raw_pts, pts);
if (pts < stream->raw_pts) {
/* Forward rollover */
GST_LOG ("Forward rollover, incrementing nb_pts_rollover");
stream->nb_pts_rollover++;
} else {
/* Reverse rollover */
GST_LOG ("Reverse rollover, decrementing nb_pts_rollover");
stream->nb_pts_rollover--;
}
}
/* Compute PTS in GstClockTime */
stream->raw_pts = pts;
stream->pts =
MPEGTIME_TO_GSTTIME (pts + stream->nb_pts_rollover * PTS_DTS_MAX_VALUE);
GST_LOG ("pid 0x%04x Stored PTS %" G_GUINT64_FORMAT " (%" GST_TIME_FORMAT ")",
bs->pid, stream->raw_pts, GST_TIME_ARGS (stream->pts));
if (G_UNLIKELY (demux->emit_statistics)) {
GstStructure *st;
st = gst_structure_new_id_empty (QUARK_TSDEMUX);
gst_structure_id_set (st,
QUARK_PID, G_TYPE_UINT, bs->pid,
QUARK_OFFSET, G_TYPE_UINT64, offset, QUARK_PTS, G_TYPE_UINT64, pts,
NULL);
gst_element_post_message (GST_ELEMENT_CAST (demux),
gst_message_new_element (GST_OBJECT (demux), st));
}
}
static inline void
gst_ts_demux_record_dts (GstTSDemux * demux, TSDemuxStream * stream,
guint64 dts, guint64 offset)
{
MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
GST_LOG ("pid 0x%04x dts:%" G_GUINT64_FORMAT " at offset %"
G_GUINT64_FORMAT, bs->pid, dts, offset);
if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (stream->dts) &&
ABSDIFF (stream->raw_dts, dts) > 900000)) {
/* Detect rollover if diff > 10s */
GST_LOG ("Detected rollover (previous:%" G_GUINT64_FORMAT " new:%"
G_GUINT64_FORMAT ")", stream->raw_dts, dts);
if (dts < stream->raw_dts) {
/* Forward rollover */
GST_LOG ("Forward rollover, incrementing nb_dts_rollover");
stream->nb_dts_rollover++;
} else {
/* Reverse rollover */
GST_LOG ("Reverse rollover, decrementing nb_dts_rollover");
stream->nb_dts_rollover--;
}
}
/* Compute DTS in GstClockTime */
stream->raw_dts = dts;
stream->dts =
MPEGTIME_TO_GSTTIME (dts + stream->nb_dts_rollover * PTS_DTS_MAX_VALUE);
GST_LOG ("pid 0x%04x Stored DTS %" G_GUINT64_FORMAT " (%" GST_TIME_FORMAT ")",
bs->pid, stream->raw_dts, GST_TIME_ARGS (stream->dts));
if (G_UNLIKELY (demux->emit_statistics)) {
GstStructure *st;
st = gst_structure_new_id_empty (QUARK_TSDEMUX);
gst_structure_id_set (st,
QUARK_PID, G_TYPE_UINT, bs->pid,
QUARK_OFFSET, G_TYPE_UINT64, offset, QUARK_DTS, G_TYPE_UINT64, dts,
NULL);
gst_element_post_message (GST_ELEMENT_CAST (demux),
gst_message_new_element (GST_OBJECT (demux), st));
}
}
static inline GstClockTime
calc_gsttime_from_pts (TSPcrOffset * start, guint64 pts)
{
GstClockTime time = start->gsttime - PCRTIME_TO_GSTTIME (start->pcr);
if (start->pcr > pts * 300)
time += PCRTIME_TO_GSTTIME (PCR_MAX_VALUE) + MPEGTIME_TO_GSTTIME (pts);
else
time += MPEGTIME_TO_GSTTIME (pts);
return time;
}
#if 0
static gint
TSPcrOffset_find_offset (gconstpointer a, gconstpointer b, gpointer user_data)
{
if (((TSPcrOffset *) a)->offset < ((TSPcrOffset *) b)->offset)
return -1;
else if (((TSPcrOffset *) a)->offset > ((TSPcrOffset *) b)->offset)
return 1;
else
return 0;
}
#endif
static GstFlowReturn
gst_ts_demux_parse_pes_header (GstTSDemux * demux, TSDemuxStream * stream)
{
MpegTSBase *base = (MpegTSBase *) demux;
PESHeader header;
GstBuffer *buf = stream->pendingbuffers[0];
GstFlowReturn res = GST_FLOW_OK;
gint offset = 0;
GstMapInfo map;
guint64 bufferoffset;
PESParsingResult parseres;
GstClockTime origts;
gst_buffer_map (buf, &map, GST_MAP_READ);
bufferoffset = GST_BUFFER_OFFSET (buf);
origts = GST_BUFFER_TIMESTAMP (buf);
GST_MEMDUMP ("Header buffer", map.data, MIN (map.size, 32));
parseres = mpegts_parse_pes_header (map.data, map.size, &header, &offset);
if (G_UNLIKELY (parseres == PES_PARSING_NEED_MORE))
goto discont;
if (G_UNLIKELY (parseres == PES_PARSING_BAD)) {
GST_WARNING ("Error parsing PES header. pid: 0x%x stream_type: 0x%x",
stream->stream.pid, stream->stream.stream_type);
goto discont;
}
if (header.DTS != -1)
gst_ts_demux_record_dts (demux, stream, header.DTS, bufferoffset);
if (header.PTS != -1) {
gst_ts_demux_record_pts (demux, stream, header.PTS, bufferoffset);
#if 0
/* WTH IS THIS ??? */
if (demux->index_pcr.offset + PCR_WRAP_SIZE_128KBPS + 1000 * 128 < offset
|| (demux->index_pcr.offset > offset)) {
/* find next entry */
TSPcrOffset *next;
demux->index_pcr.offset = offset;
next = gst_util_array_binary_search (demux->index->data,
demux->index_size, sizeof (*next), TSPcrOffset_find_offset,
GST_SEARCH_MODE_BEFORE, &demux->index_pcr, NULL);
if (next) {
GST_INFO ("new index_pcr %" GST_TIME_FORMAT " offset: %"
G_GINT64_FORMAT, GST_TIME_ARGS (next->gsttime), next->offset);
demux->index_pcr = *next;
}
}
time = calc_gsttime_from_pts (&demux->index_pcr, pts);
#endif
GST_DEBUG_OBJECT (base,
"stream PTS %" GST_TIME_FORMAT " DTS %" GST_TIME_FORMAT,
GST_TIME_ARGS (stream->pts),
GST_TIME_ARGS (MPEGTIME_TO_GSTTIME (header.DTS)));
/* FIXME : This will only work if the PES header is contained
* at the beginning of an incoming GstBuffer */
/* FIXME : Handle wrap-around ? */
if (base->upstream_live && GST_CLOCK_TIME_IS_VALID (origts)
&& !GST_CLOCK_TIME_IS_VALID (demux->pts_delta)) {
if (GST_CLOCK_TIME_IS_VALID (MPEGTIME_TO_GSTTIME (header.DTS)))
demux->pts_delta = MPEGTIME_TO_GSTTIME (header.DTS) - origts;
else
demux->pts_delta = stream->pts - origts;
GST_DEBUG_OBJECT (base, "buffer timestamp %" GST_TIME_FORMAT,
GST_TIME_ARGS (origts));
GST_DEBUG_OBJECT (base, "delta %" GST_TIME_FORMAT,
GST_TIME_ARGS (demux->pts_delta));
}
/* safe default if insufficient upstream info */
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (base->in_gap) &&
GST_CLOCK_TIME_IS_VALID (base->first_buf_ts) &&
base->mode == BASE_MODE_PUSHING &&
base->segment.format == GST_FORMAT_TIME)) {
/* Find the earliest current PTS we're going to push */
GstClockTime firstpts = GST_CLOCK_TIME_NONE;
GList *tmp;
for (tmp = demux->program->stream_list; tmp; tmp = tmp->next) {
TSDemuxStream *pstream = (TSDemuxStream *) tmp->data;
if (!GST_CLOCK_TIME_IS_VALID (firstpts) || pstream->pts < firstpts)
firstpts = pstream->pts;
}
base->in_gap = base->first_buf_ts - firstpts;
GST_DEBUG_OBJECT (base, "upstream segment start %" GST_TIME_FORMAT
", first buffer timestamp: %" GST_TIME_FORMAT
", first PTS: %" GST_TIME_FORMAT
", interpolation gap: %" GST_TIME_FORMAT,
GST_TIME_ARGS (base->segment.start),
GST_TIME_ARGS (base->first_buf_ts), GST_TIME_ARGS (firstpts),
GST_TIME_ARGS (base->in_gap));
}
if (!GST_CLOCK_TIME_IS_VALID (base->in_gap))
base->in_gap = 0;
if (base->upstream_live) {
if (GST_CLOCK_TIME_IS_VALID (demux->pts_delta))
GST_BUFFER_TIMESTAMP (buf) = stream->pts - demux->pts_delta;
else
GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
} else
GST_BUFFER_TIMESTAMP (buf) = stream->pts + base->in_gap;
GST_DEBUG ("buf %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
}
if (header.DTS != -1)
gst_ts_demux_record_dts (demux, stream, header.DTS, bufferoffset);
gst_buffer_unmap (buf, &map);
/* Remove PES headers */
GST_DEBUG ("Moving data forward by %d bytes", header.header_size);
gst_buffer_resize (buf, header.header_size, map.size - header.header_size);
/* FIXME : responsible for switching to PENDING_PACKET_BUFFER and
* creating the bufferlist */
if (1) {
/* Append to the buffer list */
if (G_UNLIKELY (stream->currentlist == NULL)) {
guint8 i;
/* Push pending buffers into the list */
for (i = stream->nbpending; i; i--)
stream->currentlist =
g_list_prepend (stream->currentlist, stream->pendingbuffers[i - 1]);
memset (stream->pendingbuffers, 0, TS_MAX_PENDING_BUFFERS);
stream->nbpending = 0;
}
stream->state = PENDING_PACKET_BUFFER;
}
return res;
discont:
stream->state = PENDING_PACKET_DISCONT;
return res;
}
/* ONLY CALL THIS:
* * WITH packet->payload != NULL
* * WITH pending/current flushed out if beginning of new PES packet
*/
static inline void
gst_ts_demux_queue_data (GstTSDemux * demux, TSDemuxStream * stream,
MpegTSPacketizerPacket * packet)
{
GstBuffer *buf;
GstMapInfo map;
GST_DEBUG ("state:%d", stream->state);
buf = packet->buffer;
gst_buffer_map (buf, &map, GST_MAP_READ);
GST_DEBUG ("Resizing buffer to %d (size:%d) (Was %" G_GSIZE_FORMAT
" bytes long)", (int) (packet->payload - map.data),
(int) (packet->data_end - packet->payload), map.size);
gst_buffer_resize (buf, packet->payload - map.data,
packet->data_end - packet->payload);
gst_buffer_unmap (buf, &map);
if (stream->state == PENDING_PACKET_EMPTY) {
if (G_UNLIKELY (!packet->payload_unit_start_indicator)) {
stream->state = PENDING_PACKET_DISCONT;
GST_WARNING ("Didn't get the first packet of this PES");
} else {
GST_LOG ("EMPTY=>HEADER");
stream->state = PENDING_PACKET_HEADER;
}
}
if (stream->state == PENDING_PACKET_HEADER) {
GST_LOG ("HEADER: appending data to array");
/* Append to the array */
stream->pendingbuffers[stream->nbpending++] = buf;
/* parse the header */
gst_ts_demux_parse_pes_header (demux, stream);
} else if (stream->state == PENDING_PACKET_BUFFER) {
GST_LOG ("BUFFER: appending data to bufferlist");
stream->currentlist = g_list_prepend (stream->currentlist, buf);
}
return;
}
static void
calculate_and_push_newsegment (GstTSDemux * demux, TSDemuxStream * stream)
{
MpegTSBase *base = (MpegTSBase *) demux;
GstEvent *newsegmentevent;
gint64 start = 0, stop = GST_CLOCK_TIME_NONE, position = 0;
GstClockTime firstpts = GST_CLOCK_TIME_NONE;
GList *tmp;
GST_DEBUG ("Creating new newsegment for stream %p", stream);
/* Outgoing newsegment values
* start : The first/start PTS
* stop : The last PTS (or -1)
* position : The stream time corresponding to start
*
* Except for live mode with incoming GST_TIME_FORMAT newsegment where
* it is the same values as that incoming newsegment (and we convert the
* PTS to that remote clock).
*/
for (tmp = demux->program->stream_list; tmp; tmp = tmp->next) {
TSDemuxStream *pstream = (TSDemuxStream *) tmp->data;
if (!GST_CLOCK_TIME_IS_VALID (firstpts) || pstream->pts < firstpts)
firstpts = pstream->pts;
}
if (base->mode == BASE_MODE_PUSHING) {
/* FIXME : We're just ignore the upstream format for the time being */
/* FIXME : We should use base->segment.format and a upstream latency query
* to decide if we need to use live values or not */
GST_DEBUG ("push-based. base Segment start:%" GST_TIME_FORMAT " duration:%"
GST_TIME_FORMAT ", stop:%" GST_TIME_FORMAT ", time:%" GST_TIME_FORMAT,
GST_TIME_ARGS (base->segment.start),
GST_TIME_ARGS (base->segment.duration),
GST_TIME_ARGS (base->segment.stop), GST_TIME_ARGS (base->segment.time));
GST_DEBUG ("push-based. demux Segment start:%" GST_TIME_FORMAT " duration:%"
GST_TIME_FORMAT ", stop:%" GST_TIME_FORMAT ", time:%" GST_TIME_FORMAT,
GST_TIME_ARGS (demux->segment.start),
GST_TIME_ARGS (demux->segment.duration),
GST_TIME_ARGS (demux->segment.stop),
GST_TIME_ARGS (demux->segment.time));
GST_DEBUG ("stream pts: %" GST_TIME_FORMAT " first pts: %" GST_TIME_FORMAT,
GST_TIME_ARGS (stream->pts), GST_TIME_ARGS (firstpts));
if (base->segment.format == GST_FORMAT_TIME) {
start = base->segment.start;
stop = base->segment.stop;
if (!base->upstream_live) {
/* Shift the start depending on our position in the stream */
start += firstpts + base->in_gap - base->first_buf_ts;
}
}
position = start;
} else {
/* pull mode */
GST_DEBUG ("pull-based. Segment start:%" GST_TIME_FORMAT " duration:%"
GST_TIME_FORMAT ", time:%" GST_TIME_FORMAT,
GST_TIME_ARGS (demux->segment.start),
GST_TIME_ARGS (demux->segment.duration),
GST_TIME_ARGS (demux->segment.time));
GST_DEBUG ("firstpcr gsttime : %" GST_TIME_FORMAT,
GST_TIME_ARGS (demux->first_pcr.gsttime));
/* FIXME : This is not entirely correct. We should be using the PTS time
* realm and not the PCR one. Doesn't matter *too* much if PTS/PCR values
* aren't too far apart, but still. */
start = demux->first_pcr.gsttime + demux->segment.start;
stop = demux->first_pcr.gsttime + demux->segment.duration;
position = demux->segment.time;
}
GST_DEBUG ("new segment: start: %" GST_TIME_FORMAT " stop: %"
GST_TIME_FORMAT " time: %" GST_TIME_FORMAT, GST_TIME_ARGS (start),
GST_TIME_ARGS (stop), GST_TIME_ARGS (position));
newsegmentevent = gst_event_new_segment (&demux->segment);
push_event ((MpegTSBase *) demux, newsegmentevent);
demux->need_newsegment = FALSE;
}
static GstFlowReturn
gst_ts_demux_push_pending_data (GstTSDemux * demux, TSDemuxStream * stream)
{
GstFlowReturn res = GST_FLOW_OK;
GList *tmp;
MpegTSBaseStream *bs = (MpegTSBaseStream *) stream;
GstBuffer *buf;
GstClockTime ts;
GST_DEBUG_OBJECT (stream->pad,
"stream:%p, pid:0x%04x stream_type:%d state:%d", stream, bs->pid,
bs->stream_type, stream->state);
if (G_UNLIKELY (stream->currentlist == NULL)) {
GST_LOG ("stream->current == NULL");
goto beach;
}
if (G_UNLIKELY (stream->state == PENDING_PACKET_EMPTY)) {
GST_LOG ("EMPTY: returning");
goto beach;
}
if (G_UNLIKELY (stream->state != PENDING_PACKET_BUFFER))
goto beach;
if (G_UNLIKELY (stream->pad == NULL)) {
g_list_foreach (stream->currentlist, (GFunc) gst_buffer_unref, NULL);
g_list_free (stream->currentlist);
stream->currentlist = NULL;
goto beach;
}
if (G_UNLIKELY (demux->need_newsegment))
calculate_and_push_newsegment (demux, stream);
/* We have a confirmed buffer, let's push it out */
GST_LOG ("Putting pending data into GstBufferList");
stream->currentlist = g_list_reverse (stream->currentlist);
buf = (GstBuffer *) stream->currentlist->data;
ts = GST_BUFFER_TIMESTAMP (buf);
GST_DEBUG_OBJECT (stream->pad,
"ts %" GST_TIME_FORMAT " delta %" GST_TIME_FORMAT " stream->pts %"
GST_TIME_FORMAT, GST_TIME_ARGS (ts), GST_TIME_ARGS (demux->pts_delta),
GST_TIME_ARGS (stream->pts));
if (GST_CLOCK_TIME_IS_VALID (demux->pts_delta)
&& GST_CLOCK_TIME_IS_VALID (stream->pts)
&& !GST_CLOCK_TIME_IS_VALID (ts)) {
ts = stream->pts - demux->pts_delta;
}
for (tmp = stream->currentlist->next; tmp; tmp = tmp->next) {
buf = gst_buffer_join (buf, (GstBuffer *) tmp->data);
}
GST_BUFFER_TIMESTAMP (buf) = ts;
GST_DEBUG_OBJECT (stream->pad,
"Pushing buffer with timestamp: %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
res = gst_pad_push (stream->pad, buf);
GST_DEBUG_OBJECT (stream->pad, "Returned %s", gst_flow_get_name (res));
res = tsdemux_combine_flows (demux, stream, res);
GST_DEBUG_OBJECT (stream->pad, "combined %s", gst_flow_get_name (res));
beach:
/* Reset everything */
GST_LOG ("Resetting to EMPTY");
stream->state = PENDING_PACKET_EMPTY;
memset (stream->pendingbuffers, 0, TS_MAX_PENDING_BUFFERS);
stream->nbpending = 0;
if (stream->currentlist)
g_list_free (stream->currentlist);
stream->currentlist = NULL;
return res;
}
static GstFlowReturn
gst_ts_demux_handle_packet (GstTSDemux * demux, TSDemuxStream * stream,
MpegTSPacketizerPacket * packet, MpegTSPacketizerSection * section)
{
GstFlowReturn res = GST_FLOW_OK;
#if 0
GST_DEBUG ("buffer:%p, data:%p", GST_BUFFER_DATA (packet->buffer),
packet->data);
#endif
GST_LOG ("pid 0x%04x pusi:%d, afc:%d, cont:%d, payload:%p",
packet->pid,
packet->payload_unit_start_indicator,
packet->adaptation_field_control,
packet->continuity_counter, packet->payload);
if (section) {
GST_DEBUG ("section complete:%d, buffer size %" G_GSIZE_FORMAT,
section->complete, gst_buffer_get_size (section->buffer));
gst_buffer_unref (packet->buffer);
return res;
}
if (G_UNLIKELY (packet->payload_unit_start_indicator))
/* Flush previous data */
res = gst_ts_demux_push_pending_data (demux, stream);
if (packet->adaptation_field_control & 0x2) {
if (packet->afc_flags & MPEGTS_AFC_PCR_FLAG)
gst_ts_demux_record_pcr (demux, stream, packet->pcr,
GST_BUFFER_OFFSET (packet->buffer));
if (packet->afc_flags & MPEGTS_AFC_OPCR_FLAG)
gst_ts_demux_record_opcr (demux, stream, packet->opcr,
GST_BUFFER_OFFSET (packet->buffer));
}
if (packet->payload)
gst_ts_demux_queue_data (demux, stream, packet);
else
gst_buffer_unref (packet->buffer);
return res;
}
static void
gst_ts_demux_flush (MpegTSBase * base)
{
GstTSDemux *demux = GST_TS_DEMUX_CAST (base);
demux->need_newsegment = TRUE;
gst_ts_demux_flush_streams (demux);
}
static GstFlowReturn
gst_ts_demux_push (MpegTSBase * base, MpegTSPacketizerPacket * packet,
MpegTSPacketizerSection * section)
{
GstTSDemux *demux = GST_TS_DEMUX_CAST (base);
TSDemuxStream *stream = NULL;
GstFlowReturn res = GST_FLOW_OK;
GST_DEBUG ("packet->buffer %p", packet->buffer);
if (G_LIKELY (demux->program)) {
stream = (TSDemuxStream *) demux->program->streams[packet->pid];
if (stream) {
res = gst_ts_demux_handle_packet (demux, stream, packet, section);
} else if (packet->buffer)
gst_buffer_unref (packet->buffer);
} else {
if (packet->buffer)
gst_buffer_unref (packet->buffer);
}
return res;
}
gboolean
gst_ts_demux_plugin_init (GstPlugin * plugin)
{
GST_DEBUG_CATEGORY_INIT (ts_demux_debug, "tsdemux", 0,
"MPEG transport stream demuxer");
init_pes_parser ();
return gst_element_register (plugin, "tsdemux",
GST_RANK_SECONDARY, GST_TYPE_TS_DEMUX);
}