GST_PAD_SOMETIMES,
GST_STATIC_CAPS_ANY);
-GST_BOILERPLATE (GstMssDemux, gst_mss_demux, GstMssDemux, GST_TYPE_ELEMENT);
+#define gst_mss_demux_parent_class parent_class
+G_DEFINE_TYPE (GstMssDemux, gst_mss_demux, GST_TYPE_ELEMENT);
static void gst_mss_demux_dispose (GObject * object);
static void gst_mss_demux_set_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstStateChangeReturn gst_mss_demux_change_state (GstElement * element,
GstStateChange transition);
-static GstFlowReturn gst_mss_demux_chain (GstPad * pad, GstBuffer * buffer);
-static GstFlowReturn gst_mss_demux_event (GstPad * pad, GstEvent * event);
-
-static gboolean gst_mss_demux_src_query (GstPad * pad, GstQuery * query);
+static GstFlowReturn gst_mss_demux_chain (GstPad * pad, GstObject * parent,
+ GstBuffer * buffer);
+static GstFlowReturn gst_mss_demux_event (GstPad * pad, GstObject * parent,
+ GstEvent * event);
+static gboolean gst_mss_demux_src_query (GstPad * pad, GstObject * parent,
+ GstQuery * query);
static void gst_mss_demux_download_loop (GstMssDemuxStream * stream);
static void gst_mss_demux_stream_loop (GstMssDemux * mssdemux);
+static void gst_mss_demux_stream_store_object (GstMssDemuxStream * stream,
+ GstMiniObject * obj);
static gboolean gst_mss_demux_process_manifest (GstMssDemux * mssdemux);
static void
-gst_mss_demux_base_init (gpointer klass)
-{
- GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
-
- gst_element_class_add_static_pad_template (element_class,
- &gst_mss_demux_sink_template);
- gst_element_class_add_static_pad_template (element_class,
- &gst_mss_demux_videosrc_template);
- gst_element_class_add_static_pad_template (element_class,
- &gst_mss_demux_audiosrc_template);
- gst_element_class_set_details_simple (element_class, "Smooth Streaming "
- "demuxer", "Demuxer",
- "Parse and demultiplex a Smooth Streaming manifest into audio and video "
- "streams", "Thiago Santos <thiago.sousa.santos@collabora.com>");
-
- GST_DEBUG_CATEGORY_INIT (mssdemux_debug, "mssdemux", 0, "mssdemux plugin");
-}
-
-static void
gst_mss_demux_class_init (GstMssDemuxClass * klass)
{
GObjectClass *gobject_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) 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", "Demuxer",
+ "Parse and demultiplex a Smooth Streaming manifest into audio and video "
+ "streams", "Thiago Santos <thiago.sousa.santos@collabora.com>");
+
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;
gstelement_class->change_state =
GST_DEBUG_FUNCPTR (gst_mss_demux_change_state);
+
+ GST_DEBUG_CATEGORY_INIT (mssdemux_debug, "mssdemux", 0, "mssdemux plugin");
}
static void
-gst_mss_demux_init (GstMssDemux * mssdemux, GstMssDemuxClass * klass)
+gst_mss_demux_init (GstMssDemux * mssdemux)
{
mssdemux->sinkpad =
gst_pad_new_from_static_template (&gst_mss_demux_sink_template, "sink");
GST_DEBUG_FUNCPTR (gst_mss_demux_event));
gst_element_add_pad (GST_ELEMENT_CAST (mssdemux), mssdemux->sinkpad);
- g_static_rec_mutex_init (&mssdemux->stream_lock);
+ g_rec_mutex_init (&mssdemux->stream_lock);
mssdemux->stream_task =
- gst_task_create ((GstTaskFunction) gst_mss_demux_stream_loop, mssdemux);
+ gst_task_new ((GstTaskFunction) gst_mss_demux_stream_loop, mssdemux,
+ NULL);
gst_task_set_lock (mssdemux->stream_task, &mssdemux->stream_lock);
mssdemux->data_queue_max_size = DEFAULT_MAX_QUEUE_SIZE_BUFFERS;
stream = g_new0 (GstMssDemuxStream, 1);
stream->downloader = gst_uri_downloader_new ();
- stream->dataqueue = gst_data_queue_new (_data_queue_check_full, stream);
+ stream->dataqueue =
+ gst_data_queue_new (_data_queue_check_full, NULL, NULL, stream);
/* Downloading task */
- g_static_rec_mutex_init (&stream->download_lock);
+ g_rec_mutex_init (&stream->download_lock);
stream->download_task =
- gst_task_create ((GstTaskFunction) gst_mss_demux_download_loop, stream);
+ gst_task_new ((GstTaskFunction) gst_mss_demux_download_loop, stream,
+ NULL);
gst_task_set_lock (stream->download_task, &stream->download_lock);
stream->pad = srcpad;
GST_DEBUG_PAD_NAME (stream->pad));
gst_uri_downloader_cancel (stream->downloader);
gst_task_stop (stream->download_task);
- g_static_rec_mutex_lock (&stream->download_lock);
- g_static_rec_mutex_unlock (&stream->download_lock);
+ g_rec_mutex_lock (&stream->download_lock);
+ g_rec_mutex_unlock (&stream->download_lock);
GST_LOG_OBJECT (stream->parent, "Waiting for task to finish");
gst_task_join (stream->download_task);
GST_LOG_OBJECT (stream->parent, "Finished");
}
gst_object_unref (stream->download_task);
- g_static_rec_mutex_free (&stream->download_lock);
+ g_rec_mutex_clear (&stream->download_lock);
stream->download_task = NULL;
}
if (GST_TASK_STATE (mssdemux->stream_task) != GST_TASK_STOPPED) {
gst_task_stop (mssdemux->stream_task);
- g_static_rec_mutex_lock (&mssdemux->stream_lock);
- g_static_rec_mutex_unlock (&mssdemux->stream_lock);
+ g_rec_mutex_lock (&mssdemux->stream_lock);
+ g_rec_mutex_unlock (&mssdemux->stream_lock);
gst_task_join (mssdemux->stream_task);
}
if (mssdemux->stream_task) {
gst_object_unref (mssdemux->stream_task);
- g_static_rec_mutex_free (&mssdemux->stream_lock);
+ g_rec_mutex_clear (&mssdemux->stream_lock);
mssdemux->stream_task = NULL;
}
result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
- case GST_STATE_CHANGE_PAUSED_TO_READY:{
+ case GST_STATE_CHANGE_READY_TO_PAUSED:{
+ gst_segment_init (&mssdemux->segment, GST_FORMAT_TIME);
break;
}
default:
}
static GstFlowReturn
-gst_mss_demux_chain (GstPad * pad, GstBuffer * buffer)
+gst_mss_demux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
- GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (GST_PAD_PARENT (pad));
+ GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (parent);
if (mssdemux->manifest_buffer == NULL)
mssdemux->manifest_buffer = buffer;
else
mssdemux->manifest_buffer =
- gst_buffer_join (mssdemux->manifest_buffer, buffer);
+ gst_buffer_append (mssdemux->manifest_buffer, buffer);
GST_INFO_OBJECT (mssdemux, "Received manifest buffer, total size is %i bytes",
- GST_BUFFER_SIZE (mssdemux->manifest_buffer));
+ gst_buffer_get_size (mssdemux->manifest_buffer));
return GST_FLOW_OK;
}
}
static gboolean
-gst_mss_demux_event (GstPad * pad, GstEvent * event)
+gst_mss_demux_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
- GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (GST_PAD_PARENT (pad));
+ GstMssDemux *mssdemux = GST_MSS_DEMUX_CAST (parent);
gboolean forward = TRUE;
gboolean ret = TRUE;
}
if (forward) {
- ret = gst_pad_event_default (pad, event);
+ ret = gst_pad_event_default (pad, parent, event);
} else {
gst_event_unref (event);
}
for (iter = mssdemux->streams; iter; iter = g_slist_next (iter)) {
GstMssDemuxStream *stream = iter->data;
- g_static_rec_mutex_lock (&stream->download_lock);
+ g_rec_mutex_lock (&stream->download_lock);
stream->cancelled = FALSE;
stream->download_error_count = 0;
}
- g_static_rec_mutex_lock (&mssdemux->stream_lock);
+ g_rec_mutex_lock (&mssdemux->stream_lock);
}
static void
for (iter = mssdemux->streams; iter; iter = g_slist_next (iter)) {
GstMssDemuxStream *stream = iter->data;
gst_uri_downloader_reset (stream->downloader);
- g_static_rec_mutex_unlock (&stream->download_lock);
+ g_rec_mutex_unlock (&stream->download_lock);
}
- g_static_rec_mutex_unlock (&mssdemux->stream_lock);
+ g_rec_mutex_unlock (&mssdemux->stream_lock);
for (iter = mssdemux->streams; iter; iter = g_slist_next (iter)) {
GstMssDemuxStream *stream = iter->data;
}
static gboolean
-gst_mss_demux_src_event (GstPad * pad, GstEvent * event)
+gst_mss_demux_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstMssDemux *mssdemux;
- mssdemux = GST_MSS_DEMUX (GST_PAD_PARENT (pad));
+ mssdemux = GST_MSS_DEMUX_CAST (parent);
switch (event->type) {
case GST_EVENT_SEEK:
gint64 start, stop;
GstEvent *newsegment;
GSList *iter;
+ gboolean update;
GST_INFO_OBJECT (mssdemux, "Received GST_EVENT_SEEK");
goto not_supported;
}
- newsegment =
- gst_event_new_new_segment (FALSE, rate, format, start, stop, start);
+ gst_segment_do_seek (&mssdemux->segment, rate, format, flags,
+ start_type, start, stop_type, stop, &update);
+
+ newsegment = gst_event_new_segment (&mssdemux->segment);
gst_event_set_seqnum (newsegment, gst_event_get_seqnum (event));
for (iter = mssdemux->streams; iter; iter = g_slist_next (iter)) {
GstMssDemuxStream *stream = iter->data;
gst_event_unref (newsegment);
if (flags & GST_SEEK_FLAG_FLUSH) {
- GstEvent *flush = gst_event_new_flush_stop ();
+ GstEvent *flush = gst_event_new_flush_stop (TRUE);
GST_DEBUG_OBJECT (mssdemux, "sending flush stop");
gst_event_set_seqnum (flush, gst_event_get_seqnum (event));
break;
}
- return gst_pad_event_default (pad, event);
+ return gst_pad_event_default (pad, parent, event);
not_supported:
gst_event_unref (event);
}
static gboolean
-gst_mss_demux_src_query (GstPad * pad, GstQuery * query)
+gst_mss_demux_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
GstMssDemux *mssdemux;
gboolean ret = FALSE;
if (query == NULL)
return FALSE;
- mssdemux = GST_MSS_DEMUX (GST_PAD_PARENT (pad));
+ mssdemux = GST_MSS_DEMUX (parent);
switch (query->type) {
case GST_QUERY_DURATION:{
media_caps = gst_mss_stream_get_caps (stream->manifest_stream);
if (media_caps) {
+ gst_pad_set_active (pad, TRUE);
+
caps = create_mss_caps (stream, media_caps);
gst_caps_unref (media_caps);
gst_pad_set_caps (pad, caps);
stream->caps = caps;
- gst_pad_set_active (pad, TRUE);
GST_INFO_OBJECT (mssdemux, "Adding srcpad %s:%s with caps %" GST_PTR_FORMAT,
GST_DEBUG_PAD_NAME (pad), caps);
gst_object_ref (pad);
}
GST_INFO_OBJECT (mssdemux, "Received manifest: %i bytes",
- GST_BUFFER_SIZE (mssdemux->manifest_buffer));
+ gst_buffer_get_size (mssdemux->manifest_buffer));
mssdemux->manifest = gst_mss_manifest_new (mssdemux->manifest_buffer);
if (!mssdemux->manifest) {
GST_PAD_NAME (stream->pad), new_bitrate);
if (gst_mss_stream_select_bitrate (stream->manifest_stream, new_bitrate)) {
+ GstEvent *capsevent;
GstCaps *caps;
caps = gst_mss_stream_get_caps (stream->manifest_stream);
"Stream %s changed bitrate to %llu caps: %" GST_PTR_FORMAT,
GST_PAD_NAME (stream->pad),
gst_mss_stream_get_current_bitrate (stream->manifest_stream), caps);
+
+ capsevent = gst_event_new_caps (stream->caps);
+ gst_mss_demux_stream_store_object (stream,
+ GST_MINI_OBJECT_CAST (capsevent));
}
}
switch (ret) {
case GST_FLOW_OK:
break; /* all is good, let's go */
- case GST_FLOW_UNEXPECTED: /* EOS */
+ case GST_FLOW_EOS:
if (gst_mss_manifest_is_live (mssdemux->manifest)) {
gst_mss_demux_reload_manifest (mssdemux);
return GST_FLOW_OK;
}
- return GST_FLOW_UNEXPECTED;
+ return GST_FLOW_EOS;
case GST_FLOW_ERROR:
goto error;
default:
}
_buffer = gst_fragment_get_buffer (fragment);
- _buffer = gst_buffer_make_metadata_writable (_buffer);
- gst_buffer_set_caps (_buffer, stream->caps);
+ _buffer = gst_buffer_make_writable (_buffer);
GST_BUFFER_TIMESTAMP (_buffer) =
gst_mss_stream_get_fragment_gst_timestamp (stream->manifest_stream);
GST_BUFFER_DURATION (_buffer) =
after_download = g_get_real_time ();
if (_buffer) {
- guint64 bitrate = (8 * GST_BUFFER_SIZE (_buffer) * 1000000LLU) /
+ guint64 bitrate = (8 * gst_buffer_get_size (_buffer) * 1000000LLU) /
(after_download - before_download);
GST_DEBUG_OBJECT (mssdemux, "Measured download bitrate: %s %llu bps",
GST_PAD_NAME (stream->pad), bitrate);
gst_download_rate_add_rate (&stream->download_rate,
- GST_BUFFER_SIZE (_buffer), 1000 * (after_download - before_download));
+ gst_buffer_get_size (_buffer),
+ 1000 * (after_download - before_download));
GST_DEBUG_OBJECT (mssdemux,
"Storing buffer for stream %p - %s. Timestamp: %" GST_TIME_FORMAT
switch (ret) {
case GST_FLOW_OK:
break; /* all is good, let's go */
- case GST_FLOW_UNEXPECTED: /* EOS */
+ case GST_FLOW_EOS:
goto eos;
case GST_FLOW_ERROR:
goto error;
if (!gst_data_queue_peek (other->dataqueue, &item)) {
/* flushing */
- return GST_FLOW_WRONG_STATE;
+ return GST_FLOW_FLUSHING;
}
if (GST_IS_EVENT (item->object)) {
*stream = current;
if (current == NULL)
- ret = GST_FLOW_UNEXPECTED;
+ ret = GST_FLOW_EOS;
return ret;
}
GST_LOG_OBJECT (mssdemux, "Starting stream loop");
-
ret = gst_mss_demux_select_latest_stream (mssdemux, &stream);
if (stream)
break;
case GST_FLOW_ERROR:
goto error;
- case GST_FLOW_UNEXPECTED:
+ case GST_FLOW_EOS:
goto eos;
- case GST_FLOW_WRONG_STATE:
+ case GST_FLOW_FLUSHING:
GST_DEBUG_OBJECT (mssdemux, "Wrong state, stopping task");
goto stop;
default:
}
switch (ret) {
- case GST_FLOW_UNEXPECTED:
+ case GST_FLOW_EOS:
goto eos; /* EOS ? */
case GST_FLOW_ERROR:
goto error;
}
GstMssManifest *
-gst_mss_manifest_new (const GstBuffer * data)
+gst_mss_manifest_new (GstBuffer * data)
{
GstMssManifest *manifest;
xmlNodePtr root;
xmlNodePtr nodeiter;
gchar *live_str;
+ GstMapInfo mapinfo;
+
+ if (!gst_buffer_map (data, &mapinfo, GST_MAP_READ)) {
+ return NULL;
+ }
manifest = g_malloc0 (sizeof (GstMssManifest));
- manifest->xml = xmlReadMemory ((const gchar *) GST_BUFFER_DATA (data),
- GST_BUFFER_SIZE (data), "manifest", NULL, 0);
+ manifest->xml = xmlReadMemory ((const gchar *) mapinfo.data,
+ mapinfo.size, "manifest", NULL, 0);
root = manifest->xmlrootnode = xmlDocGetRootElement (manifest->xml);
live_str = (gchar *) xmlGetProp (root, (xmlChar *) "IsLive");
}
}
+ gst_buffer_unmap (data, &mapinfo);
+
return manifest;
}
guint8 profile_idc = 0, profile_comp = 0, level_idc = 0;
guint8 *data;
gint nl;
+ GstMapInfo spsinfo, ppsinfo, codecdatainfo;
- if (GST_BUFFER_SIZE (sps) < 4)
+ if (gst_buffer_get_size (sps) < 4)
return NULL;
- sps_size += GST_BUFFER_SIZE (sps) + 2;
- profile_idc = GST_BUFFER_DATA (sps)[1];
- profile_comp = GST_BUFFER_DATA (sps)[2];
- level_idc = GST_BUFFER_DATA (sps)[3];
+ gst_buffer_map (sps, &spsinfo, GST_MAP_READ);
+ gst_buffer_map (pps, &ppsinfo, GST_MAP_READ);
+
+ sps_size += spsinfo.size + 2;
+ profile_idc = spsinfo.data[1];
+ profile_comp = spsinfo.data[2];
+ level_idc = spsinfo.data[3];
num_sps = 1;
- pps_size += GST_BUFFER_SIZE (pps) + 2;
+ pps_size += ppsinfo.size + 2;
num_pps = 1;
buf = gst_buffer_new_and_alloc (5 + 1 + sps_size + 1 + pps_size);
- data = GST_BUFFER_DATA (buf);
+ gst_buffer_map (buf, &codecdatainfo, GST_MAP_WRITE);
+ data = codecdatainfo.data;
nl = 4;
data[0] = 1; /* AVC Decoder Configuration Record ver. 1 */
data[5] = 0xe0 | num_sps; /* number of SPSs */
data += 6;
- GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (sps));
- memcpy (data + 2, GST_BUFFER_DATA (sps), GST_BUFFER_SIZE (sps));
- data += 2 + GST_BUFFER_SIZE (sps);
+ GST_WRITE_UINT16_BE (data, spsinfo.size);
+ memcpy (data + 2, spsinfo.data, spsinfo.size);
+ data += 2 + spsinfo.size;
data[0] = num_pps;
data++;
- GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (pps));
- memcpy (data + 2, GST_BUFFER_DATA (pps), GST_BUFFER_SIZE (pps));
- data += 2 + GST_BUFFER_SIZE (pps);
+ GST_WRITE_UINT16_BE (data, ppsinfo.size);
+ memcpy (data + 2, ppsinfo.data, ppsinfo.size);
+ data += 2 + ppsinfo.size;
+
+ gst_buffer_unmap (sps, &spsinfo);
+ gst_buffer_unmap (pps, &ppsinfo);
+ gst_buffer_unmap (buf, &codecdatainfo);
return buf;
}
GstH264NalUnit nalu;
GstH264SPS sps_struct;
GstH264ParserResult parseres;
+ GstMapInfo spsinfo;
/* search for the sps start */
if (g_str_has_prefix (codecdatastr, "00000001")) {
pps_str = pps_str + 8;
pps = gst_buffer_from_hex_string (pps_str);
- nalu.ref_idc = (GST_BUFFER_DATA (sps)[0] & 0x60) >> 5;
+ gst_buffer_map (sps, &spsinfo, GST_MAP_READ);
+
+ nalu.ref_idc = (spsinfo.data[0] & 0x60) >> 5;
nalu.type = GST_H264_NAL_SPS;
- nalu.size = GST_BUFFER_SIZE (sps);
- nalu.data = GST_BUFFER_DATA (sps);
+ nalu.size = spsinfo.size;
+ nalu.data = spsinfo.data;
nalu.offset = 0;
nalu.sc_offset = 0;
nalu.valid = TRUE;
}
buffer = _make_h264_codec_data (sps, pps);
+ gst_buffer_unmap (sps, &spsinfo);
gst_buffer_unref (sps);
gst_buffer_unref (pps);
guint8 *data;
guint8 frequency_index;
guint8 buf_size;
+ GstMapInfo info;
buf_size = 2;
frequency_index = _frequency_index_from_sampling_rate (sampling_rate);
buf_size += 3;
buf = gst_buffer_new_and_alloc (buf_size);
- data = GST_BUFFER_DATA (buf);
+ gst_buffer_map (buf, &info, GST_MAP_WRITE);
+ data = info.data;
data[0] = 2 << 3; /* AAC-LC object type is 2 */
data[0] += frequency_index >> 1;
data[1] += (channels & 0x0F) << 3;
+ gst_buffer_unmap (buf, &info);
+
return buf;
}
g_return_val_if_fail (stream->active, GST_FLOW_ERROR);
if (stream->current_fragment == NULL) /* stream is over */
- return GST_FLOW_UNEXPECTED;
+ return GST_FLOW_EOS;
fragment = stream->current_fragment->data;
g_return_val_if_fail (stream->active, GST_FLOW_ERROR);
if (stream->current_fragment == NULL)
- return GST_FLOW_UNEXPECTED;
+ return GST_FLOW_EOS;
stream->current_fragment = g_list_next (stream->current_fragment);
if (stream->current_fragment == NULL)
- return GST_FLOW_UNEXPECTED;
+ return GST_FLOW_EOS;
return GST_FLOW_OK;
}
{
xmlDocPtr xml;
xmlNodePtr root;
+ GstMapInfo info;
g_return_if_fail (manifest->is_live);
- xml = xmlReadMemory ((const gchar *) GST_BUFFER_DATA (data),
- GST_BUFFER_SIZE (data), "manifest", NULL, 0);
+ gst_buffer_map (data, &info, GST_MAP_READ);
+
+ xml = xmlReadMemory ((const gchar *) info.data,
+ info.size, "manifest", NULL, 0);
root = xmlDocGetRootElement (xml);
gst_mss_manifest_reload_fragments_from_xml (manifest, root);
xmlFreeDoc (xml);
+
+ gst_buffer_unmap (data, &info);
}
gboolean
gchar ts[3];
guint8 *data;
gint i;
+ GstMapInfo info;
len = strlen (s);
if (len & 1)
return NULL;
buffer = gst_buffer_new_and_alloc (len / 2);
- data = GST_BUFFER_DATA (buffer);
+ gst_buffer_map (buffer, &info, GST_MAP_WRITE);
+ data = info.data;
for (i = 0; i < len / 2; i++) {
if (!isxdigit ((int) s[i * 2]) || !isxdigit ((int) s[i * 2 + 1])) {
gst_buffer_unref (buffer);
data[i] = (guint8) strtoul (ts, NULL, 16);
}
+ gst_buffer_unmap (buffer, &info);
return buffer;
}
projects / platform / upstream / gstreamer.git / commitdiff