X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gst%2Fisomp4%2Fqtdemux.c;h=ad07c1e365de345bf359976fa210453c731ff476;hb=29f924643cd9730210ac05b083514fd6d6bde465;hp=4a99ca5eded4eccd6ac77cd35740d95eabb7258e;hpb=c0972897259683780bfb3ce9cf7051aca6b6dea5;p=platform%2Fupstream%2Fgst-plugins-good.git diff --git a/gst/isomp4/qtdemux.c b/gst/isomp4/qtdemux.c index 4a99ca5..ad07c1e 100644 --- a/gst/isomp4/qtdemux.c +++ b/gst/isomp4/qtdemux.c @@ -97,9 +97,12 @@ #define ABSDIFF(x, y) ( (x) > (y) ? ((x) - (y)) : ((y) - (x)) ) -#define QTDEMUX_FIRST_STREAM(demux) ((QtDemuxStream *)(demux)->active_streams \ - ? (QtDemuxStream *)(demux)->active_streams->data : NULL) #define QTDEMUX_STREAM(s) ((QtDemuxStream *)(s)) +#define QTDEMUX_N_STREAMS(demux) ((demux)->active_streams->len) +#define QTDEMUX_NTH_STREAM(demux,idx) \ + QTDEMUX_STREAM(g_ptr_array_index((demux)->active_streams,idx)) +#define QTDEMUX_NTH_OLD_STREAM(demux,idx) \ + QTDEMUX_STREAM(g_ptr_array_index((demux)->old_streams,idx)) GST_DEBUG_CATEGORY (qtdemux_debug); #define GST_CAT_DEFAULT qtdemux_debug @@ -310,8 +313,6 @@ struct _QtDemuxStream guint32 n_samples; QtDemuxSample *samples; gboolean all_keyframe; /* TRUE when all samples are keyframes (no stss) */ - guint32 first_duration; /* duration in timescale of first sample, used for figuring out - the framerate */ guint32 n_samples_moof; /* sample count in a moof */ guint64 duration_moof; /* duration in timescale of a moof, used for figure out * the framerate of fragmented format stream */ @@ -348,6 +349,8 @@ struct _QtDemuxStream /* buffer needs some custom processing, e.g. subtitles */ gboolean need_process; + /* buffer needs potentially be split, e.g. CEA608 subtitles */ + gboolean need_split; /* current position */ guint32 segment_index; @@ -448,6 +451,8 @@ struct _QtDemuxStream guint32 protection_scheme_version; gpointer protection_scheme_info; /* specific to the protection scheme */ GQueue protection_scheme_event_queue; + + gint ref_count; /* atomic */ }; /* Contains properties and cryptographic info for a set of samples from a @@ -486,6 +491,8 @@ static GNode *qtdemux_tree_get_sibling_by_type_full (GNode * node, static GstFlowReturn qtdemux_add_fragmented_samples (GstQTDemux * qtdemux); +static void gst_qtdemux_check_send_pending_segment (GstQTDemux * demux); + static GstStaticPadTemplate gst_qtdemux_sink_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, @@ -530,6 +537,8 @@ static GstIndex *gst_qtdemux_get_index (GstElement * element); #endif static GstStateChangeReturn gst_qtdemux_change_state (GstElement * element, GstStateChange transition); +static void gst_qtdemux_set_context (GstElement * element, + GstContext * context); static gboolean qtdemux_sink_activate (GstPad * sinkpad, GstObject * parent); static gboolean qtdemux_sink_activate_mode (GstPad * sinkpad, GstObject * parent, GstPadMode mode, gboolean active); @@ -539,6 +548,8 @@ static GstFlowReturn gst_qtdemux_chain (GstPad * sinkpad, GstObject * parent, GstBuffer * inbuf); static gboolean gst_qtdemux_handle_sink_event (GstPad * pad, GstObject * parent, GstEvent * event); +static gboolean gst_qtdemux_handle_sink_query (GstPad * pad, GstObject * parent, + GstQuery * query); static gboolean gst_qtdemux_setcaps (GstQTDemux * qtdemux, GstCaps * caps); static gboolean gst_qtdemux_configure_stream (GstQTDemux * qtdemux, QtDemuxStream * stream); @@ -547,6 +558,8 @@ static void gst_qtdemux_stream_check_and_change_stsd_index (GstQTDemux * demux, static GstFlowReturn gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force); +static void gst_qtdemux_check_seekability (GstQTDemux * demux); + static gboolean qtdemux_parse_moov (GstQTDemux * qtdemux, const guint8 * buffer, guint length); static gboolean qtdemux_parse_node (GstQTDemux * qtdemux, GNode * node, @@ -574,13 +587,12 @@ static GstCaps *qtdemux_generic_caps (GstQTDemux * qtdemux, static gboolean qtdemux_parse_samples (GstQTDemux * qtdemux, QtDemuxStream * stream, guint32 n); static GstFlowReturn qtdemux_expose_streams (GstQTDemux * qtdemux); -static void gst_qtdemux_stream_free (QtDemuxStream * stream); +static QtDemuxStream *gst_qtdemux_stream_ref (QtDemuxStream * stream); +static void gst_qtdemux_stream_unref (QtDemuxStream * stream); static void gst_qtdemux_stream_clear (QtDemuxStream * stream); -static void gst_qtdemux_remove_stream (GstQTDemux * qtdemux, - QtDemuxStream * stream); static GstFlowReturn qtdemux_prepare_streams (GstQTDemux * qtdemux); -static void qtdemux_do_allocation (GstQTDemux * qtdemux, - QtDemuxStream * stream); +static void qtdemux_do_allocation (QtDemuxStream * stream, + GstQTDemux * qtdemux); static gboolean gst_qtdemux_activate_segment (GstQTDemux * qtdemux, QtDemuxStream * stream, guint32 seg_idx, GstClockTime offset); static gboolean gst_qtdemux_stream_update_segment (GstQTDemux * qtdemux, @@ -619,6 +631,7 @@ gst_qtdemux_class_init (GstQTDemuxClass * klass) gstelement_class->set_index = GST_DEBUG_FUNCPTR (gst_qtdemux_set_index); gstelement_class->get_index = GST_DEBUG_FUNCPTR (gst_qtdemux_get_index); #endif + gstelement_class->set_context = GST_DEBUG_FUNCPTR (gst_qtdemux_set_context); gst_tag_register_musicbrainz_tags (); @@ -649,6 +662,7 @@ gst_qtdemux_init (GstQTDemux * qtdemux) qtdemux_sink_activate_mode); gst_pad_set_chain_function (qtdemux->sinkpad, gst_qtdemux_chain); gst_pad_set_event_function (qtdemux->sinkpad, gst_qtdemux_handle_sink_event); + gst_pad_set_query_function (qtdemux->sinkpad, gst_qtdemux_handle_sink_query); gst_element_add_pad (GST_ELEMENT_CAST (qtdemux), qtdemux->sinkpad); qtdemux->adapter = gst_adapter_new (); @@ -656,6 +670,11 @@ gst_qtdemux_init (GstQTDemux * qtdemux) qtdemux->flowcombiner = gst_flow_combiner_new (); g_mutex_init (&qtdemux->expose_lock); + qtdemux->active_streams = g_ptr_array_new_with_free_func + ((GDestroyNotify) gst_qtdemux_stream_unref); + qtdemux->old_streams = g_ptr_array_new_with_free_func + ((GDestroyNotify) gst_qtdemux_stream_unref); + GST_OBJECT_FLAG_SET (qtdemux, GST_ELEMENT_FLAG_INDEXABLE); gst_qtdemux_reset (qtdemux, TRUE); @@ -680,6 +699,9 @@ gst_qtdemux_dispose (GObject * object) qtdemux->cenc_aux_info_sizes = NULL; g_mutex_clear (&qtdemux->expose_lock); + g_ptr_array_free (qtdemux->active_streams, TRUE); + g_ptr_array_free (qtdemux->old_streams, TRUE); + G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -997,14 +1019,14 @@ gst_qtdemux_push_event (GstQTDemux * qtdemux, GstEvent * event) { gboolean has_valid_stream = FALSE; GstEventType etype = GST_EVENT_TYPE (event); - GList *iter; + guint i; GST_DEBUG_OBJECT (qtdemux, "pushing %s event on all source pads", GST_EVENT_TYPE_NAME (event)); - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { GstPad *pad; - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); GST_DEBUG_OBJECT (qtdemux, "pushing on track-id %u", stream->track_id); if ((pad = stream->pad)) { @@ -1029,16 +1051,6 @@ gst_qtdemux_push_event (GstQTDemux * qtdemux, GstEvent * event) } } -/* push a pending newsegment event, if any from the streaming thread */ -static void -gst_qtdemux_push_pending_newsegment (GstQTDemux * qtdemux) -{ - if (qtdemux->pending_newsegment) { - gst_qtdemux_push_event (qtdemux, qtdemux->pending_newsegment); - qtdemux->pending_newsegment = NULL; - } -} - typedef struct { guint64 media_time; @@ -1311,13 +1323,13 @@ gst_qtdemux_adjust_seek (GstQTDemux * qtdemux, gint64 desired_time, { guint64 min_offset; gint64 min_byte_offset = -1; - GList *iter; + guint i; min_offset = desired_time; /* for each stream, find the index of the sample in the segment * and move back to the previous keyframe. */ - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { QtDemuxStream *str; guint32 index, kindex; guint32 seg_idx; @@ -1327,7 +1339,7 @@ gst_qtdemux_adjust_seek (GstQTDemux * qtdemux, gint64 desired_time, QtDemuxSegment *seg; gboolean empty_segment = FALSE; - str = QTDEMUX_STREAM (iter->data); + str = QTDEMUX_NTH_STREAM (qtdemux, i); if (CUR_STREAM (str)->sparse && !use_sparse) continue; @@ -1508,6 +1520,7 @@ gst_qtdemux_do_push_seek (GstQTDemux * qtdemux, GstPad * pad, GstEvent * event) } GST_OBJECT_UNLOCK (qtdemux); + qtdemux->segment_seqnum = seqnum; /* BYTE seek event */ event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, cur_type, byte_cur, stop_type, stop); @@ -1556,7 +1569,7 @@ gst_qtdemux_perform_seek (GstQTDemux * qtdemux, GstSegment * segment, guint32 seqnum, GstSeekFlags flags) { gint64 desired_offset; - GList *iter; + guint i; desired_offset = segment->position; @@ -1586,8 +1599,8 @@ gst_qtdemux_perform_seek (GstQTDemux * qtdemux, GstSegment * segment, /* and set all streams to the final position */ gst_flow_combiner_reset (qtdemux->flowcombiner); qtdemux->segment_seqnum = seqnum; - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); stream->time_position = desired_offset; stream->accumulated_base = 0; @@ -1731,13 +1744,13 @@ no_format: static gboolean qtdemux_ensure_index (GstQTDemux * qtdemux) { - GList *iter; + guint i; GST_DEBUG_OBJECT (qtdemux, "collecting all metadata for all streams"); /* Build complete index */ - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); if (!qtdemux_parse_samples (qtdemux, stream, stream->n_samples - 1)) { GST_LOG_OBJECT (qtdemux, @@ -1765,6 +1778,8 @@ gst_qtdemux_handle_src_event (GstPad * pad, GstObject * parent, #endif guint32 seqnum = gst_event_get_seqnum (event); + qtdemux->received_seek = TRUE; + if (seqnum == qtdemux->segment_seqnum) { GST_LOG_OBJECT (pad, "Drop duplicated SEEK event seqnum %" G_GUINT32_FORMAT, seqnum); @@ -1795,7 +1810,8 @@ gst_qtdemux_handle_src_event (GstPad * pad, GstObject * parent, } else if (gst_pad_push_event (qtdemux->sinkpad, gst_event_ref (event))) { GST_DEBUG_OBJECT (qtdemux, "Upstream successfully seeked"); res = TRUE; - } else if (qtdemux->state == QTDEMUX_STATE_MOVIE && qtdemux->n_streams + } else if (qtdemux->state == QTDEMUX_STATE_MOVIE + && QTDEMUX_N_STREAMS (qtdemux) && !qtdemux->fragmented) { res = gst_qtdemux_do_push_seek (qtdemux, pad, event); } else { @@ -1844,18 +1860,18 @@ gst_qtdemux_find_sample (GstQTDemux * qtdemux, gint64 byte_pos, gboolean fw, gint i, index; gint64 time, min_time; QtDemuxStream *stream; - GList *iter; + gint iter; min_time = -1; stream = NULL; index = -1; - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { + for (iter = 0; iter < QTDEMUX_N_STREAMS (qtdemux); iter++) { QtDemuxStream *str; gint inc; gboolean set_sample; - str = QTDEMUX_STREAM (iter->data); + str = QTDEMUX_NTH_STREAM (qtdemux, iter); set_sample = !set; if (fw) { @@ -1992,6 +2008,9 @@ _create_stream (GstQTDemux * demux, guint32 track_id) stream->stream_tags = gst_tag_list_new_empty (); gst_tag_list_set_scope (stream->stream_tags, GST_TAG_SCOPE_STREAM); g_queue_init (&stream->protection_scheme_event_queue); + stream->ref_count = 1; + /* consistent default for push based mode */ + gst_segment_init (&stream->segment, GST_FORMAT_TIME); return stream; } @@ -2014,7 +2033,7 @@ gst_qtdemux_setcaps (GstQTDemux * demux, GstCaps * caps) demux->fragmented = TRUE; demux->mss_mode = TRUE; - if (demux->n_streams > 1) { + if (QTDEMUX_N_STREAMS (demux) > 1) { /* can't do this, we can only renegotiate for another mss format */ return FALSE; } @@ -2026,16 +2045,15 @@ gst_qtdemux_setcaps (GstQTDemux * demux, GstCaps * caps) /* TODO update when stream changes during playback */ - if (demux->n_streams == 0) { + if (QTDEMUX_N_STREAMS (demux) == 0) { stream = _create_stream (demux, 1); - demux->active_streams = g_list_append (demux->active_streams, stream); - demux->n_streams = 1; + g_ptr_array_add (demux->active_streams, stream); /* mss has no stsd/stsd entry, use id 0 as default */ stream->stsd_entries_length = 1; stream->stsd_sample_description_id = stream->cur_stsd_entry_index = 0; stream->stsd_entries = g_new0 (QtDemuxStreamStsdEntry, 1); } else { - stream = QTDEMUX_FIRST_STREAM (demux); + stream = QTDEMUX_NTH_STREAM (demux, 0); } timescale_v = gst_structure_get_value (structure, "timescale"); @@ -2084,7 +2102,7 @@ gst_qtdemux_setcaps (GstQTDemux * demux, GstCaps * caps) static void gst_qtdemux_reset (GstQTDemux * qtdemux, gboolean hard) { - GList *iter; + gint i; GST_DEBUG_OBJECT (qtdemux, "Resetting demux"); gst_pad_stop_task (qtdemux->sinkpad); @@ -2130,9 +2148,6 @@ gst_qtdemux_reset (GstQTDemux * qtdemux, gboolean hard) qtdemux->element_index = NULL; #endif qtdemux->major_brand = 0; - if (qtdemux->pending_newsegment) - gst_event_unref (qtdemux->pending_newsegment); - qtdemux->pending_newsegment = NULL; qtdemux->upstream_format_is_time = FALSE; qtdemux->upstream_seekable = FALSE; qtdemux->upstream_size = 0; @@ -2148,20 +2163,19 @@ gst_qtdemux_reset (GstQTDemux * qtdemux, gboolean hard) g_queue_foreach (&qtdemux->protection_event_queue, (GFunc) gst_event_unref, NULL); g_queue_clear (&qtdemux->protection_event_queue); + + qtdemux->received_seek = FALSE; + qtdemux->first_moof_already_parsed = FALSE; } qtdemux->offset = 0; gst_adapter_clear (qtdemux->adapter); gst_segment_init (&qtdemux->segment, GST_FORMAT_TIME); - qtdemux->segment_seqnum = GST_SEQNUM_INVALID; + qtdemux->need_segment = TRUE; if (hard) { - g_list_free_full (qtdemux->active_streams, - (GDestroyNotify) gst_qtdemux_stream_free); - g_list_free_full (qtdemux->old_streams, - (GDestroyNotify) gst_qtdemux_stream_free); - qtdemux->active_streams = NULL; - qtdemux->old_streams = NULL; - qtdemux->n_streams = 0; + qtdemux->segment_seqnum = GST_SEQNUM_INVALID; + g_ptr_array_set_size (qtdemux->active_streams, 0); + g_ptr_array_set_size (qtdemux->old_streams, 0); qtdemux->n_video_streams = 0; qtdemux->n_audio_streams = 0; qtdemux->n_sub_streams = 0; @@ -2181,24 +2195,23 @@ gst_qtdemux_reset (GstQTDemux * qtdemux, gboolean hard) qtdemux->streams_aware = GST_OBJECT_PARENT (qtdemux) && GST_OBJECT_FLAG_IS_SET (GST_OBJECT_PARENT (qtdemux), GST_BIN_FLAG_STREAMS_AWARE); + + if (qtdemux->preferred_protection_system_id) { + g_free (qtdemux->preferred_protection_system_id); + qtdemux->preferred_protection_system_id = NULL; + } } else if (qtdemux->mss_mode) { gst_flow_combiner_reset (qtdemux->flowcombiner); - g_list_foreach (qtdemux->active_streams, + g_ptr_array_foreach (qtdemux->active_streams, (GFunc) gst_qtdemux_stream_clear, NULL); } else { gst_flow_combiner_reset (qtdemux->flowcombiner); - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); stream->sent_eos = FALSE; stream->time_position = 0; stream->accumulated_base = 0; } - if (!qtdemux->pending_newsegment) { - qtdemux->pending_newsegment = gst_event_new_segment (&qtdemux->segment); - if (qtdemux->segment_seqnum != GST_SEQNUM_INVALID) - gst_event_set_seqnum (qtdemux->pending_newsegment, - qtdemux->segment_seqnum); - } } } @@ -2213,11 +2226,10 @@ gst_qtdemux_reset (GstQTDemux * qtdemux, gboolean hard) static void gst_qtdemux_map_and_push_segments (GstQTDemux * qtdemux, GstSegment * segment) { - gint i; - GList *iter; + gint i, iter; - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (iter = 0; iter < QTDEMUX_N_STREAMS (qtdemux); iter++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, iter); stream->time_position = segment->start; @@ -2226,12 +2238,18 @@ gst_qtdemux_map_and_push_segments (GstQTDemux * qtdemux, GstSegment * segment) * supported and are discarded when parsing the edts */ for (i = 0; i < stream->n_segments; i++) { if (stream->segments[i].stop_time > segment->start) { + /* push the empty segment and move to the next one */ gst_qtdemux_activate_segment (qtdemux, stream, i, stream->time_position); if (QTSEGMENT_IS_EMPTY (&stream->segments[i])) { - /* push the empty segment and move to the next one */ gst_qtdemux_send_gap_for_segment (qtdemux, stream, i, stream->time_position); + + /* accumulate previous segments */ + if (GST_CLOCK_TIME_IS_VALID (stream->segment.stop)) + stream->accumulated_base += + (stream->segment.stop - + stream->segment.start) / ABS (stream->segment.rate); continue; } @@ -2241,6 +2259,31 @@ gst_qtdemux_map_and_push_segments (GstQTDemux * qtdemux, GstSegment * segment) } } +static void +gst_qtdemux_stream_concat (GstQTDemux * qtdemux, GPtrArray * dest, + GPtrArray * src) +{ + guint i; + guint len; + + len = src->len; + + if (len == 0) + return; + + for (i = 0; i < len; i++) { + QtDemuxStream *stream = g_ptr_array_index (src, i); + +#ifndef GST_DISABLE_GST_DEBUG + GST_DEBUG_OBJECT (qtdemux, "Move stream %p (stream-id %s) to %p", + stream, GST_STR_NULL (stream->stream_id), dest); +#endif + g_ptr_array_add (dest, gst_qtdemux_stream_ref (stream)); + } + + g_ptr_array_set_size (src, 0); +} + static gboolean gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstObject * parent, GstEvent * event) @@ -2263,19 +2306,15 @@ gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstObject * parent, GST_DEBUG_OBJECT (demux, "received newsegment %" GST_SEGMENT_FORMAT, &segment); - /* erase any previously set segment */ - gst_event_replace (&demux->pending_newsegment, NULL); - if (segment.format == GST_FORMAT_TIME) { - GST_DEBUG_OBJECT (demux, "new pending_newsegment"); - gst_event_replace (&demux->pending_newsegment, event); demux->upstream_format_is_time = TRUE; + demux->segment_seqnum = gst_event_get_seqnum (event); } else { GST_DEBUG_OBJECT (demux, "Not storing upstream newsegment, " "not in time format"); /* chain will send initial newsegment after pads have been added */ - if (demux->state != QTDEMUX_STATE_MOVIE || !demux->n_streams) { + if (demux->state != QTDEMUX_STATE_MOVIE || !QTDEMUX_N_STREAMS (demux)) { GST_DEBUG_OBJECT (demux, "still starting, eating event"); goto exit; } @@ -2343,17 +2382,9 @@ gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstObject * parent, GST_DEBUG_OBJECT (demux, "Pushing newseg %" GST_SEGMENT_FORMAT, &segment); /* map segment to internal qt segments and push on each stream */ - if (demux->n_streams) { - if (demux->fragmented) { - GstEvent *segment_event = gst_event_new_segment (&segment); - - gst_event_replace (&demux->pending_newsegment, NULL); - gst_event_set_seqnum (segment_event, demux->segment_seqnum); - gst_qtdemux_push_event (demux, segment_event); - } else { - gst_event_replace (&demux->pending_newsegment, NULL); - gst_qtdemux_map_and_push_segments (demux, &segment); - } + if (QTDEMUX_N_STREAMS (demux)) { + demux->need_segment = TRUE; + gst_qtdemux_check_send_pending_segment (demux); } /* clear leftover in current segment, if any */ @@ -2412,10 +2443,10 @@ gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstObject * parent, /* If we are in push mode, and get an EOS before we've seen any streams, * then error out - we have nowhere to send the EOS */ if (!demux->pullbased) { - GList *iter; + gint i; gboolean has_valid_stream = FALSE; - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { - if (QTDEMUX_STREAM (iter->data)->pad != NULL) { + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { + if (QTDEMUX_NTH_STREAM (demux, i)->pad != NULL) { has_valid_stream = TRUE; break; } @@ -2464,9 +2495,10 @@ gst_qtdemux_handle_sink_event (GstPad * sinkpad, GstObject * parent, gst_qtdemux_process_adapter (demux, TRUE); gst_qtdemux_reset (demux, FALSE); /* We expect new moov box after new stream-start event */ - demux->old_streams = - g_list_concat (demux->old_streams, demux->active_streams); - demux->active_streams = NULL; + if (demux->exposed) { + gst_qtdemux_stream_concat (demux, + demux->old_streams, demux->active_streams); + } goto drop; } @@ -2480,6 +2512,46 @@ drop: return res; } +static gboolean +gst_qtdemux_handle_sink_query (GstPad * pad, GstObject * parent, + GstQuery * query) +{ + GstQTDemux *demux = GST_QTDEMUX (parent); + gboolean res = FALSE; + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_BITRATE: + { + GstClockTime duration; + + /* populate demux->upstream_size if not done yet */ + gst_qtdemux_check_seekability (demux); + + if (demux->upstream_size != -1 + && gst_qtdemux_get_duration (demux, &duration)) { + guint bitrate = + gst_util_uint64_scale (8 * demux->upstream_size, GST_SECOND, + duration); + + GST_LOG_OBJECT (demux, "bitrate query byte length: %" G_GUINT64_FORMAT + " duration %" GST_TIME_FORMAT " resulting a bitrate of %u", + demux->upstream_size, GST_TIME_ARGS (duration), bitrate); + + /* TODO: better results based on ranges/index tables */ + gst_query_set_bitrate (query, bitrate); + res = TRUE; + } + break; + } + default: + res = gst_pad_query_default (pad, (GstObject *) demux, query); + break; + } + + return res; +} + + #if 0 static void gst_qtdemux_set_index (GstElement * element, GstIndex * index) @@ -2588,7 +2660,9 @@ gst_qtdemux_stream_clear (QtDemuxStream * stream) entry->sparse = FALSE; } - gst_tag_list_unref (stream->stream_tags); + if (stream->stream_tags) + gst_tag_list_unref (stream->stream_tags); + stream->stream_tags = gst_tag_list_new_empty (); gst_tag_list_set_scope (stream->stream_tags, GST_TAG_SCOPE_STREAM); g_free (stream->redirect_uri); @@ -2633,27 +2707,28 @@ gst_qtdemux_stream_reset (QtDemuxStream * stream) stream->stsd_entries_length = 0; } - -static void -gst_qtdemux_stream_free (QtDemuxStream * stream) +static QtDemuxStream * +gst_qtdemux_stream_ref (QtDemuxStream * stream) { - gst_qtdemux_stream_reset (stream); - gst_tag_list_unref (stream->stream_tags); - if (stream->pad) { - GstQTDemux *demux = stream->demux; - gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->pad); - gst_flow_combiner_remove_pad (demux->flowcombiner, stream->pad); - } - g_free (stream->stream_id); - g_free (stream); + g_atomic_int_add (&stream->ref_count, 1); + + return stream; } static void -gst_qtdemux_remove_stream (GstQTDemux * qtdemux, QtDemuxStream * stream) +gst_qtdemux_stream_unref (QtDemuxStream * stream) { - qtdemux->active_streams = g_list_remove (qtdemux->active_streams, stream); - gst_qtdemux_stream_free (stream); - qtdemux->n_streams--; + if (g_atomic_int_dec_and_test (&stream->ref_count)) { + gst_qtdemux_stream_reset (stream); + gst_tag_list_unref (stream->stream_tags); + if (stream->pad) { + GstQTDemux *demux = stream->demux; + gst_element_remove_pad (GST_ELEMENT_CAST (demux), stream->pad); + gst_flow_combiner_remove_pad (demux->flowcombiner, stream->pad); + } + g_free (stream->stream_id); + g_free (stream); + } } static GstStateChangeReturn @@ -2685,6 +2760,28 @@ gst_qtdemux_change_state (GstElement * element, GstStateChange transition) } static void +gst_qtdemux_set_context (GstElement * element, GstContext * context) +{ + GstQTDemux *qtdemux = GST_QTDEMUX (element); + + g_return_if_fail (GST_IS_CONTEXT (context)); + + if (gst_context_has_context_type (context, + "drm-preferred-decryption-system-id")) { + const GstStructure *s; + + s = gst_context_get_structure (context); + g_free (qtdemux->preferred_protection_system_id); + qtdemux->preferred_protection_system_id = + g_strdup (gst_structure_get_string (s, "decryption-system-id")); + GST_DEBUG_OBJECT (element, "set preferred decryption system to %s", + qtdemux->preferred_protection_system_id); + } + + GST_ELEMENT_CLASS (parent_class)->set_context (element, context); +} + +static void qtdemux_parse_ftyp (GstQTDemux * qtdemux, const guint8 * buffer, gint length) { /* counts as header data */ @@ -2726,6 +2823,62 @@ qtdemux_handle_xmp_taglist (GstQTDemux * qtdemux, GstTagList * taglist, } static void +qtdemux_update_default_sample_encryption_settings (GstQTDemux * qtdemux, + QtDemuxCencSampleSetInfo * info, guint32 is_encrypted, guint8 iv_size, + const guint8 * kid) +{ + GstBuffer *kid_buf = gst_buffer_new_allocate (NULL, 16, NULL); + gst_buffer_fill (kid_buf, 0, kid, 16); + if (info->default_properties) + gst_structure_free (info->default_properties); + info->default_properties = + gst_structure_new ("application/x-cenc", + "iv_size", G_TYPE_UINT, iv_size, + "encrypted", G_TYPE_BOOLEAN, (is_encrypted == 1), + "kid", GST_TYPE_BUFFER, kid_buf, NULL); + GST_DEBUG_OBJECT (qtdemux, "default sample properties: " + "is_encrypted=%u, iv_size=%u", is_encrypted, iv_size); + gst_buffer_unref (kid_buf); +} + +static gboolean +qtdemux_update_default_piff_encryption_settings (GstQTDemux * qtdemux, + QtDemuxCencSampleSetInfo * info, GstByteReader * br) +{ + guint32 algorithm_id = 0; + const guint8 *kid; + gboolean is_encrypted = TRUE; + guint8 iv_size = 8; + + if (!gst_byte_reader_get_uint24_le (br, &algorithm_id)) { + GST_ERROR_OBJECT (qtdemux, "Error getting box's algorithm ID field"); + return FALSE; + } + + algorithm_id >>= 8; + if (algorithm_id == 0) { + is_encrypted = FALSE; + } else if (algorithm_id == 1) { + GST_DEBUG_OBJECT (qtdemux, "AES 128-bits CTR encrypted stream"); + } else if (algorithm_id == 2) { + GST_DEBUG_OBJECT (qtdemux, "AES 128-bits CBC encrypted stream"); + } + + if (!gst_byte_reader_get_uint8 (br, &iv_size)) + return FALSE; + + if (!gst_byte_reader_get_data (br, 16, &kid)) + return FALSE; + + qtdemux_update_default_sample_encryption_settings (qtdemux, info, + is_encrypted, iv_size, kid); + gst_structure_set (info->default_properties, "piff_algorithm_id", + G_TYPE_UINT, algorithm_id, NULL); + return TRUE; +} + + +static void qtdemux_parse_piff (GstQTDemux * qtdemux, const guint8 * buffer, gint length, guint offset) { @@ -2733,7 +2886,7 @@ qtdemux_parse_piff (GstQTDemux * qtdemux, const guint8 * buffer, gint length, guint8 version; guint32 flags = 0; guint i; - guint8 iv_size = 8; + guint iv_size = 8; QtDemuxStream *stream; GstStructure *structure; QtDemuxCencSampleSetInfo *ss_info = NULL; @@ -2741,10 +2894,11 @@ qtdemux_parse_piff (GstQTDemux * qtdemux, const guint8 * buffer, gint length, gboolean uses_sub_sample_encryption = FALSE; guint32 sample_count; - stream = QTDEMUX_FIRST_STREAM (qtdemux); - if (!stream) + if (QTDEMUX_N_STREAMS (qtdemux) == 0) return; + stream = QTDEMUX_NTH_STREAM (qtdemux, 0); + structure = gst_caps_get_structure (CUR_STREAM (stream)->caps, 0); if (!gst_structure_has_name (structure, "application/x-cenc")) { GST_WARNING_OBJECT (qtdemux, @@ -2763,13 +2917,13 @@ qtdemux_parse_piff (GstQTDemux * qtdemux, const guint8 * buffer, gint length, stream->protection_scheme_info = g_new0 (QtDemuxCencSampleSetInfo, 1); ss_info = (QtDemuxCencSampleSetInfo *) stream->protection_scheme_info; + if (!ss_info->default_properties) { + ss_info->default_properties = + gst_structure_new ("application/x-cenc", + "iv_size", G_TYPE_UINT, iv_size, "encrypted", G_TYPE_BOOLEAN, TRUE, + NULL); - if (ss_info->default_properties) - gst_structure_free (ss_info->default_properties); - - ss_info->default_properties = - gst_structure_new ("application/x-cenc", - "iv_size", G_TYPE_UINT, iv_size, "encrypted", G_TYPE_BOOLEAN, TRUE, NULL); + } if (ss_info->crypto_info) { GST_LOG_OBJECT (qtdemux, "unreffing existing crypto_info"); @@ -2791,49 +2945,19 @@ qtdemux_parse_piff (GstQTDemux * qtdemux, const guint8 * buffer, gint length, } if ((flags & 0x000001)) { - guint32 algorithm_id = 0; - const guint8 *kid; - GstBuffer *kid_buf; - gboolean is_encrypted = TRUE; - - if (!gst_byte_reader_get_uint24_le (&br, &algorithm_id)) { - GST_ERROR_OBJECT (qtdemux, "Error getting box's algorithm ID field"); - return; - } - - algorithm_id >>= 8; - if (algorithm_id == 0) { - is_encrypted = FALSE; - } else if (algorithm_id == 1) { - /* FIXME: maybe store this in properties? */ - GST_DEBUG_OBJECT (qtdemux, "AES 128-bits CTR encrypted stream"); - } else if (algorithm_id == 2) { - /* FIXME: maybe store this in properties? */ - GST_DEBUG_OBJECT (qtdemux, "AES 128-bits CBC encrypted stream"); - } - - if (!gst_byte_reader_get_uint8 (&br, &iv_size)) - return; - - if (!gst_byte_reader_get_data (&br, 16, &kid)) + if (!qtdemux_update_default_piff_encryption_settings (qtdemux, ss_info, + &br)) return; - - kid_buf = gst_buffer_new_allocate (NULL, 16, NULL); - gst_buffer_fill (kid_buf, 0, kid, 16); - if (ss_info->default_properties) - gst_structure_free (ss_info->default_properties); - ss_info->default_properties = - gst_structure_new ("application/x-cenc", - "iv_size", G_TYPE_UINT, iv_size, - "encrypted", G_TYPE_BOOLEAN, is_encrypted, - "kid", GST_TYPE_BUFFER, kid_buf, NULL); - GST_DEBUG_OBJECT (qtdemux, "default sample properties: " - "is_encrypted=%u, iv_size=%u", is_encrypted, iv_size); - gst_buffer_unref (kid_buf); } else if ((flags & 0x000002)) { uses_sub_sample_encryption = TRUE; } + if (!gst_structure_get_uint (ss_info->default_properties, "iv_size", + &iv_size)) { + GST_ERROR_OBJECT (qtdemux, "Error getting encryption IV size field"); + return; + } + if (!gst_byte_reader_get_uint32_be (&br, &sample_count)) { GST_ERROR_OBJECT (qtdemux, "Error getting box's sample count field"); return; @@ -2867,6 +2991,7 @@ qtdemux_parse_piff (GstQTDemux * qtdemux, const guint8 * buffer, gint length, if (uses_sub_sample_encryption) { guint16 n_subsamples; + const GValue *kid_buf_value; if (!gst_byte_reader_get_uint16_be (&br, &n_subsamples) || n_subsamples == 0) { @@ -2885,9 +3010,14 @@ qtdemux_parse_piff (GstQTDemux * qtdemux, const guint8 * buffer, gint length, return; } buf = gst_buffer_new_wrapped (data, n_subsamples * 6); + + kid_buf_value = + gst_structure_get_value (ss_info->default_properties, "kid"); + gst_structure_set (properties, "subsample_count", G_TYPE_UINT, n_subsamples, "subsamples", GST_TYPE_BUFFER, buf, NULL); + gst_structure_set_value (properties, "kid", kid_buf_value); gst_buffer_unref (buf); } else { gst_structure_set (properties, "subsample_count", G_TYPE_UINT, 0, NULL); @@ -3121,7 +3251,6 @@ check_update_duration (GstQTDemux * qtdemux, GstClockTime duration) guint i; guint64 movdur; GstClockTime prevdur; - GList *iter; movdur = GSTTIME_TO_QTTIME (qtdemux, duration); @@ -3146,9 +3275,9 @@ check_update_duration (GstQTDemux * qtdemux, GstClockTime duration) qtdemux->segment.stop = fixeddur; } } - for (iter = qtdemux->active_streams, i = 0; iter; - iter = g_list_next (iter), i++) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); movdur = GSTTIME_TO_QTSTREAMTIME (stream, duration); if (movdur > stream->duration) { @@ -3467,7 +3596,7 @@ static inline QtDemuxStream * qtdemux_find_stream (GstQTDemux * qtdemux, guint32 id) { QtDemuxStream *stream; - GList *iter; + gint i; /* check */ if (G_UNLIKELY (!id)) { @@ -3475,14 +3604,14 @@ qtdemux_find_stream (GstQTDemux * qtdemux, guint32 id) return NULL; } - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + stream = QTDEMUX_NTH_STREAM (qtdemux, i); if (stream->track_id == id) return stream; } if (qtdemux->mss_mode) { /* mss should have only 1 stream anyway */ - return QTDEMUX_FIRST_STREAM (qtdemux); + return QTDEMUX_NTH_STREAM (qtdemux, 0); } return NULL; @@ -3895,7 +4024,7 @@ qtdemux_parse_pssh (GstQTDemux * qtdemux, GNode * node) GstBuffer *pssh = NULL; GstEvent *event = NULL; guint32 parent_box_type; - GList *iter; + gint i; if (G_UNLIKELY (pssh_size < 32U)) { GST_ERROR_OBJECT (qtdemux, "invalid box size"); @@ -3916,8 +4045,11 @@ qtdemux_parse_pssh (GstQTDemux * qtdemux, GNode * node) /* Push an event containing the pssh box onto the queues of all streams. */ event = gst_event_new_protection (sysid_string, pssh, (parent_box_type == FOURCC_moov) ? "isobmff/moov" : "isobmff/moof"); - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); + GST_TRACE_OBJECT (qtdemux, + "adding protection event for stream %s and system %s", + stream->stream_id, sysid_string); g_queue_push_tail (&stream->protection_scheme_event_queue, gst_event_ref (event)); } @@ -3939,6 +4071,7 @@ qtdemux_parse_moof (GstQTDemux * qtdemux, const guint8 * buffer, guint length, guint32 ds_size = 0, ds_duration = 0, ds_flags = 0; gint64 base_offset, running_offset; guint32 frag_num; + GstClockTime min_dts = GST_CLOCK_TIME_NONE; /* NOTE @stream ignored */ @@ -4059,8 +4192,19 @@ qtdemux_parse_moof (GstQTDemux * qtdemux, const guint8 * buffer, guint length, if (G_UNLIKELY (base_offset < -1)) goto lost_offset; - if (qtdemux->upstream_format_is_time) + min_dts = MIN (min_dts, QTSTREAMTIME_TO_GSTTIME (stream, decode_time)); + + if (!qtdemux->pullbased) { + /* Sample tables can grow enough to be problematic if the system memory + * is very low (e.g. embedded devices) and the videos very long + * (~8 MiB/hour for 25-30 fps video + typical AAC audio frames). + * Fortunately, we can easily discard them for each new fragment when + * we know qtdemux will not receive seeks outside of the current fragment. + * adaptivedemux honors this assumption. + * This optimization is also useful for applications that use qtdemux as + * a push-based simple demuxer, like Media Source Extensions. */ gst_qtdemux_stream_flush_samples_data (stream); + } /* initialise moof sample data */ stream->n_samples_moof = 0; @@ -4109,6 +4253,38 @@ qtdemux_parse_moof (GstQTDemux * qtdemux, const guint8 * buffer, guint length, pssh_node = qtdemux_tree_get_sibling_by_type (pssh_node, FOURCC_pssh); } + if (!qtdemux->upstream_format_is_time && !qtdemux->first_moof_already_parsed + && !qtdemux->received_seek && GST_CLOCK_TIME_IS_VALID (min_dts) + && min_dts != 0) { + /* Unless the user has explictly requested another seek, perform an + * internal seek to the time specified in the tfdt. + * + * This way if the user opens a file where the first tfdt is 1 hour + * into the presentation, they will not have to wait 1 hour for run + * time to catch up and actual playback to start. */ + gint i; + + GST_DEBUG_OBJECT (qtdemux, "First fragment has a non-zero tfdt, " + "performing an internal seek to %" GST_TIME_FORMAT, + GST_TIME_ARGS (min_dts)); + + qtdemux->segment.start = min_dts; + qtdemux->segment.time = qtdemux->segment.position = min_dts; + + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); + stream->time_position = min_dts; + } + + /* Before this code was run a segment was already sent when the moov was + * parsed... which is OK -- some apps (mostly tests) expect a segment to + * be emitted after a moov, and we can emit a second segment anyway for + * special cases like this. */ + qtdemux->need_segment = TRUE; + } + + qtdemux->first_moof_already_parsed = TRUE; + g_node_destroy (moof_node); return TRUE; @@ -4573,13 +4749,13 @@ gst_qtdemux_seek_to_previous_keyframe (GstQTDemux * qtdemux) QtDemuxStream *ref_str = NULL; guint64 seg_media_start_mov; /* segment media start time in mov format */ guint64 target_ts; - GList *iter; + gint i; /* Now we choose an arbitrary stream, get the previous keyframe timestamp * and finally align all the other streams on that timestamp with their * respective keyframes */ - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *str = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *str = QTDEMUX_NTH_STREAM (qtdemux, i); /* No candidate yet, take the first stream */ if (!ref_str) { @@ -4627,7 +4803,7 @@ gst_qtdemux_seek_to_previous_keyframe (GstQTDemux * qtdemux) seg_media_start_mov = seg->trak_media_start; GST_LOG_OBJECT (qtdemux, "keyframe index %u ts %" G_GUINT64_FORMAT - " seg start %" G_GUINT64_FORMAT " %" GST_TIME_FORMAT "\n", + " seg start %" G_GUINT64_FORMAT " %" GST_TIME_FORMAT, k_index, target_ts, seg_media_start_mov, GST_TIME_ARGS (seg->media_start)); @@ -4674,10 +4850,10 @@ gst_qtdemux_seek_to_previous_keyframe (GstQTDemux * qtdemux) ref_k_index = k_index; /* Align them all on this */ - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { guint32 index = 0; GstClockTime seg_time = 0; - QtDemuxStream *str = QTDEMUX_STREAM (iter->data); + QtDemuxStream *str = QTDEMUX_NTH_STREAM (qtdemux, i); /* aligning reference stream again might lead to backing up to yet another * keyframe (due to timestamp rounding issues), @@ -5038,8 +5214,8 @@ gst_qtdemux_prepare_current_sample (GstQTDemux * qtdemux, if (G_UNLIKELY (stream->segment_index != seg_idx)) gst_qtdemux_activate_segment (qtdemux, stream, seg_idx, time_position); - if (G_UNLIKELY (QTSEGMENT_IS_EMPTY (&stream->segments[stream-> - segment_index]))) { + if (G_UNLIKELY (QTSEGMENT_IS_EMPTY (&stream-> + segments[stream->segment_index]))) { QtDemuxSegment *seg = &stream->segments[stream->segment_index]; GST_LOG_OBJECT (qtdemux, "Empty segment activated," @@ -5191,16 +5367,16 @@ next_segment: static void gst_qtdemux_sync_streams (GstQTDemux * demux) { - GList *iter; + gint i; - if (demux->n_streams <= 1) + if (QTDEMUX_N_STREAMS (demux) <= 1) return; - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { QtDemuxStream *stream; GstClockTime end_time; - stream = QTDEMUX_STREAM (iter->data); + stream = QTDEMUX_NTH_STREAM (demux, i); if (!stream->pad) continue; @@ -5430,7 +5606,7 @@ gst_qtdemux_align_buffer (GstQTDemux * demux, } static guint8 * -convert_to_ccdata (const guint8 * ccpair, guint8 ccpair_size, guint field, +convert_to_s334_1a (const guint8 * ccpair, guint8 ccpair_size, guint field, gsize * res) { guint8 *storage; @@ -5440,10 +5616,11 @@ convert_to_ccdata (const guint8 * ccpair, guint8 ccpair_size, guint field, *res = ccpair_size / 2 * 3; storage = g_malloc (*res); for (i = 0; i * 2 < ccpair_size; i += 1) { + /* FIXME: Use line offset 0 as we simply can't know here */ if (field == 1) - storage[i * 3] = 0xfc; + storage[i * 3] = 0x80 | 0x00; else - storage[i * 3] = 0xfd; + storage[i * 3] = 0x00 | 0x00; storage[i * 3 + 1] = ccpair[i * 2]; storage[i * 3 + 2] = ccpair[i * 2 + 1]; } @@ -5487,11 +5664,11 @@ extract_cc_from_data (QtDemuxStream * stream, const guint8 * data, gsize size, goto invalid_cdat; } - /* Convert to cc_data triplet */ + /* Convert to S334-1 Annex A byte triplet */ if (fourcc == FOURCC_cdat) - cdat = convert_to_ccdata (data + 8, atom_length - 8, 1, &cdat_size); + cdat = convert_to_s334_1a (data + 8, atom_length - 8, 1, &cdat_size); else - cdt2 = convert_to_ccdata (data + 8, atom_length - 8, 2, &cdt2_size); + cdt2 = convert_to_s334_1a (data + 8, atom_length - 8, 2, &cdt2_size); GST_DEBUG_OBJECT (stream->pad, "size:%" G_GSIZE_FORMAT " atom_length:%u", size, atom_length); @@ -5503,7 +5680,7 @@ extract_cc_from_data (QtDemuxStream * stream, const guint8 * data, gsize size, if (fourcc == FOURCC_cdat) { if (cdat == NULL) cdat = - convert_to_ccdata (data + atom_length + 8, + convert_to_s334_1a (data + atom_length + 8, new_atom_length - 8, 1, &cdat_size); else GST_WARNING_OBJECT (stream->pad, @@ -5511,7 +5688,7 @@ extract_cc_from_data (QtDemuxStream * stream, const guint8 * data, gsize size, } else { if (cdt2 == NULL) cdt2 = - convert_to_ccdata (data + atom_length + 8, + convert_to_s334_1a (data + atom_length + 8, new_atom_length - 8, 2, &cdt2_size); else GST_WARNING_OBJECT (stream->pad, @@ -5634,6 +5811,210 @@ gst_qtdemux_process_buffer (GstQTDemux * qtdemux, QtDemuxStream * stream, return buf; } +static GstFlowReturn +gst_qtdemux_push_buffer (GstQTDemux * qtdemux, QtDemuxStream * stream, + GstBuffer * buf) +{ + GstFlowReturn ret = GST_FLOW_OK; + GstClockTime pts, duration; + + if (stream->need_clip) + buf = gst_qtdemux_clip_buffer (qtdemux, stream, buf); + + if (G_UNLIKELY (buf == NULL)) + goto exit; + + if (G_UNLIKELY (stream->discont)) { + GST_LOG_OBJECT (qtdemux, "marking discont buffer"); + GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); + stream->discont = FALSE; + } else { + GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT); + } + + GST_LOG_OBJECT (qtdemux, + "Pushing buffer with dts %" GST_TIME_FORMAT ", pts %" GST_TIME_FORMAT + ", duration %" GST_TIME_FORMAT " on pad %s", + GST_TIME_ARGS (GST_BUFFER_DTS (buf)), + GST_TIME_ARGS (GST_BUFFER_PTS (buf)), + GST_TIME_ARGS (GST_BUFFER_DURATION (buf)), GST_PAD_NAME (stream->pad)); + + if (stream->protected && stream->protection_scheme_type == FOURCC_cenc) { + GstStructure *crypto_info; + QtDemuxCencSampleSetInfo *info = + (QtDemuxCencSampleSetInfo *) stream->protection_scheme_info; + gint index; + GstEvent *event; + + while ((event = g_queue_pop_head (&stream->protection_scheme_event_queue))) { + GST_TRACE_OBJECT (stream->pad, "pushing protection event: %" + GST_PTR_FORMAT, event); + gst_pad_push_event (stream->pad, event); + } + + if (info->crypto_info == NULL) { + GST_DEBUG_OBJECT (qtdemux, + "cenc metadata hasn't been parsed yet, pushing buffer as if it wasn't encrypted"); + } else { + /* The end of the crypto_info array matches our n_samples position, + * so count backward from there */ + index = stream->sample_index - stream->n_samples + info->crypto_info->len; + if (G_LIKELY (index >= 0 && index < info->crypto_info->len)) { + /* steal structure from array */ + crypto_info = g_ptr_array_index (info->crypto_info, index); + g_ptr_array_index (info->crypto_info, index) = NULL; + GST_LOG_OBJECT (qtdemux, "attaching cenc metadata [%u/%u]", index, + info->crypto_info->len); + if (!crypto_info || !gst_buffer_add_protection_meta (buf, crypto_info)) + GST_ERROR_OBJECT (qtdemux, + "failed to attach cenc metadata to buffer"); + } else { + GST_INFO_OBJECT (qtdemux, "No crypto info with index %d and sample %d", + index, stream->sample_index); + } + } + } + + if (stream->alignment > 1) + buf = gst_qtdemux_align_buffer (qtdemux, buf, stream->alignment); + + pts = GST_BUFFER_PTS (buf); + duration = GST_BUFFER_DURATION (buf); + + ret = gst_pad_push (stream->pad, buf); + + if (GST_CLOCK_TIME_IS_VALID (pts) && GST_CLOCK_TIME_IS_VALID (duration)) { + /* mark position in stream, we'll need this to know when to send GAP event */ + stream->segment.position = pts + duration; + } + +exit: + + return ret; +} + +static GstFlowReturn +gst_qtdemux_split_and_push_buffer (GstQTDemux * qtdemux, QtDemuxStream * stream, + GstBuffer * buf) +{ + GstFlowReturn ret = GST_FLOW_OK; + + if (stream->subtype == FOURCC_clcp + && CUR_STREAM (stream)->fourcc == FOURCC_c608 && stream->need_split) { + GstMapInfo map; + guint n_output_buffers, n_field1 = 0, n_field2 = 0; + guint n_triplets, i; + guint field1_off = 0, field2_off = 0; + + /* We have to split CEA608 buffers so that each outgoing buffer contains + * one byte pair per field according to the framerate of the video track. + * + * If there is only a single byte pair per field we don't have to do + * anything + */ + + gst_buffer_map (buf, &map, GST_MAP_READ); + + n_triplets = map.size / 3; + for (i = 0; i < n_triplets; i++) { + if (map.data[3 * i] & 0x80) + n_field1++; + else + n_field2++; + } + + g_assert (n_field1 || n_field2); + + /* If there's more than 1 frame we have to split, otherwise we can just + * pass through */ + if (n_field1 > 1 || n_field2 > 1) { + n_output_buffers = + gst_util_uint64_scale (GST_BUFFER_DURATION (buf), + CUR_STREAM (stream)->fps_n, GST_SECOND * CUR_STREAM (stream)->fps_d); + + for (i = 0; i < n_output_buffers; i++) { + GstBuffer *outbuf = + gst_buffer_new_and_alloc ((n_field1 ? 3 : 0) + (n_field2 ? 3 : 0)); + GstMapInfo outmap; + guint8 *outptr; + + gst_buffer_map (outbuf, &outmap, GST_MAP_WRITE); + outptr = outmap.data; + + if (n_field1) { + gboolean found = FALSE; + + while (map.data + field1_off < map.data + map.size) { + if (map.data[field1_off] & 0x80) { + memcpy (outptr, &map.data[field1_off], 3); + field1_off += 3; + found = TRUE; + break; + } + field1_off += 3; + } + + if (!found) { + const guint8 empty[] = { 0x80, 0x80, 0x80 }; + + memcpy (outptr, empty, 3); + } + + outptr += 3; + } + + if (n_field2) { + gboolean found = FALSE; + + while (map.data + field2_off < map.data + map.size) { + if ((map.data[field2_off] & 0x80) == 0) { + memcpy (outptr, &map.data[field2_off], 3); + field2_off += 3; + found = TRUE; + break; + } + field2_off += 3; + } + + if (!found) { + const guint8 empty[] = { 0x00, 0x80, 0x80 }; + + memcpy (outptr, empty, 3); + } + + outptr += 3; + } + + gst_buffer_unmap (outbuf, &outmap); + + GST_BUFFER_PTS (outbuf) = + GST_BUFFER_PTS (buf) + gst_util_uint64_scale (i, + GST_SECOND * CUR_STREAM (stream)->fps_d, + CUR_STREAM (stream)->fps_n); + GST_BUFFER_DURATION (outbuf) = + gst_util_uint64_scale (GST_SECOND, CUR_STREAM (stream)->fps_d, + CUR_STREAM (stream)->fps_n); + GST_BUFFER_OFFSET (outbuf) = -1; + GST_BUFFER_OFFSET_END (outbuf) = -1; + + ret = gst_qtdemux_push_buffer (qtdemux, stream, outbuf); + + if (ret != GST_FLOW_OK && ret != GST_FLOW_NOT_LINKED) + break; + } + gst_buffer_unmap (buf, &map); + gst_buffer_unref (buf); + } else { + gst_buffer_unmap (buf, &map); + ret = gst_qtdemux_push_buffer (qtdemux, stream, buf); + } + } else { + ret = gst_qtdemux_push_buffer (qtdemux, stream, buf); + } + + return ret; +} + /* Sets a buffer's attributes properly and pushes it downstream. * Also checks for additional actions and custom processing that may * need to be done first. @@ -5716,6 +6097,13 @@ gst_qtdemux_decorate_and_push_buffer (GstQTDemux * qtdemux, GST_BUFFER_OFFSET (buf) = -1; GST_BUFFER_OFFSET_END (buf) = -1; + if (!keyframe) { + GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); + stream->on_keyframe = FALSE; + } else { + stream->on_keyframe = TRUE; + } + if (G_UNLIKELY (CUR_STREAM (stream)->rgb8_palette)) gst_buffer_append_memory (buf, gst_memory_ref (CUR_STREAM (stream)->rgb8_palette)); @@ -5743,77 +6131,7 @@ gst_qtdemux_decorate_and_push_buffer (GstQTDemux * qtdemux, } #endif - if (stream->need_clip) - buf = gst_qtdemux_clip_buffer (qtdemux, stream, buf); - - if (G_UNLIKELY (buf == NULL)) - goto exit; - - if (G_UNLIKELY (stream->discont)) { - GST_LOG_OBJECT (qtdemux, "marking discont buffer"); - GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); - stream->discont = FALSE; - } else { - GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT); - } - - if (!keyframe) { - GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); - stream->on_keyframe = FALSE; - } else { - stream->on_keyframe = TRUE; - } - - - GST_LOG_OBJECT (qtdemux, - "Pushing buffer with dts %" GST_TIME_FORMAT ", pts %" GST_TIME_FORMAT - ", duration %" GST_TIME_FORMAT " on pad %s", GST_TIME_ARGS (dts), - GST_TIME_ARGS (pts), GST_TIME_ARGS (duration), - GST_PAD_NAME (stream->pad)); - - if (stream->protected && stream->protection_scheme_type == FOURCC_cenc) { - GstStructure *crypto_info; - QtDemuxCencSampleSetInfo *info = - (QtDemuxCencSampleSetInfo *) stream->protection_scheme_info; - gint index; - GstEvent *event; - - while ((event = g_queue_pop_head (&stream->protection_scheme_event_queue))) { - gst_pad_push_event (stream->pad, event); - } - - if (info->crypto_info == NULL) { - GST_DEBUG_OBJECT (qtdemux, "cenc metadata hasn't been parsed yet"); - gst_buffer_unref (buf); - goto exit; - } - - /* The end of the crypto_info array matches our n_samples position, - * so count backward from there */ - index = stream->sample_index - stream->n_samples + info->crypto_info->len; - if (G_LIKELY (index >= 0 && index < info->crypto_info->len)) { - /* steal structure from array */ - crypto_info = g_ptr_array_index (info->crypto_info, index); - g_ptr_array_index (info->crypto_info, index) = NULL; - GST_LOG_OBJECT (qtdemux, "attaching cenc metadata [%u/%u]", index, - info->crypto_info->len); - if (!crypto_info || !gst_buffer_add_protection_meta (buf, crypto_info)) - GST_ERROR_OBJECT (qtdemux, "failed to attach cenc metadata to buffer"); - } else { - GST_INFO_OBJECT (qtdemux, "No crypto info with index %d and sample %d", - index, stream->sample_index); - } - } - - if (stream->alignment > 1) - buf = gst_qtdemux_align_buffer (qtdemux, buf, stream->alignment); - - ret = gst_pad_push (stream->pad, buf); - - if (GST_CLOCK_TIME_IS_VALID (pts) && GST_CLOCK_TIME_IS_VALID (duration)) { - /* mark position in stream, we'll need this to know when to send GAP event */ - stream->segment.position = pts + duration; - } + ret = gst_qtdemux_split_and_push_buffer (qtdemux, stream, buf); exit: return ret; @@ -5848,20 +6166,20 @@ static gboolean gst_qtdemux_do_fragmented_seek (GstQTDemux * qtdemux) { const QtDemuxRandomAccessEntry *best_entry = NULL; - GList *iter; + gint i; GST_OBJECT_LOCK (qtdemux); - g_assert (qtdemux->n_streams > 0); + g_assert (QTDEMUX_N_STREAMS (qtdemux) > 0); /* first see if we can determine where to go to using mfra, * before we start clearing things */ - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { const QtDemuxRandomAccessEntry *entry; QtDemuxStream *stream; gboolean is_audio_or_video; - stream = QTDEMUX_STREAM (iter->data); + stream = QTDEMUX_NTH_STREAM (qtdemux, i); if (stream->ra_entries == NULL) continue; @@ -5895,10 +6213,10 @@ gst_qtdemux_do_fragmented_seek (GstQTDemux * qtdemux) } /* ok, now we can prepare for processing as of located moof */ - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { QtDemuxStream *stream; - stream = QTDEMUX_STREAM (iter->data); + stream = QTDEMUX_NTH_STREAM (qtdemux, i); g_free (stream->samples); stream->samples = NULL; @@ -5921,7 +6239,7 @@ gst_qtdemux_do_fragmented_seek (GstQTDemux * qtdemux) GST_INFO_OBJECT (qtdemux, "seek to %" GST_TIME_FORMAT ", best fragment " "moof offset: %" G_GUINT64_FORMAT ", ts %" GST_TIME_FORMAT, - GST_TIME_ARGS (QTDEMUX_FIRST_STREAM (qtdemux)->time_position), + GST_TIME_ARGS (QTDEMUX_NTH_STREAM (qtdemux, 0)->time_position), best_entry->moof_offset, GST_TIME_ARGS (best_entry->ts)); qtdemux->moof_offset = best_entry->moof_offset; @@ -5947,9 +6265,7 @@ gst_qtdemux_loop_state_movie (GstQTDemux * qtdemux) guint sample_size = 0; gboolean empty = 0; guint size; - GList *iter; - - gst_qtdemux_push_pending_newsegment (qtdemux); + gint i; if (qtdemux->fragmented_seek_pending) { GST_INFO_OBJECT (qtdemux, "pending fragmented seek"); @@ -5964,10 +6280,10 @@ gst_qtdemux_loop_state_movie (GstQTDemux * qtdemux) /* Figure out the next stream sample to output, min_time is expressed in * global time and runs over the edit list segments. */ min_time = G_MAXUINT64; - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { GstClockTime position; - stream = QTDEMUX_STREAM (iter->data); + stream = QTDEMUX_NTH_STREAM (qtdemux, i); position = stream->time_position; /* position of -1 is EOS */ @@ -5994,8 +6310,8 @@ gst_qtdemux_loop_state_movie (GstQTDemux * qtdemux) } /* gap events for subtitle streams */ - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + stream = QTDEMUX_NTH_STREAM (qtdemux, i); if (stream->pad && (stream->subtype == FOURCC_subp || stream->subtype == FOURCC_text || stream->subtype == FOURCC_sbtl)) { @@ -6021,12 +6337,12 @@ gst_qtdemux_loop_state_movie (GstQTDemux * qtdemux) gst_qtdemux_stream_check_and_change_stsd_index (qtdemux, stream); if (stream->new_caps) { gst_qtdemux_configure_stream (qtdemux, stream); - qtdemux_do_allocation (qtdemux, stream); + qtdemux_do_allocation (stream, qtdemux); } /* If we're doing a keyframe-only trickmode, only push keyframes on video streams */ - if (G_UNLIKELY (qtdemux-> - segment.flags & GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS)) { + if (G_UNLIKELY (qtdemux->segment. + flags & GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS)) { if (stream->subtype == FOURCC_vide && !keyframe) { GST_LOG_OBJECT (qtdemux, "Skipping non-keyframe on track-id %u", stream->track_id); @@ -6235,7 +6551,7 @@ pause: /* fatal errors need special actions */ /* check EOS */ if (ret == GST_FLOW_EOS) { - if (qtdemux->n_streams == 0) { + if (QTDEMUX_N_STREAMS (qtdemux) == 0) { /* we have no streams, post an error */ gst_qtdemux_post_no_playable_stream_error (qtdemux); } @@ -6302,12 +6618,12 @@ static gboolean has_next_entry (GstQTDemux * demux) { QtDemuxStream *stream; - GList *iter; + gint i; GST_DEBUG_OBJECT (demux, "Checking if there are samples not played yet"); - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { - stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { + stream = QTDEMUX_NTH_STREAM (demux, i); if (stream->sample_index == -1) { stream->sample_index = 0; @@ -6338,13 +6654,13 @@ next_entry_size (GstQTDemux * demux) QtDemuxStream *stream, *target_stream = NULL; guint64 smalloffs = (guint64) - 1; QtDemuxSample *sample; - GList *iter; + gint i; GST_LOG_OBJECT (demux, "Finding entry at offset %" G_GUINT64_FORMAT, demux->offset); - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { - stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { + stream = QTDEMUX_NTH_STREAM (demux, i); if (stream->sample_index == -1) { stream->sample_index = 0; @@ -6483,18 +6799,28 @@ gst_qtdemux_drop_data (GstQTDemux * demux, gint bytes) demux->todrop -= bytes; } +/* PUSH-MODE only: Send a segment, if not done already. */ static void gst_qtdemux_check_send_pending_segment (GstQTDemux * demux) { - if (G_UNLIKELY (demux->pending_newsegment)) { + if (G_UNLIKELY (demux->need_segment)) { gint i; - GList *iter; - gst_qtdemux_push_pending_newsegment (demux); + if (!demux->upstream_format_is_time) { + gst_qtdemux_map_and_push_segments (demux, &demux->segment); + } else { + GstEvent *segment_event; + segment_event = gst_event_new_segment (&demux->segment); + if (demux->segment_seqnum != GST_SEQNUM_INVALID) + gst_event_set_seqnum (segment_event, demux->segment_seqnum); + gst_qtdemux_push_event (demux, segment_event); + } + + demux->need_segment = FALSE; + /* clear to send tags on all streams */ - for (iter = demux->active_streams, i = 0; iter; - iter = g_list_next (iter), i++) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (demux, i); gst_qtdemux_push_tags (demux, stream); if (CUR_STREAM (stream)->sparse) { GST_INFO_OBJECT (demux, "Sending gap event on stream %d", i); @@ -6505,46 +6831,29 @@ gst_qtdemux_check_send_pending_segment (GstQTDemux * demux) } } +/* Used for push mode only. */ static void gst_qtdemux_send_gap_for_segment (GstQTDemux * demux, QtDemuxStream * stream, gint segment_index, GstClockTime pos) { GstClockTime ts, dur; - GstEvent *gap; - ts = pos; - dur = - stream->segments[segment_index].duration - (pos - - stream->segments[segment_index].time); - gap = gst_event_new_gap (ts, dur); - stream->time_position += dur; - - GST_DEBUG_OBJECT (stream->pad, "Pushing gap for empty " - "segment: %" GST_PTR_FORMAT, gap); - gst_pad_push_event (stream->pad, gap); -} - -static void -gst_qtdemux_stream_send_initial_gap_segments (GstQTDemux * demux, - QtDemuxStream * stream) -{ - gint i; + ts = pos; + dur = + stream->segments[segment_index].duration - (pos - + stream->segments[segment_index].time); + stream->time_position += dur; - /* Push any initial gap segments before proceeding to the - * 'real' data */ - for (i = 0; i < stream->n_segments; i++) { - gst_qtdemux_activate_segment (demux, stream, i, stream->time_position); + /* Only gaps with a duration of at least one second are propagated. + * Same workaround as in pull mode. + * (See 2e45926a96ec5298c6ef29bf912e5e6a06dc3e0e) */ + if (dur >= GST_SECOND) { + GstEvent *gap; + gap = gst_event_new_gap (ts, dur); - if (QTSEGMENT_IS_EMPTY (&stream->segments[i])) { - gst_qtdemux_send_gap_for_segment (demux, stream, i, - stream->time_position); - } else { - /* Only support empty segment at the beginning followed by - * one non-empty segment, this was checked when parsing the - * edts atom, arriving here is unexpected */ - g_assert (i + 1 == stream->n_segments); - break; - } + GST_DEBUG_OBJECT (stream->pad, "Pushing gap for empty " + "segment: %" GST_PTR_FORMAT, gap); + gst_pad_push_event (stream->pad, gap); } } @@ -6564,12 +6873,12 @@ gst_qtdemux_chain (GstPad * sinkpad, GstObject * parent, GstBuffer * inbuf) if (GST_BUFFER_FLAG_IS_SET (inbuf, GST_BUFFER_FLAG_DISCONT)) { gboolean is_gap_input = FALSE; - GList *iter; + gint i; GST_DEBUG_OBJECT (demux, "Got DISCONT, marking all streams as DISCONT"); - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { - QTDEMUX_STREAM (iter->data)->discont = TRUE; + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { + QTDEMUX_NTH_STREAM (demux, i)->discont = TRUE; } /* Check if we can land back on our feet in the case where upstream is @@ -6577,9 +6886,9 @@ gst_qtdemux_chain (GstPad * sinkpad, GstObject * parent, GstBuffer * inbuf) * in the case of trick-mode DASH for example) */ if (demux->upstream_format_is_time && GST_BUFFER_OFFSET (inbuf) != GST_BUFFER_OFFSET_NONE) { - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { guint32 res; - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (demux, i); GST_LOG_OBJECT (demux, "track-id #%u , checking if offset %" G_GUINT64_FORMAT " is a sample start", stream->track_id, GST_BUFFER_OFFSET (inbuf)); @@ -6627,7 +6936,7 @@ gst_qtdemux_chain (GstPad * sinkpad, GstObject * parent, GstBuffer * inbuf) * previously received one. */ if (!is_gap_input && demux->fragmented && demux->segment.rate < 0) { gst_qtdemux_process_adapter (demux, TRUE); - g_list_foreach (demux->active_streams, + g_ptr_array_foreach (demux->active_streams, (GFunc) gst_qtdemux_stream_flush_samples_data, NULL); } } @@ -6697,7 +7006,8 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) } if (fourcc == FOURCC_mdat) { gint next_entry = next_entry_size (demux); - if (demux->n_streams > 0 && (next_entry != -1 || !demux->fragmented)) { + if (QTDEMUX_N_STREAMS (demux) > 0 && (next_entry != -1 + || !demux->fragmented)) { /* we have the headers, start playback */ demux->state = QTDEMUX_STATE_MOVIE; demux->neededbytes = next_entry; @@ -6785,11 +7095,9 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) extract_initial_length_and_fourcc (data, demux->neededbytes, NULL, &fourcc); if (fourcc == FOURCC_moov) { - GList *iter; - /* in usual fragmented setup we could try to scan for more * and end up at the the moov (after mdat) again */ - if (demux->got_moov && demux->n_streams > 0 && + if (demux->got_moov && QTDEMUX_N_STREAMS (demux) > 0 && (!demux->fragmented || demux->last_moov_offset == demux->offset)) { GST_DEBUG_OBJECT (demux, @@ -6809,23 +7117,13 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) if (demux->moov_node) g_node_destroy (demux->moov_node); demux->moov_node = NULL; - } else { - /* prepare newsegment to send when streaming actually starts */ - if (!demux->pending_newsegment) { - demux->pending_newsegment = - gst_event_new_segment (&demux->segment); - if (demux->segment_seqnum != GST_SEQNUM_INVALID) - gst_event_set_seqnum (demux->pending_newsegment, - demux->segment_seqnum); - } } demux->last_moov_offset = demux->offset; /* Update streams with new moov */ - demux->old_streams = - g_list_concat (demux->old_streams, demux->active_streams); - demux->active_streams = NULL; + gst_qtdemux_stream_concat (demux, + demux->old_streams, demux->active_streams); qtdemux_parse_moov (demux, data, demux->neededbytes); qtdemux_node_dump (demux, demux->moov_node); @@ -6836,16 +7134,8 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) QTDEMUX_EXPOSE_UNLOCK (demux); demux->got_moov = TRUE; - gst_qtdemux_check_send_pending_segment (demux); - /* fragmented streams headers shouldn't contain edts atoms */ - if (!demux->fragmented) { - for (iter = demux->active_streams; iter; - iter = g_list_next (iter)) { - gst_qtdemux_stream_send_initial_gap_segments (demux, - QTDEMUX_STREAM (iter->data)); - } - } + gst_qtdemux_check_send_pending_segment (demux); if (demux->moov_node_compressed) { g_node_destroy (demux->moov_node_compressed); @@ -6928,20 +7218,15 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) ret = GST_FLOW_ERROR; goto done; } + /* in MSS we need to expose the pads after the first moof as we won't get a moov */ if (demux->mss_mode && !demux->exposed) { - if (!demux->pending_newsegment) { - GST_DEBUG_OBJECT (demux, "new pending_newsegment"); - demux->pending_newsegment = - gst_event_new_segment (&demux->segment); - if (demux->segment_seqnum != GST_SEQNUM_INVALID) - gst_event_set_seqnum (demux->pending_newsegment, - demux->segment_seqnum); - } QTDEMUX_EXPOSE_LOCK (demux); qtdemux_expose_streams (demux); QTDEMUX_EXPOSE_UNLOCK (demux); } + + gst_qtdemux_check_send_pending_segment (demux); } else { GST_DEBUG_OBJECT (demux, "Discarding [moof]"); } @@ -6977,12 +7262,12 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) gst_adapter_unmap (demux->adapter); data = NULL; - if (demux->mdatbuffer && demux->n_streams) { + if (demux->mdatbuffer && QTDEMUX_N_STREAMS (demux)) { gsize remaining_data_size = 0; /* the mdat was before the header */ GST_DEBUG_OBJECT (demux, "We have n_streams:%d and mdatbuffer:%p", - demux->n_streams, demux->mdatbuffer); + QTDEMUX_N_STREAMS (demux), demux->mdatbuffer); /* restore our adapter/offset view of things with upstream; * put preceding buffered data ahead of current moov data. * This should also handle evil mdat, moov, mdat cases and alike */ @@ -7059,7 +7344,7 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) QtDemuxSample *sample; GstClockTime dts, pts, duration; gboolean keyframe; - GList *iter; + gint i; GST_DEBUG_OBJECT (demux, "BEGIN // in MOVIE for offset %" G_GUINT64_FORMAT, demux->offset); @@ -7110,7 +7395,7 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) data = gst_adapter_map (demux->adapter, demux->todrop); gst_byte_reader_init (&br, data + 8, demux->todrop); if (!qtdemux_parse_cenc_aux_info (demux, - QTDEMUX_FIRST_STREAM (demux), &br, + QTDEMUX_NTH_STREAM (demux, 0), &br, demux->cenc_aux_info_sizes, demux->cenc_aux_sample_count)) { GST_ERROR_OBJECT (demux, "failed to parse cenc auxiliary info"); ret = GST_FLOW_ERROR; @@ -7133,8 +7418,8 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) gst_qtdemux_check_send_pending_segment (demux); /* Figure out which stream this packet belongs to */ - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { - stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { + stream = QTDEMUX_NTH_STREAM (demux, i); if (stream->sample_index >= stream->n_samples) { /* reset to be checked below G_UNLIKELY (stream == NULL) */ stream = NULL; @@ -7174,7 +7459,8 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) /* check for segment end */ if (G_UNLIKELY (demux->segment.stop != -1 - && demux->segment.stop <= pts && stream->on_keyframe)) { + && demux->segment.stop <= pts && stream->on_keyframe) + && !(demux->upstream_format_is_time && demux->segment.rate < 0)) { GST_DEBUG_OBJECT (demux, "we reached the end of our segment."); stream->time_position = GST_CLOCK_TIME_NONE; /* this means EOS */ @@ -7184,8 +7470,8 @@ gst_qtdemux_process_adapter (GstQTDemux * demux, gboolean force) /* check if all streams are eos */ ret = GST_FLOW_EOS; - for (iter = demux->active_streams; iter; iter = g_list_next (iter)) { - if (!STREAM_IS_EOS (QTDEMUX_STREAM (iter->data))) { + for (i = 0; i < QTDEMUX_N_STREAMS (demux); i++) { + if (!STREAM_IS_EOS (QTDEMUX_NTH_STREAM (demux, i))) { ret = GST_FLOW_OK; break; } @@ -7942,7 +8228,7 @@ qtdemux_tree_get_sibling_by_type (GNode * node, guint32 fourcc) } static void -qtdemux_do_allocation (GstQTDemux * qtdemux, QtDemuxStream * stream) +qtdemux_do_allocation (QtDemuxStream * stream, GstQTDemux * qtdemux) { /* FIXME: This can only reliably work if demuxers have a * separate streaming thread per srcpad. This should be @@ -7979,11 +8265,147 @@ qtdemux_do_allocation (GstQTDemux * qtdemux, QtDemuxStream * stream) } static gboolean +pad_query (const GValue * item, GValue * value, gpointer user_data) +{ + GstPad *pad = g_value_get_object (item); + GstQuery *query = user_data; + gboolean res; + + res = gst_pad_peer_query (pad, query); + + if (res) { + g_value_set_boolean (value, TRUE); + return FALSE; + } + + GST_INFO_OBJECT (pad, "pad peer query failed"); + return TRUE; +} + +static gboolean +gst_qtdemux_run_query (GstElement * element, GstQuery * query, + GstPadDirection direction) +{ + GstIterator *it; + GstIteratorFoldFunction func = pad_query; + GValue res = { 0, }; + + g_value_init (&res, G_TYPE_BOOLEAN); + g_value_set_boolean (&res, FALSE); + + /* Ask neighbor */ + if (direction == GST_PAD_SRC) + it = gst_element_iterate_src_pads (element); + else + it = gst_element_iterate_sink_pads (element); + + while (gst_iterator_fold (it, func, &res, query) == GST_ITERATOR_RESYNC) + gst_iterator_resync (it); + + gst_iterator_free (it); + + return g_value_get_boolean (&res); +} + +static void +gst_qtdemux_request_protection_context (GstQTDemux * qtdemux, + QtDemuxStream * stream) +{ + GstQuery *query; + GstContext *ctxt; + GstElement *element = GST_ELEMENT (qtdemux); + GstStructure *st; + gchar **filtered_sys_ids; + GValue event_list = G_VALUE_INIT; + GList *walk; + + /* 1. Check if we already have the context. */ + if (qtdemux->preferred_protection_system_id != NULL) { + GST_LOG_OBJECT (element, + "already have the protection context, no need to request it again"); + return; + } + + g_ptr_array_add (qtdemux->protection_system_ids, NULL); + filtered_sys_ids = gst_protection_filter_systems_by_available_decryptors ( + (const gchar **) qtdemux->protection_system_ids->pdata); + + g_ptr_array_remove_index (qtdemux->protection_system_ids, + qtdemux->protection_system_ids->len - 1); + GST_TRACE_OBJECT (qtdemux, "detected %u protection systems, we have " + "decryptors for %u of them, running context request", + qtdemux->protection_system_ids->len, + filtered_sys_ids ? g_strv_length (filtered_sys_ids) : 0); + + + if (stream->protection_scheme_event_queue.length) { + GST_TRACE_OBJECT (qtdemux, "using stream event queue, length %u", + stream->protection_scheme_event_queue.length); + walk = stream->protection_scheme_event_queue.tail; + } else { + GST_TRACE_OBJECT (qtdemux, "using demuxer event queue, length %u", + qtdemux->protection_event_queue.length); + walk = qtdemux->protection_event_queue.tail; + } + + g_value_init (&event_list, GST_TYPE_LIST); + for (; walk; walk = g_list_previous (walk)) { + GValue *event_value = g_new0 (GValue, 1); + g_value_init (event_value, GST_TYPE_EVENT); + g_value_set_boxed (event_value, walk->data); + gst_value_list_append_and_take_value (&event_list, event_value); + } + + /* 2a) Query downstream with GST_QUERY_CONTEXT for the context and + * check if downstream already has a context of the specific type + * 2b) Query upstream as above. + */ + query = gst_query_new_context ("drm-preferred-decryption-system-id"); + st = gst_query_writable_structure (query); + gst_structure_set (st, "track-id", G_TYPE_UINT, stream->track_id, + "available-stream-encryption-systems", G_TYPE_STRV, filtered_sys_ids, + NULL); + gst_structure_set_value (st, "stream-encryption-events", &event_list); + if (gst_qtdemux_run_query (element, query, GST_PAD_SRC)) { + gst_query_parse_context (query, &ctxt); + GST_INFO_OBJECT (element, "found context (%p) in downstream query", ctxt); + gst_element_set_context (element, ctxt); + } else if (gst_qtdemux_run_query (element, query, GST_PAD_SINK)) { + gst_query_parse_context (query, &ctxt); + GST_INFO_OBJECT (element, "found context (%p) in upstream query", ctxt); + gst_element_set_context (element, ctxt); + } else { + /* 3) Post a GST_MESSAGE_NEED_CONTEXT message on the bus with + * the required context type and afterwards check if a + * usable context was set now as in 1). The message could + * be handled by the parent bins of the element and the + * application. + */ + GstMessage *msg; + + GST_INFO_OBJECT (element, "posting need context message"); + msg = gst_message_new_need_context (GST_OBJECT_CAST (element), + "drm-preferred-decryption-system-id"); + st = (GstStructure *) gst_message_get_structure (msg); + gst_structure_set (st, "track-id", G_TYPE_UINT, stream->track_id, + "available-stream-encryption-systems", G_TYPE_STRV, filtered_sys_ids, + NULL); + + gst_structure_set_value (st, "stream-encryption-events", &event_list); + gst_element_post_message (element, msg); + } + + g_strfreev (filtered_sys_ids); + g_value_unset (&event_list); + gst_query_unref (query); +} + +static gboolean gst_qtdemux_configure_protected_caps (GstQTDemux * qtdemux, QtDemuxStream * stream) { GstStructure *s; - const gchar *selected_system; + const gchar *selected_system = NULL; g_return_val_if_fail (qtdemux != NULL, FALSE); g_return_val_if_fail (stream != NULL, FALSE); @@ -7991,7 +8413,9 @@ gst_qtdemux_configure_protected_caps (GstQTDemux * qtdemux, FALSE); if (stream->protection_scheme_type != FOURCC_cenc) { - GST_ERROR_OBJECT (qtdemux, "unsupported protection scheme"); + GST_ERROR_OBJECT (qtdemux, + "unsupported protection scheme: %" GST_FOURCC_FORMAT, + GST_FOURCC_ARGS (stream->protection_scheme_type)); return FALSE; } if (qtdemux->protection_system_ids == NULL) { @@ -7999,17 +8423,41 @@ gst_qtdemux_configure_protected_caps (GstQTDemux * qtdemux, "cenc protection system information has been found"); return FALSE; } - g_ptr_array_add (qtdemux->protection_system_ids, NULL); - selected_system = gst_protection_select_system ((const gchar **) - qtdemux->protection_system_ids->pdata); - g_ptr_array_remove_index (qtdemux->protection_system_ids, - qtdemux->protection_system_ids->len - 1); + + gst_qtdemux_request_protection_context (qtdemux, stream); + if (qtdemux->preferred_protection_system_id != NULL) { + const gchar *preferred_system_array[] = + { qtdemux->preferred_protection_system_id, NULL }; + + selected_system = gst_protection_select_system (preferred_system_array); + + if (selected_system) { + GST_TRACE_OBJECT (qtdemux, "selected preferred system %s", + qtdemux->preferred_protection_system_id); + } else { + GST_WARNING_OBJECT (qtdemux, "could not select preferred system %s " + "because there is no available decryptor", + qtdemux->preferred_protection_system_id); + } + } + + if (!selected_system) { + g_ptr_array_add (qtdemux->protection_system_ids, NULL); + selected_system = gst_protection_select_system ((const gchar **) + qtdemux->protection_system_ids->pdata); + g_ptr_array_remove_index (qtdemux->protection_system_ids, + qtdemux->protection_system_ids->len - 1); + } + if (!selected_system) { GST_ERROR_OBJECT (qtdemux, "stream is protected, but no " "suitable decryptor element has been found"); return FALSE; } + GST_DEBUG_OBJECT (qtdemux, "selected protection system is %s", + selected_system); + s = gst_caps_get_structure (CUR_STREAM (stream)->caps, 0); if (!gst_structure_has_name (s, "application/x-cenc")) { gst_structure_set (s, @@ -8022,70 +8470,84 @@ gst_qtdemux_configure_protected_caps (GstQTDemux * qtdemux, } static gboolean -gst_qtdemux_configure_stream (GstQTDemux * qtdemux, QtDemuxStream * stream) +gst_qtdemux_guess_framerate (GstQTDemux * qtdemux, QtDemuxStream * stream) { - if (stream->subtype == FOURCC_vide) { - /* fps is calculated base on the duration of the average framerate since - * qt does not have a fixed framerate. */ - gboolean fps_available = TRUE; - - if ((stream->n_samples == 1 && stream->first_duration == 0) - || (qtdemux->fragmented && stream->n_samples_moof == 1)) { - /* still frame */ - CUR_STREAM (stream)->fps_n = 0; + /* fps is calculated base on the duration of the average framerate since + * qt does not have a fixed framerate. */ + gboolean fps_available = TRUE; + guint32 first_duration = 0; + + if (stream->n_samples > 0) + first_duration = stream->samples[0].duration; + + if ((stream->n_samples == 1 && first_duration == 0) + || (qtdemux->fragmented && stream->n_samples_moof == 1)) { + /* still frame */ + CUR_STREAM (stream)->fps_n = 0; + CUR_STREAM (stream)->fps_d = 1; + } else { + if (stream->duration == 0 || stream->n_samples < 2) { + CUR_STREAM (stream)->fps_n = stream->timescale; CUR_STREAM (stream)->fps_d = 1; + fps_available = FALSE; } else { - if (stream->duration == 0 || stream->n_samples < 2) { - CUR_STREAM (stream)->fps_n = stream->timescale; - CUR_STREAM (stream)->fps_d = 1; - fps_available = FALSE; + GstClockTime avg_duration; + guint64 duration; + guint32 n_samples; + + /* duration and n_samples can be updated for fragmented format + * so, framerate of fragmented format is calculated using data in a moof */ + if (qtdemux->fragmented && stream->n_samples_moof > 0 + && stream->duration_moof > 0) { + n_samples = stream->n_samples_moof; + duration = stream->duration_moof; } else { - GstClockTime avg_duration; - guint64 duration; - guint32 n_samples; - - /* duration and n_samples can be updated for fragmented format - * so, framerate of fragmented format is calculated using data in a moof */ - if (qtdemux->fragmented && stream->n_samples_moof > 0 - && stream->duration_moof > 0) { - n_samples = stream->n_samples_moof; - duration = stream->duration_moof; - } else { - n_samples = stream->n_samples; - duration = stream->duration; - } + n_samples = stream->n_samples; + duration = stream->duration; + } - /* Calculate a framerate, ignoring the first sample which is sometimes truncated */ - /* stream->duration is guint64, timescale, n_samples are guint32 */ - avg_duration = - gst_util_uint64_scale_round (duration - - stream->first_duration, GST_SECOND, - (guint64) (stream->timescale) * (n_samples - 1)); + /* Calculate a framerate, ignoring the first sample which is sometimes truncated */ + /* stream->duration is guint64, timescale, n_samples are guint32 */ + avg_duration = + gst_util_uint64_scale_round (duration - + first_duration, GST_SECOND, + (guint64) (stream->timescale) * (n_samples - 1)); - GST_LOG_OBJECT (qtdemux, - "Calculating avg sample duration based on stream (or moof) duration %" - G_GUINT64_FORMAT - " minus first sample %u, leaving %d samples gives %" - GST_TIME_FORMAT, duration, stream->first_duration, - n_samples - 1, GST_TIME_ARGS (avg_duration)); + GST_LOG_OBJECT (qtdemux, + "Calculating avg sample duration based on stream (or moof) duration %" + G_GUINT64_FORMAT + " minus first sample %u, leaving %d samples gives %" + GST_TIME_FORMAT, duration, first_duration, + n_samples - 1, GST_TIME_ARGS (avg_duration)); - gst_video_guess_framerate (avg_duration, &CUR_STREAM (stream)->fps_n, - &CUR_STREAM (stream)->fps_d); + fps_available = + gst_video_guess_framerate (avg_duration, + &CUR_STREAM (stream)->fps_n, &CUR_STREAM (stream)->fps_d); - GST_DEBUG_OBJECT (qtdemux, - "Calculating framerate, timescale %u gave fps_n %d fps_d %d", - stream->timescale, CUR_STREAM (stream)->fps_n, - CUR_STREAM (stream)->fps_d); - } + GST_DEBUG_OBJECT (qtdemux, + "Calculating framerate, timescale %u gave fps_n %d fps_d %d", + stream->timescale, CUR_STREAM (stream)->fps_n, + CUR_STREAM (stream)->fps_d); } + } + + return fps_available; +} + +static gboolean +gst_qtdemux_configure_stream (GstQTDemux * qtdemux, QtDemuxStream * stream) +{ + if (stream->subtype == FOURCC_vide) { + gboolean fps_available = gst_qtdemux_guess_framerate (qtdemux, stream); if (CUR_STREAM (stream)->caps) { CUR_STREAM (stream)->caps = gst_caps_make_writable (CUR_STREAM (stream)->caps); - gst_caps_set_simple (CUR_STREAM (stream)->caps, - "width", G_TYPE_INT, CUR_STREAM (stream)->width, - "height", G_TYPE_INT, CUR_STREAM (stream)->height, NULL); + if (CUR_STREAM (stream)->width && CUR_STREAM (stream)->height) + gst_caps_set_simple (CUR_STREAM (stream)->caps, + "width", G_TYPE_INT, CUR_STREAM (stream)->width, + "height", G_TYPE_INT, CUR_STREAM (stream)->height, NULL); /* set framerate if calculated framerate is reliable */ if (fps_available) { @@ -8196,6 +8658,56 @@ gst_qtdemux_configure_stream (GstQTDemux * qtdemux, QtDemuxStream * stream) } } + else if (stream->subtype == FOURCC_clcp && CUR_STREAM (stream)->caps) { + const GstStructure *s; + QtDemuxStream *fps_stream = NULL; + gboolean fps_available = FALSE; + + /* CEA608 closed caption tracks are a bit special in that each sample + * can contain CCs for multiple frames, and CCs can be omitted and have to + * be inferred from the duration of the sample then. + * + * As such we take the framerate from the (first) video track here for + * CEA608 as there must be one CC byte pair for every video frame + * according to the spec. + * + * For CEA708 all is fine and there is one sample per frame. + */ + + s = gst_caps_get_structure (CUR_STREAM (stream)->caps, 0); + if (gst_structure_has_name (s, "closedcaption/x-cea-608")) { + gint i; + + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *tmp = QTDEMUX_NTH_STREAM (qtdemux, i); + + if (tmp->subtype == FOURCC_vide) { + fps_stream = tmp; + break; + } + } + + if (fps_stream) { + fps_available = gst_qtdemux_guess_framerate (qtdemux, fps_stream); + CUR_STREAM (stream)->fps_n = CUR_STREAM (fps_stream)->fps_n; + CUR_STREAM (stream)->fps_d = CUR_STREAM (fps_stream)->fps_d; + } + } else { + fps_available = gst_qtdemux_guess_framerate (qtdemux, stream); + fps_stream = stream; + } + + CUR_STREAM (stream)->caps = + gst_caps_make_writable (CUR_STREAM (stream)->caps); + + /* set framerate if calculated framerate is reliable */ + if (fps_available) { + gst_caps_set_simple (CUR_STREAM (stream)->caps, + "framerate", GST_TYPE_FRACTION, CUR_STREAM (stream)->fps_n, + CUR_STREAM (stream)->fps_d, NULL); + } + } + if (stream->pad) { GstCaps *prev_caps = NULL; @@ -8298,8 +8810,6 @@ gst_qtdemux_add_stream (GstQTDemux * qtdemux, QtDemuxStream * stream, GstTagList * list) { gboolean ret = TRUE; - /* consistent default for push based mode */ - gst_segment_init (&stream->segment, GST_FORMAT_TIME); if (stream->subtype == FOURCC_vide) { gchar *name = g_strdup_printf ("video_%u", qtdemux->n_video_streams); @@ -8332,7 +8842,8 @@ gst_qtdemux_add_stream (GstQTDemux * qtdemux, } else if (stream->subtype == FOURCC_strm) { GST_DEBUG_OBJECT (qtdemux, "stream type, not creating pad"); } else if (stream->subtype == FOURCC_subp || stream->subtype == FOURCC_text - || stream->subtype == FOURCC_sbtl || stream->subtype == FOURCC_subt) { + || stream->subtype == FOURCC_sbtl || stream->subtype == FOURCC_subt + || stream->subtype == FOURCC_clcp) { gchar *name = g_strdup_printf ("subtitle_%u", qtdemux->n_sub_streams); stream->pad = @@ -8732,6 +9243,18 @@ qtdemux_stbl_init (GstQTDemux * qtdemux, QtDemuxStream * stream, GNode * stbl) gst_byte_reader_skip_unchecked (&stream->ctts, 4); offset = gst_byte_reader_get_int32_be_unchecked (&stream->ctts); + /* HACK: if sample_offset is larger than 2 * duration, ignore the box. + * slightly inaccurate PTS could be more usable than corrupted one */ + if (G_UNLIKELY ((ABS (offset) / 2) > stream->duration)) { + GST_WARNING_OBJECT (qtdemux, + "Ignore corrupted ctts, sample_offset %" G_GINT32_FORMAT + " larger than duration %" G_GUINT64_FORMAT, + offset, stream->duration); + + stream->cslg_shift = 0; + stream->ctts_present = FALSE; + return TRUE; + } if (offset < cslg_least) cslg_least = offset; @@ -9263,7 +9786,7 @@ qtdemux_parse_segments (GstQTDemux * qtdemux, QtDemuxStream * stream, for (segment_number = 0; segment_number < n_segments; segment_number++) { guint64 duration; guint64 media_time; - gboolean time_valid = TRUE; + gboolean empty_edit = FALSE; QtDemuxSegment *segment; guint32 rate_int; GstClockTime media_start = GST_CLOCK_TIME_NONE; @@ -9272,44 +9795,44 @@ qtdemux_parse_segments (GstQTDemux * qtdemux, QtDemuxStream * stream, media_time = QT_UINT64 (buffer + 8); duration = QT_UINT64 (buffer); if (media_time == G_MAXUINT64) - time_valid = FALSE; + empty_edit = TRUE; } else { media_time = QT_UINT32 (buffer + 4); duration = QT_UINT32 (buffer); if (media_time == G_MAXUINT32) - time_valid = FALSE; + empty_edit = TRUE; } - if (time_valid) + if (!empty_edit) media_start = QTSTREAMTIME_TO_GSTTIME (stream, media_time); segment = &stream->segments[segment_number]; /* time and duration expressed in global timescale */ segment->time = stime; - /* add non scaled values so we don't cause roundoff errors */ - if (duration || media_start == GST_CLOCK_TIME_NONE) { + if (duration != 0 || empty_edit) { + /* edge case: empty edits with duration=zero are treated here. + * (files should not have these anyway). */ + + /* add non scaled values so we don't cause roundoff errors */ time += duration; stime = QTTIME_TO_GSTTIME (qtdemux, time); segment->duration = stime - segment->time; } else { /* zero duration does not imply media_start == media_stop - * but, only specify media_start.*/ - stime = QTTIME_TO_GSTTIME (qtdemux, qtdemux->duration); - if (GST_CLOCK_TIME_IS_VALID (stime) && time_valid - && stime >= media_start) { - segment->duration = stime - media_start; - } else { - segment->duration = GST_CLOCK_TIME_NONE; - } + * but, only specify media_start. The edit ends with the track. */ + stime = segment->duration = GST_CLOCK_TIME_NONE; + /* Don't allow more edits after this one. */ + n_segments = segment_number + 1; } segment->stop_time = stime; segment->trak_media_start = media_time; /* media_time expressed in stream timescale */ - if (time_valid) { + if (!empty_edit) { segment->media_start = media_start; - segment->media_stop = segment->media_start + segment->duration; + segment->media_stop = GST_CLOCK_TIME_IS_VALID (segment->duration) + ? segment->media_start + segment->duration : GST_CLOCK_TIME_NONE; media_segments_count++; } else { segment->media_start = GST_CLOCK_TIME_NONE; @@ -9337,14 +9860,15 @@ qtdemux_parse_segments (GstQTDemux * qtdemux, QtDemuxStream * stream, GST_TIME_ARGS (segment->media_stop), GST_TIME_ARGS (segment->stop_time), segment->rate, rate_int, stream->timescale); - if (segment->stop_time > qtdemux->segment.stop) { + if (segment->stop_time > qtdemux->segment.stop && + !qtdemux->upstream_format_is_time) { GST_WARNING_OBJECT (qtdemux, "Segment %d " " extends to %" GST_TIME_FORMAT - " past the end of the file duration %" GST_TIME_FORMAT - " it will be truncated", segment_number, + " past the end of the declared movie duration %" GST_TIME_FORMAT + " movie segment will be extended", segment_number, GST_TIME_ARGS (segment->stop_time), GST_TIME_ARGS (qtdemux->segment.stop)); - qtdemux->segment.stop = segment->stop_time; + qtdemux->segment.stop = qtdemux->segment.duration = segment->stop_time; } buffer += entry_size; @@ -9743,6 +10267,9 @@ qtdemux_parse_protection_scheme_info (GstQTDemux * qtdemux, GNode *frma; GNode *schm; GNode *schi; + QtDemuxCencSampleSetInfo *info; + GNode *tenc; + const guint8 *tenc_data; g_return_val_if_fail (qtdemux != NULL, FALSE); g_return_val_if_fail (stream != NULL, FALSE); @@ -9789,20 +10316,24 @@ qtdemux_parse_protection_scheme_info (GstQTDemux * qtdemux, GST_DEBUG_OBJECT (qtdemux, "sinf box does not contain schi box"); return FALSE; } + if (stream->protection_scheme_type != FOURCC_cenc && + stream->protection_scheme_type != FOURCC_piff) { + GST_ERROR_OBJECT (qtdemux, + "Invalid protection_scheme_type: %" GST_FOURCC_FORMAT, + GST_FOURCC_ARGS (stream->protection_scheme_type)); + return FALSE; + } + + if (G_UNLIKELY (!stream->protection_scheme_info)) + stream->protection_scheme_info = + g_malloc0 (sizeof (QtDemuxCencSampleSetInfo)); + + info = (QtDemuxCencSampleSetInfo *) stream->protection_scheme_info; + if (stream->protection_scheme_type == FOURCC_cenc) { - QtDemuxCencSampleSetInfo *info; - GNode *tenc; - const guint8 *tenc_data; - guint32 isEncrypted; + guint32 is_encrypted; guint8 iv_size; const guint8 *default_kid; - GstBuffer *kid_buf; - - if (G_UNLIKELY (!stream->protection_scheme_info)) - stream->protection_scheme_info = - g_malloc0 (sizeof (QtDemuxCencSampleSetInfo)); - - info = (QtDemuxCencSampleSetInfo *) stream->protection_scheme_info; tenc = qtdemux_tree_get_child_by_type (schi, FOURCC_tenc); if (!tenc) { @@ -9811,29 +10342,50 @@ qtdemux_parse_protection_scheme_info (GstQTDemux * qtdemux, return FALSE; } tenc_data = (const guint8 *) tenc->data + 12; - isEncrypted = QT_UINT24 (tenc_data); + is_encrypted = QT_UINT24 (tenc_data); iv_size = QT_UINT8 (tenc_data + 3); default_kid = (tenc_data + 4); - kid_buf = gst_buffer_new_allocate (NULL, 16, NULL); - gst_buffer_fill (kid_buf, 0, default_kid, 16); - if (info->default_properties) - gst_structure_free (info->default_properties); - info->default_properties = - gst_structure_new ("application/x-cenc", - "iv_size", G_TYPE_UINT, iv_size, - "encrypted", G_TYPE_BOOLEAN, (isEncrypted == 1), - "kid", GST_TYPE_BUFFER, kid_buf, NULL); - GST_DEBUG_OBJECT (qtdemux, "default sample properties: " - "is_encrypted=%u, iv_size=%u", isEncrypted, iv_size); - gst_buffer_unref (kid_buf); + qtdemux_update_default_sample_encryption_settings (qtdemux, info, + is_encrypted, iv_size, default_kid); + } else if (stream->protection_scheme_type == FOURCC_piff) { + GstByteReader br; + static const guint8 piff_track_encryption_uuid[] = { + 0x89, 0x74, 0xdb, 0xce, 0x7b, 0xe7, 0x4c, 0x51, + 0x84, 0xf9, 0x71, 0x48, 0xf9, 0x88, 0x25, 0x54 + }; + + tenc = qtdemux_tree_get_child_by_type (schi, FOURCC_uuid); + if (!tenc) { + GST_ERROR_OBJECT (qtdemux, "schi box does not contain tenc box, " + "which is mandatory for Common Encryption"); + return FALSE; + } + + tenc_data = (const guint8 *) tenc->data + 8; + if (memcmp (tenc_data, piff_track_encryption_uuid, 16) != 0) { + gchar *box_uuid = qtdemux_uuid_bytes_to_string (tenc_data); + GST_ERROR_OBJECT (qtdemux, + "Unsupported track encryption box with uuid: %s", box_uuid); + g_free (box_uuid); + return FALSE; + } + tenc_data = (const guint8 *) tenc->data + 16 + 12; + gst_byte_reader_init (&br, tenc_data, 20); + if (!qtdemux_update_default_piff_encryption_settings (qtdemux, info, &br)) { + GST_ERROR_OBJECT (qtdemux, "PIFF track box parsing error"); + return FALSE; + } + stream->protection_scheme_type = FOURCC_cenc; } + return TRUE; } static gint -qtdemux_track_id_compare_func (QtDemuxStream * stream1, QtDemuxStream * stream2) +qtdemux_track_id_compare_func (QtDemuxStream ** stream1, + QtDemuxStream ** stream2) { - return (gint) stream1->track_id - (gint) stream2->track_id; + return (gint) (*stream1)->track_id - (gint) (*stream2)->track_id; } /* parse the traks. @@ -9917,11 +10469,11 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak) version = QT_UINT32 ((guint8 *) mdhd->data + 8); GST_LOG_OBJECT (qtdemux, "track version/flags: %08x", version); if (version == 0x01000000) { - if (len < 38) + if (len < 42) goto corrupt_file; stream->timescale = QT_UINT32 ((guint8 *) mdhd->data + 28); stream->duration = QT_UINT64 ((guint8 *) mdhd->data + 32); - lang_code = QT_UINT16 ((guint8 *) mdhd->data + 36); + lang_code = QT_UINT16 ((guint8 *) mdhd->data + 40); } else { if (len < 30) goto corrupt_file; @@ -9986,7 +10538,7 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak) "found, assuming preview image or something; skipping track", stream->duration, stream->timescale, qtdemux->duration, qtdemux->timescale); - gst_qtdemux_stream_free (stream); + gst_qtdemux_stream_unref (stream); return TRUE; } } @@ -10083,7 +10635,7 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak) if (stsd_len < 24) { /* .. but skip stream with empty stsd produced by some Vivotek cameras */ if (stream->subtype == FOURCC_vivo) { - gst_qtdemux_stream_free (stream); + gst_qtdemux_stream_unref (stream); return TRUE; } else { goto corrupt_file; @@ -10299,14 +10851,17 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak) fiel = NULL; /* pick 'the' stsd child */ mp4v = qtdemux_tree_get_child_by_index (stsd, stsd_index); - if (!stream->protected) { - if (QTDEMUX_TREE_NODE_FOURCC (mp4v) != fourcc) { + // We should skip parsing the stsd for non-protected streams if + // the entry doesn't match the fourcc, since they don't change + // format. However, for protected streams we can have partial + // encryption, where parts of the stream are encrypted and parts + // not. For both parts of such streams, we should ensure the + // esds overrides are parsed for both from the stsd. + if (QTDEMUX_TREE_NODE_FOURCC (mp4v) != fourcc) { + if (stream->protected && QTDEMUX_TREE_NODE_FOURCC (mp4v) != FOURCC_encv) mp4v = NULL; - } - } else { - if (QTDEMUX_TREE_NODE_FOURCC (mp4v) != FOURCC_encv) { + else if (!stream->protected) mp4v = NULL; - } } if (mp4v) { @@ -11000,6 +11555,81 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak) } break; } + case FOURCC_av01: + { + gint len = QT_UINT32 (stsd_entry_data) - 0x56; + const guint8 *av1_data = stsd_entry_data + 0x56; + + /* find av1C */ + while (len >= 0x8) { + gint size; + + if (QT_UINT32 (av1_data) <= len) + size = QT_UINT32 (av1_data) - 0x8; + else + size = len - 0x8; + + if (size < 1) + /* No real data, so break out */ + break; + + switch (QT_FOURCC (av1_data + 0x4)) { + case FOURCC_av1C: + { + /* parse, if found */ + GstBuffer *buf; + guint8 pres_delay_field; + + GST_DEBUG_OBJECT (qtdemux, + "found av1C codec_data in stsd of size %d", size); + + /* not enough data, just ignore and hope for the best */ + if (size < 5) + break; + + /* Content is: + * 4 bytes: atom length + * 4 bytes: fourcc + * 1 byte: version + * 3 bytes: flags + * 3 bits: reserved + * 1 bits: initial_presentation_delay_present + * 4 bits: initial_presentation_delay (if present else reserved + * rest: OBUs. + */ + + if (av1_data[9] != 0) { + GST_WARNING ("Unknown version %d of av1C box", av1_data[9]); + break; + } + + /* We skip initial_presentation_delay* for now */ + pres_delay_field = *(av1_data + 12); + if (pres_delay_field & (1 << 5)) { + gst_caps_set_simple (entry->caps, + "presentation-delay", G_TYPE_INT, + (gint) (pres_delay_field & 0x0F) + 1, NULL); + } + if (size > 5) { + buf = gst_buffer_new_and_alloc (size - 5); + GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER); + gst_buffer_fill (buf, 0, av1_data + 13, size - 5); + gst_caps_set_simple (entry->caps, + "codec_data", GST_TYPE_BUFFER, buf, NULL); + gst_buffer_unref (buf); + } + break; + } + default: + break; + } + + len -= size + 8; + av1_data += size + 8; + } + + break; + } default: break; } @@ -11415,20 +12045,11 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak) } mp4a = qtdemux_tree_get_child_by_index (stsd, stsd_index); - if (!stream->protected) { - } else { - if (QTDEMUX_TREE_NODE_FOURCC (mp4v) != FOURCC_encv) { - mp4v = NULL; - } - } - if (stream->protected && fourcc == FOURCC_mp4a) { - if (QTDEMUX_TREE_NODE_FOURCC (mp4a) != FOURCC_enca) { + if (QTDEMUX_TREE_NODE_FOURCC (mp4a) != fourcc) { + if (stream->protected && QTDEMUX_TREE_NODE_FOURCC (mp4a) != FOURCC_enca) mp4a = NULL; - } - } else { - if (QTDEMUX_TREE_NODE_FOURCC (mp4a) != FOURCC_mp4a) { + else if (!stream->protected) mp4a = NULL; - } } wave = NULL; @@ -11885,11 +12506,11 @@ qtdemux_parse_trak (GstQTDemux * qtdemux, GNode * trak) /* Insert and sort new stream in track-id order. * This will help in comparing old/new streams during stream update check */ - qtdemux->active_streams = - g_list_insert_sorted (qtdemux->active_streams, stream, + g_ptr_array_add (qtdemux->active_streams, stream); + g_ptr_array_sort (qtdemux->active_streams, (GCompareFunc) qtdemux_track_id_compare_func); - qtdemux->n_streams++; - GST_DEBUG_OBJECT (qtdemux, "n_streams is now %d", qtdemux->n_streams); + GST_DEBUG_OBJECT (qtdemux, "n_streams is now %d", + QTDEMUX_N_STREAMS (qtdemux)); return TRUE; @@ -11899,13 +12520,13 @@ corrupt_file: GST_ELEMENT_ERROR (qtdemux, STREAM, DEMUX, (_("This file is corrupt and cannot be played.")), (NULL)); if (stream) - gst_qtdemux_stream_free (stream); + gst_qtdemux_stream_unref (stream); return FALSE; } error_encrypted: { GST_ELEMENT_ERROR (qtdemux, STREAM, DECRYPT, (NULL), (NULL)); - gst_qtdemux_stream_free (stream); + gst_qtdemux_stream_unref (stream); return FALSE; } samples_failed: @@ -11914,7 +12535,7 @@ segments_failed: /* we posted an error already */ /* free stbl sub-atoms */ gst_qtdemux_stbl_free (stream); - gst_qtdemux_stream_free (stream); + gst_qtdemux_stream_unref (stream); return FALSE; } existing_stream: @@ -11927,7 +12548,7 @@ unknown_stream: { GST_INFO_OBJECT (qtdemux, "unknown subtype %" GST_FOURCC_FORMAT, GST_FOURCC_ARGS (stream->subtype)); - gst_qtdemux_stream_free (stream); + gst_qtdemux_stream_unref (stream); return TRUE; } } @@ -11944,7 +12565,7 @@ gst_qtdemux_guess_bitrate (GstQTDemux * qtdemux) gint64 size, sys_bitrate, sum_bitrate = 0; GstClockTime duration; guint bitrate; - GList *iter; + gint i; if (qtdemux->fragmented) return; @@ -11972,8 +12593,8 @@ gst_qtdemux_guess_bitrate (GstQTDemux * qtdemux) return; } - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *str = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *str = QTDEMUX_NTH_STREAM (qtdemux, i); switch (str->subtype) { case FOURCC_soun: case FOURCC_vide: @@ -12041,16 +12662,14 @@ static GstFlowReturn qtdemux_prepare_streams (GstQTDemux * qtdemux) { GstFlowReturn ret = GST_FLOW_OK; - GList *iter, *next; + gint i; GST_DEBUG_OBJECT (qtdemux, "prepare streams"); - for (iter = qtdemux->active_streams; ret == GST_FLOW_OK && iter; iter = next) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); guint32 sample_num = 0; - next = iter->next; - GST_DEBUG_OBJECT (qtdemux, "track-id %u, fourcc %" GST_FOURCC_FORMAT, stream->track_id, GST_FOURCC_ARGS (CUR_STREAM (stream)->fourcc)); @@ -12075,13 +12694,15 @@ qtdemux_prepare_streams (GstQTDemux * qtdemux) * in push mode, we'll just have to deal with it */ if (G_UNLIKELY (qtdemux->pullbased && !stream->n_samples)) { GST_DEBUG_OBJECT (qtdemux, "no samples for stream; discarding"); - gst_qtdemux_remove_stream (qtdemux, stream); + g_ptr_array_remove_index (qtdemux->active_streams, i); + i--; continue; } else if (stream->track_id == qtdemux->chapters_track_id && (stream->subtype == FOURCC_text || stream->subtype == FOURCC_sbtl)) { /* TODO - parse chapters track and expose it as GstToc; For now just ignore it so that it doesn't look like a subtitle track */ - gst_qtdemux_remove_stream (qtdemux, stream); + g_ptr_array_remove_index (qtdemux->active_streams, i); + i--; continue; } @@ -12091,51 +12712,34 @@ qtdemux_prepare_streams (GstQTDemux * qtdemux) break; ++sample_num; } - if (stream->n_samples > 0 && stream->stbl_index >= 0) { - stream->first_duration = stream->samples[0].duration; - GST_LOG_OBJECT (qtdemux, "track-id %u first duration %u", - stream->track_id, stream->first_duration); - } } return ret; } -static GList * -_stream_in_list (GList * list, QtDemuxStream * stream) +static gboolean +_stream_equal_func (const QtDemuxStream * stream, const gchar * stream_id) { - GList *iter; - - for (iter = list; iter; iter = g_list_next (iter)) { - QtDemuxStream *tmp = QTDEMUX_STREAM (iter->data); - if (!g_strcmp0 (tmp->stream_id, stream->stream_id)) - return iter; - } - - return NULL; + return g_strcmp0 (stream->stream_id, stream_id) == 0; } static gboolean qtdemux_is_streams_update (GstQTDemux * qtdemux) { - GList *new, *old; + gint i; - g_return_val_if_fail (qtdemux->active_streams != NULL, FALSE); + /* Different length, updated */ + if (QTDEMUX_N_STREAMS (qtdemux) != qtdemux->old_streams->len) + return TRUE; /* streams in list are sorted in track-id order */ - for (new = qtdemux->active_streams, old = qtdemux->old_streams; new && old; - new = g_list_next (new), old = g_list_next (old)) { - + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { /* Different stream-id, updated */ - if (g_strcmp0 (QTDEMUX_STREAM (new->data)->stream_id, - QTDEMUX_STREAM (old->data)->stream_id)) + if (g_strcmp0 (QTDEMUX_NTH_STREAM (qtdemux, i)->stream_id, + QTDEMUX_NTH_OLD_STREAM (qtdemux, i)->stream_id)) return TRUE; } - /* Different length, updated */ - if (new != NULL || old != NULL) - return TRUE; - return FALSE; } @@ -12153,10 +12757,38 @@ qtdemux_reuse_and_configure_stream (GstQTDemux * qtdemux, return gst_qtdemux_configure_stream (qtdemux, newstream); } +/* g_ptr_array_find_with_equal_func is available since 2.54, + * replacement until we can depend unconditionally on the real one in GLib */ +#if !GLIB_CHECK_VERSION(2,54,0) +#define g_ptr_array_find_with_equal_func qtdemux_ptr_array_find_with_equal_func +static gboolean +qtdemux_ptr_array_find_with_equal_func (GPtrArray * haystack, + gconstpointer needle, GEqualFunc equal_func, guint * index_) +{ + guint i; + + g_return_val_if_fail (haystack != NULL, FALSE); + + if (equal_func == NULL) + equal_func = g_direct_equal; + + for (i = 0; i < haystack->len; i++) { + if (equal_func (g_ptr_array_index (haystack, i), needle)) { + if (index_ != NULL) + *index_ = i; + return TRUE; + } + } + + return FALSE; +} +#endif + static gboolean qtdemux_update_streams (GstQTDemux * qtdemux) { - GList *iter, *next; + gint i; + g_assert (qtdemux->streams_aware); /* At below, figure out which stream in active_streams has identical stream-id * with that of in old_streams. If there is matching stream-id, @@ -12167,32 +12799,31 @@ qtdemux_update_streams (GstQTDemux * qtdemux) * old_streams : existing streams (belong to previous moov) */ - /* Count n_streams again */ - qtdemux->n_streams = 0; - - for (iter = qtdemux->active_streams;iter; iter = next) { - GList *tmp; - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); - - next = iter->next; + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); + QtDemuxStream *oldstream = NULL; + guint target; GST_DEBUG_OBJECT (qtdemux, "track-id %u, fourcc %" GST_FOURCC_FORMAT, stream->track_id, GST_FOURCC_ARGS (CUR_STREAM (stream)->fourcc)); - qtdemux->n_streams++; + if (g_ptr_array_find_with_equal_func (qtdemux->old_streams, + stream->stream_id, (GEqualFunc) _stream_equal_func, &target)) { + oldstream = QTDEMUX_NTH_OLD_STREAM (qtdemux, target); - if (qtdemux->streams_aware - && (tmp = _stream_in_list (qtdemux->old_streams, stream)) != NULL - && QTDEMUX_STREAM (tmp->data)->pad) { - QtDemuxStream *oldstream = QTDEMUX_STREAM (tmp->data); + /* null pad stream cannot be reused */ + if (oldstream->pad == NULL) + oldstream = NULL; + } + if (oldstream) { GST_DEBUG_OBJECT (qtdemux, "Reuse track-id %d", oldstream->track_id); if (!qtdemux_reuse_and_configure_stream (qtdemux, oldstream, stream)) return FALSE; - qtdemux->old_streams = g_list_remove (qtdemux->old_streams, oldstream); - gst_qtdemux_stream_free (oldstream); + /* we don't need to preserve order of old streams */ + g_ptr_array_remove_fast (qtdemux->old_streams, oldstream); } else { GstTagList *list; @@ -12201,14 +12832,6 @@ qtdemux_update_streams (GstQTDemux * qtdemux) stream->stream_tags = NULL; if (!gst_qtdemux_add_stream (qtdemux, stream, list)) return FALSE; - - /* New segment will be exposed at _update_segment in case of pull mode */ - if (!qtdemux->pending_newsegment && !qtdemux->pullbased) { - qtdemux->pending_newsegment = gst_event_new_segment (&qtdemux->segment); - if (qtdemux->segment_seqnum) - gst_event_set_seqnum (qtdemux->pending_newsegment, - qtdemux->segment_seqnum); - } } } @@ -12219,24 +12842,21 @@ qtdemux_update_streams (GstQTDemux * qtdemux) static GstFlowReturn qtdemux_expose_streams (GstQTDemux * qtdemux) { - GList *iter, *next; + gint i; GST_DEBUG_OBJECT (qtdemux, "exposing streams"); if (!qtdemux_is_streams_update (qtdemux)) { - GList *new, *old; - GST_DEBUG_OBJECT (qtdemux, "Reuse all streams"); - for (new = qtdemux->active_streams, old = qtdemux->old_streams; new && old; - new = g_list_next (new), old = g_list_next (old)) { - if (!qtdemux_reuse_and_configure_stream (qtdemux, - QTDEMUX_STREAM (old->data), QTDEMUX_STREAM (new->data))) + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *new_stream = QTDEMUX_NTH_STREAM (qtdemux, i); + QtDemuxStream *old_stream = QTDEMUX_NTH_OLD_STREAM (qtdemux, i); + if (!qtdemux_reuse_and_configure_stream (qtdemux, old_stream, new_stream)) return GST_FLOW_ERROR; } - g_list_free_full (qtdemux->old_streams, - (GDestroyNotify) gst_qtdemux_stream_free); - qtdemux->old_streams = NULL; + g_ptr_array_set_size (qtdemux->old_streams, 0); + qtdemux->need_segment = TRUE; return GST_FLOW_OK; } @@ -12245,8 +12865,8 @@ qtdemux_expose_streams (GstQTDemux * qtdemux) if (!qtdemux_update_streams (qtdemux)) return GST_FLOW_ERROR; } else { - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); + for (i = 0; i < QTDEMUX_N_STREAMS (qtdemux); i++) { + QtDemuxStream *stream = QTDEMUX_NTH_STREAM (qtdemux, i); GstTagList *list; /* now we have all info and can expose */ @@ -12255,13 +12875,6 @@ qtdemux_expose_streams (GstQTDemux * qtdemux) if (!gst_qtdemux_add_stream (qtdemux, stream, list)) return GST_FLOW_ERROR; - /* New segment will be exposed at _update_segment in case of pull mode */ - if (!qtdemux->pending_newsegment && !qtdemux->pullbased) { - qtdemux->pending_newsegment = gst_event_new_segment (&qtdemux->segment); - if (qtdemux->segment_seqnum) - gst_event_set_seqnum (qtdemux->pending_newsegment, - qtdemux->segment_seqnum); - } } } @@ -12270,9 +12883,8 @@ qtdemux_expose_streams (GstQTDemux * qtdemux) gst_element_no_more_pads (GST_ELEMENT_CAST (qtdemux)); /* If we have still old_streams, it's no more used stream */ - for (iter = qtdemux->old_streams; iter; iter = next) { - QtDemuxStream *stream = QTDEMUX_STREAM (iter->data); - next = g_list_next (iter); + for (i = 0; i < qtdemux->old_streams->len; i++) { + QtDemuxStream *stream = QTDEMUX_NTH_OLD_STREAM (qtdemux, i); if (stream->pad) { GstEvent *event; @@ -12283,15 +12895,14 @@ qtdemux_expose_streams (GstQTDemux * qtdemux) gst_pad_push_event (stream->pad, event); } - - qtdemux->old_streams = g_list_remove (qtdemux->old_streams, stream); - gst_qtdemux_stream_free (stream); } + g_ptr_array_set_size (qtdemux->old_streams, 0); + /* check if we should post a redirect in case there is a single trak * and it is a redirecting trak */ - if (qtdemux->n_streams == 1 && - QTDEMUX_FIRST_STREAM (qtdemux)->redirect_uri != NULL) { + if (QTDEMUX_N_STREAMS (qtdemux) == 1 && + QTDEMUX_NTH_STREAM (qtdemux, 0)->redirect_uri != NULL) { GstMessage *m; GST_INFO_OBJECT (qtdemux, "Issuing a redirect due to a single track with " @@ -12299,14 +12910,15 @@ qtdemux_expose_streams (GstQTDemux * qtdemux) m = gst_message_new_element (GST_OBJECT_CAST (qtdemux), gst_structure_new ("redirect", "new-location", G_TYPE_STRING, - QTDEMUX_FIRST_STREAM (qtdemux)->redirect_uri, NULL)); + QTDEMUX_NTH_STREAM (qtdemux, 0)->redirect_uri, NULL)); gst_element_post_message (GST_ELEMENT_CAST (qtdemux), m); qtdemux->posted_redirect = TRUE; } - for (iter = qtdemux->active_streams; iter; iter = g_list_next (iter)) { - qtdemux_do_allocation (qtdemux, QTDEMUX_STREAM (iter->data)); - } + g_ptr_array_foreach (qtdemux->active_streams, + (GFunc) qtdemux_do_allocation, qtdemux); + + qtdemux->need_segment = TRUE; qtdemux->exposed = TRUE; return GST_FLOW_OK; @@ -13496,7 +14108,6 @@ qtdemux_parse_tree (GstQTDemux * qtdemux) GNode *trak; GNode *udta; GNode *mvex; - GstClockTime duration; GNode *pssh; guint64 creation_time; GstDateTime *datetime = NULL; @@ -13576,9 +14187,13 @@ qtdemux_parse_tree (GstQTDemux * qtdemux) qtdemux_parse_mehd (qtdemux, &mehd_data); } - /* set duration in the segment info */ - gst_qtdemux_get_duration (qtdemux, &duration); - if (duration) { + /* Update the movie segment duration, unless it was directly given to us + * by upstream. Otherwise let it as is, as we don't want to mangle the + * duration provided by upstream that may come e.g. from a MPD file. */ + if (!qtdemux->upstream_format_is_time) { + GstClockTime duration; + /* set duration in the segment info */ + gst_qtdemux_get_duration (qtdemux, &duration); qtdemux->segment.duration = duration; /* also do not exceed duration; stop is set that way post seek anyway, * and segment activation falls back to duration, @@ -14479,6 +15094,10 @@ qtdemux_video_caps (GstQTDemux * qtdemux, QtDemuxStream * stream, caps = gst_caps_new_simple ("video/x-wmv", "wmvversion", G_TYPE_INT, 3, "format", G_TYPE_STRING, "WVC1", NULL); break; + case FOURCC_av01: + _codec ("AV1"); + caps = gst_caps_new_empty_simple ("video/x-av1"); + break; case GST_MAKE_FOURCC ('k', 'p', 'c', 'd'): default: { @@ -14877,8 +15496,9 @@ qtdemux_sub_caps (GstQTDemux * qtdemux, QtDemuxStream * stream, _codec ("CEA 608 Closed Caption"); caps = gst_caps_new_simple ("closedcaption/x-cea-608", "format", - G_TYPE_STRING, "cc_data", NULL); + G_TYPE_STRING, "s334-1a", NULL); stream->need_process = TRUE; + stream->need_split = TRUE; break; case FOURCC_c708: _codec ("CEA 708 Closed Caption");