/* GStreamer * Copyright (C) 2012 Smart TV Alliance * Author: Thiago Sousa Santos , Collabora Ltd. * * gstmssdemux.c: * * 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. */ /** * SECTION:element-mssdemux * * Demuxes a Microsoft's Smooth Streaming manifest into its audio and/or video streams. * * */ /* * == Internals * * = Smooth streaming in a few lines * A SS stream is defined by a xml manifest file. This file has a list of * tracks (StreamIndex), each one can have multiple QualityLevels, that define * different encoding/bitrates. When playing a track, only one of those * QualityLevels can be active at a time (per stream). * * The StreamIndex defines a URL with {time} and {bitrate} tags that are * replaced by values indicated by the fragment start times and the selected * QualityLevel, that generates the fragments URLs. * * Another relevant detail is that the Isomedia fragments for smoothstreaming * won't contains a 'moov' atom, nor a 'stsd', so there is no information * about the media type/configuration on the fragments, it must be extracted * from the Manifest and passed downstream. mssdemux does this via GstCaps. * * = How mssdemux works * There is a gstmssmanifest.c utility that holds the manifest and parses * and has functions to extract information from it. mssdemux received the * manifest from its sink pad and starts processing it when it gets EOS. * * The Manifest is parsed and the streams are exposed, 1 pad for each, with * a initially selected QualityLevel. Each stream starts its own GstTaks that * is responsible for downloading fragments and pushing them downstream. * * When a new connection-speed is set, mssdemux evaluates the available * QualityLevels and might decide to switch to another one. In this case it * pushes a new GstCaps event indicating the new caps on the pads. * * All operations that intend to update the GstTasks state should be protected * with the GST_OBJECT_LOCK. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "gst/gst-i18n-plugin.h" #include #include #include #include "gstmssdemux.h" GST_DEBUG_CATEGORY (mssdemux_debug); #define DEFAULT_MAX_QUEUE_SIZE_BUFFERS 0 #define DEFAULT_BITRATE_LIMIT 0.8 enum { PROP_0, PROP_MAX_QUEUE_SIZE_BUFFERS, PROP_LAST }; static GstStaticPadTemplate gst_mss_demux_sink_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("application/vnd.ms-sstr+xml") ); static GstStaticPadTemplate gst_mss_demux_videosrc_template = GST_STATIC_PAD_TEMPLATE ("video_%02u", GST_PAD_SRC, GST_PAD_SOMETIMES, GST_STATIC_CAPS_ANY); static GstStaticPadTemplate gst_mss_demux_audiosrc_template = GST_STATIC_PAD_TEMPLATE ("audio_%02u", GST_PAD_SRC, GST_PAD_SOMETIMES, GST_STATIC_CAPS_ANY); #define gst_mss_demux_parent_class parent_class G_DEFINE_TYPE (GstMssDemux, gst_mss_demux, GST_TYPE_ADAPTIVE_DEMUX); static void gst_mss_demux_dispose (GObject * object); static void gst_mss_demux_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_mss_demux_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static gboolean gst_mss_demux_is_live (GstAdaptiveDemux * demux); static gboolean gst_mss_demux_process_manifest (GstAdaptiveDemux * demux, GstBuffer * buffer); static GstClockTime gst_mss_demux_get_duration (GstAdaptiveDemux * demux); static void gst_mss_demux_reset (GstAdaptiveDemux * demux); static GstFlowReturn gst_mss_demux_stream_seek (GstAdaptiveDemuxStream * stream, GstClockTime ts); static gboolean gst_mss_demux_stream_has_next_fragment (GstAdaptiveDemuxStream * stream); static GstFlowReturn gst_mss_demux_stream_advance_fragment (GstAdaptiveDemuxStream * stream); static gboolean gst_mss_demux_stream_select_bitrate (GstAdaptiveDemuxStream * stream, guint64 bitrate); static GstFlowReturn gst_mss_demux_stream_update_fragment_info (GstAdaptiveDemuxStream * stream); static gboolean gst_mss_demux_seek (GstAdaptiveDemux * demux, GstEvent * seek); static gint64 gst_mss_demux_get_manifest_update_interval (GstAdaptiveDemux * demux); static GstFlowReturn gst_mss_demux_update_manifest (GstAdaptiveDemux * demux, GstBuffer * buffer); static void gst_mss_demux_class_init (GstMssDemuxClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstAdaptiveDemuxClass *gstadaptivedemux_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; gstadaptivedemux_class = (GstAdaptiveDemuxClass *) klass; gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&gst_mss_demux_sink_template)); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&gst_mss_demux_videosrc_template)); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&gst_mss_demux_audiosrc_template)); gst_element_class_set_static_metadata (gstelement_class, "Smooth Streaming demuxer", "Codec/Demuxer/Adaptive", "Parse and demultiplex a Smooth Streaming manifest into audio and video " "streams", "Thiago Santos "); gobject_class->dispose = gst_mss_demux_dispose; gobject_class->set_property = gst_mss_demux_set_property; gobject_class->get_property = gst_mss_demux_get_property; #ifndef GST_REMOVE_DEPRECATED g_object_class_install_property (gobject_class, PROP_MAX_QUEUE_SIZE_BUFFERS, g_param_spec_uint ("max-queue-size-buffers", "Max queue size in buffers", "Maximum buffers that can be stored in each internal stream queue " "(0 = infinite) (deprecated)", 0, G_MAXUINT, DEFAULT_MAX_QUEUE_SIZE_BUFFERS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_DEPRECATED)); #endif gstadaptivedemux_class->process_manifest = gst_mss_demux_process_manifest; gstadaptivedemux_class->is_live = gst_mss_demux_is_live; gstadaptivedemux_class->get_duration = gst_mss_demux_get_duration; gstadaptivedemux_class->get_manifest_update_interval = gst_mss_demux_get_manifest_update_interval; gstadaptivedemux_class->reset = gst_mss_demux_reset; gstadaptivedemux_class->seek = gst_mss_demux_seek; gstadaptivedemux_class->stream_seek = gst_mss_demux_stream_seek; gstadaptivedemux_class->stream_advance_fragment = gst_mss_demux_stream_advance_fragment; gstadaptivedemux_class->stream_has_next_fragment = gst_mss_demux_stream_has_next_fragment; gstadaptivedemux_class->stream_select_bitrate = gst_mss_demux_stream_select_bitrate; gstadaptivedemux_class->stream_update_fragment_info = gst_mss_demux_stream_update_fragment_info; gstadaptivedemux_class->update_manifest = gst_mss_demux_update_manifest; GST_DEBUG_CATEGORY_INIT (mssdemux_debug, "mssdemux", 0, "mssdemux plugin"); } static void gst_mss_demux_init (GstMssDemux * mssdemux) { mssdemux->data_queue_max_size = DEFAULT_MAX_QUEUE_SIZE_BUFFERS; gst_adaptive_demux_set_stream_struct_size (GST_ADAPTIVE_DEMUX_CAST (mssdemux), sizeof (GstMssDemuxStream)); } static void gst_mss_demux_reset (GstAdaptiveDemux * demux) { GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); if (mssdemux->manifest) { gst_mss_manifest_free (mssdemux->manifest); mssdemux->manifest = NULL; } g_free (mssdemux->base_url); mssdemux->base_url = NULL; mssdemux->n_videos = mssdemux->n_audios = 0; } static void gst_mss_demux_dispose (GObject * object) { gst_mss_demux_reset (GST_ADAPTIVE_DEMUX_CAST (object)); G_OBJECT_CLASS (parent_class)->dispose (object); } static void gst_mss_demux_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMssDemux *mssdemux = GST_MSS_DEMUX (object); switch (prop_id) { case PROP_MAX_QUEUE_SIZE_BUFFERS: mssdemux->data_queue_max_size = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_mss_demux_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstMssDemux *mssdemux = GST_MSS_DEMUX (object); switch (prop_id) { case PROP_MAX_QUEUE_SIZE_BUFFERS: g_value_set_uint (value, mssdemux->data_queue_max_size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static gboolean gst_mss_demux_is_live (GstAdaptiveDemux * demux) { GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); g_return_val_if_fail (mssdemux->manifest != NULL, FALSE); return gst_mss_manifest_is_live (mssdemux->manifest); } static GstClockTime gst_mss_demux_get_duration (GstAdaptiveDemux * demux) { GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); g_return_val_if_fail (mssdemux->manifest != NULL, FALSE); return gst_mss_manifest_get_gst_duration (mssdemux->manifest); } static GstFlowReturn gst_mss_demux_stream_update_fragment_info (GstAdaptiveDemuxStream * stream) { GstMssDemuxStream *mssstream = (GstMssDemuxStream *) stream; GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (stream->demux); GstFlowReturn ret; gchar *path = NULL; gst_adaptive_demux_stream_fragment_clear (&stream->fragment); ret = gst_mss_stream_get_fragment_url (mssstream->manifest_stream, &path); if (ret == GST_FLOW_OK) { stream->fragment.uri = g_strdup_printf ("%s/%s", mssdemux->base_url, path); stream->fragment.timestamp = gst_mss_stream_get_fragment_gst_timestamp (mssstream->manifest_stream); stream->fragment.duration = gst_mss_stream_get_fragment_gst_duration (mssstream->manifest_stream); } g_free (path); return ret; } static GstFlowReturn gst_mss_demux_stream_seek (GstAdaptiveDemuxStream * stream, GstClockTime ts) { GstMssDemuxStream *mssstream = (GstMssDemuxStream *) stream; gst_mss_stream_seek (mssstream->manifest_stream, ts); return GST_FLOW_OK; } static GstFlowReturn gst_mss_demux_stream_advance_fragment (GstAdaptiveDemuxStream * stream) { GstMssDemuxStream *mssstream = (GstMssDemuxStream *) stream; if (stream->demux->segment.rate >= 0) return gst_mss_stream_advance_fragment (mssstream->manifest_stream); else return gst_mss_stream_regress_fragment (mssstream->manifest_stream); } static GstCaps * create_mss_caps (GstMssDemuxStream * stream, GstCaps * caps) { return gst_caps_new_simple ("video/quicktime", "variant", G_TYPE_STRING, "mss-fragmented", "timescale", G_TYPE_UINT64, gst_mss_stream_get_timescale (stream->manifest_stream), "media-caps", GST_TYPE_CAPS, caps, NULL); } static GstPad * _create_pad (GstMssDemux * mssdemux, GstMssStream * manifeststream) { gchar *name = NULL; GstPad *srcpad = NULL; GstMssStreamType streamtype; GstPadTemplate *tmpl = NULL; streamtype = gst_mss_stream_get_type (manifeststream); GST_DEBUG_OBJECT (mssdemux, "Found stream of type: %s", gst_mss_stream_type_name (streamtype)); /* TODO use stream's name/bitrate/index as the pad name? */ if (streamtype == MSS_STREAM_TYPE_VIDEO) { name = g_strdup_printf ("video_%02u", mssdemux->n_videos++); tmpl = gst_static_pad_template_get (&gst_mss_demux_videosrc_template); } else if (streamtype == MSS_STREAM_TYPE_AUDIO) { name = g_strdup_printf ("audio_%02u", mssdemux->n_audios++); tmpl = gst_static_pad_template_get (&gst_mss_demux_audiosrc_template); } if (tmpl != NULL) { srcpad = GST_PAD_CAST (gst_ghost_pad_new_no_target_from_template (name, tmpl)); g_free (name); gst_object_unref (tmpl); } if (!srcpad) { GST_WARNING_OBJECT (mssdemux, "Ignoring unknown type stream"); return NULL; } return srcpad; } static gboolean gst_mss_demux_setup_streams (GstAdaptiveDemux * demux) { GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); GSList *streams = gst_mss_manifest_get_streams (mssdemux->manifest); GSList *iter; if (streams == NULL) { GST_INFO_OBJECT (mssdemux, "No streams found in the manifest"); GST_ELEMENT_ERROR (mssdemux, STREAM, DEMUX, (_("This file contains no playable streams.")), ("no streams found at the Manifest")); return FALSE; } GST_INFO_OBJECT (mssdemux, "Changing max bitrate to %u", demux->connection_speed); gst_mss_manifest_change_bitrate (mssdemux->manifest, demux->connection_speed); for (iter = streams; iter; iter = g_slist_next (iter)) { GstPad *srcpad = NULL; GstMssDemuxStream *stream = NULL; GstMssStream *manifeststream = iter->data; GstCaps *caps; const gchar *lang; srcpad = _create_pad (mssdemux, manifeststream); if (!srcpad) { continue; } stream = (GstMssDemuxStream *) gst_adaptive_demux_stream_new (GST_ADAPTIVE_DEMUX_CAST (mssdemux), srcpad); stream->manifest_stream = manifeststream; gst_mss_stream_set_active (manifeststream, TRUE); caps = gst_mss_stream_get_caps (stream->manifest_stream); gst_adaptive_demux_stream_set_caps (GST_ADAPTIVE_DEMUX_STREAM_CAST (stream), create_mss_caps (stream, caps)); gst_caps_unref (caps); lang = gst_mss_stream_get_lang (stream->manifest_stream); if (lang != NULL) { GstTagList *tags; tags = gst_tag_list_new (GST_TAG_LANGUAGE_CODE, lang, NULL); gst_adaptive_demux_stream_set_tags (GST_ADAPTIVE_DEMUX_STREAM_CAST (stream), tags); } } return TRUE; } static void gst_mss_demux_update_base_url (GstMssDemux * mssdemux) { GstAdaptiveDemux *demux = GST_ADAPTIVE_DEMUX_CAST (mssdemux); gchar *baseurl_end; g_free (mssdemux->base_url); mssdemux->base_url = g_strdup (demux->manifest_base_uri ? demux->manifest_base_uri : demux-> manifest_uri); baseurl_end = g_strrstr (mssdemux->base_url, "/Manifest"); if (baseurl_end == NULL) { /* second try */ baseurl_end = g_strrstr (mssdemux->base_url, "/manifest"); } if (baseurl_end) { /* set the new end of the string */ baseurl_end[0] = '\0'; } else { GST_WARNING_OBJECT (mssdemux, "Stream's URI didn't end with /manifest"); } } static gboolean gst_mss_demux_process_manifest (GstAdaptiveDemux * demux, GstBuffer * buf) { GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); gst_mss_demux_update_base_url (mssdemux); mssdemux->manifest = gst_mss_manifest_new (buf); if (!mssdemux->manifest) { GST_ELEMENT_ERROR (mssdemux, STREAM, FORMAT, ("Bad manifest file"), ("Xml manifest file couldn't be parsed")); return FALSE; } return gst_mss_demux_setup_streams (demux); } static gboolean gst_mss_demux_stream_select_bitrate (GstAdaptiveDemuxStream * stream, guint64 bitrate) { GstMssDemuxStream *mssstream = (GstMssDemuxStream *) stream; gboolean ret = FALSE; GST_DEBUG_OBJECT (stream->pad, "Using stream download bitrate %" G_GUINT64_FORMAT, bitrate); if (gst_mss_stream_select_bitrate (mssstream->manifest_stream, bitrate)) { GstCaps *caps; GstCaps *msscaps; caps = gst_mss_stream_get_caps (mssstream->manifest_stream); GST_DEBUG_OBJECT (stream->pad, "Starting streams reconfiguration due to bitrate changes"); msscaps = create_mss_caps (mssstream, caps); GST_DEBUG_OBJECT (stream->pad, "Stream changed bitrate to %" G_GUINT64_FORMAT " caps: %" GST_PTR_FORMAT, gst_mss_stream_get_current_bitrate (mssstream->manifest_stream), caps); gst_caps_unref (caps); gst_adaptive_demux_stream_set_caps (stream, msscaps); ret = TRUE; GST_DEBUG_OBJECT (stream->pad, "Finished streams reconfiguration"); } return ret; } static gboolean gst_mss_demux_seek (GstAdaptiveDemux * demux, GstEvent * seek) { gdouble rate; GstFormat format; GstSeekFlags flags; GstSeekType start_type, stop_type; gint64 start, stop; GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); gst_event_parse_seek (seek, &rate, &format, &flags, &start_type, &start, &stop_type, &stop); GST_DEBUG_OBJECT (mssdemux, "seek event, rate: %f start: %" GST_TIME_FORMAT " stop: %" GST_TIME_FORMAT, rate, GST_TIME_ARGS (start), GST_TIME_ARGS (stop)); gst_mss_manifest_seek (mssdemux->manifest, start); return TRUE; } static gboolean gst_mss_demux_stream_has_next_fragment (GstAdaptiveDemuxStream * stream) { GstMssDemuxStream *mssstream = (GstMssDemuxStream *) stream; return gst_mss_stream_has_next_fragment (mssstream->manifest_stream); } static gint64 gst_mss_demux_get_manifest_update_interval (GstAdaptiveDemux * demux) { GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); GstClockTime interval; /* Not much information about this in the MSS spec. It seems that * the fragments contain an UUID box that should tell the next * fragments time and duration so one wouldn't need to fetch * the Manifest again, but we need a fallback here. So use 2 times * the current fragment duration */ interval = gst_mss_manifest_get_min_fragment_duration (mssdemux->manifest); if (!GST_CLOCK_TIME_IS_VALID (interval)) interval = 2 * GST_SECOND; /* default to 2 seconds */ interval = 2 * (interval / GST_USECOND); return interval; } static GstFlowReturn gst_mss_demux_update_manifest (GstAdaptiveDemux * demux, GstBuffer * buffer) { GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (demux); gst_mss_demux_update_base_url (mssdemux); gst_mss_manifest_reload_fragments (mssdemux->manifest, buffer); return GST_FLOW_OK; }