gst/matroska/matroska-demux.c

   1 /* GStreamer Matroska muxer/demuxer
   2  * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
   3  * (c) 2006 Tim-Philipp Müller <tim centricular net>
   4  * (c) 2008 Sebastian Dröge <slomo@circular-chaos.org>
   5  * (c) 2011 Debarshi Ray <rishi@gnu.org>
   6  *
   7  * matroska-demux.c: matroska file/stream demuxer
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 /* TODO: check CRC32 if present
  26  * TODO: there can be a segment after the first segment. Handle like
  27  *       chained oggs. Fixes #334082
  28  * TODO: Test samples: http://www.matroska.org/samples/matrix/index.html
  29  *                     http://samples.mplayerhq.hu/Matroska/
  30  * TODO: check if demuxing is done correct for all codecs according to spec
  31  * TODO: seeking with incomplete or without CUE
  32  */
  33
  34 /**
  35  * SECTION:element-matroskademux
  36  *
  37  * matroskademux demuxes a Matroska file into the different contained streams.
  38  *
  39  * <refsect2>
  40  * <title>Example launch line</title>
  41  * |[
  42  * gst-launch-1.0 -v filesrc location=/path/to/mkv ! matroskademux ! vorbisdec ! audioconvert ! audioresample ! autoaudiosink
  43  * ]| This pipeline demuxes a Matroska file and outputs the contained Vorbis audio.
  44  * </refsect2>
  45  */
  46
  47
  48 #ifdef HAVE_CONFIG_H
  49 #include "config.h"
  50 #endif
  51
  52 #include <math.h>
  53 #include <string.h>
  54 #include <glib/gprintf.h>
  55
  56 /* For AVI compatibility mode
  57    and for fourcc stuff */
  58 #include <gst/riff/riff-read.h>
  59 #include <gst/riff/riff-ids.h>
  60 #include <gst/riff/riff-media.h>
  61
  62 #include <gst/audio/audio.h>
  63 #include <gst/tag/tag.h>
  64 #include <gst/pbutils/pbutils.h>
  65 #include <gst/video/video.h>
  66
  67 #include "matroska-demux.h"
  68 #include "matroska-ids.h"
  69
  70 GST_DEBUG_CATEGORY_STATIC (matroskademux_debug);
  71 #define GST_CAT_DEFAULT matroskademux_debug
  72
  73 #define DEBUG_ELEMENT_START(demux, ebml, element) \
  74     GST_DEBUG_OBJECT (demux, "Parsing " element " element at offset %" \
  75         G_GUINT64_FORMAT, gst_ebml_read_get_pos (ebml))
  76
  77 #define DEBUG_ELEMENT_STOP(demux, ebml, element, ret) \
  78     GST_DEBUG_OBJECT (demux, "Parsing " element " element " \
  79         " finished with '%s'", gst_flow_get_name (ret))
  80
  81 enum
  82 {
  83   PROP_0,
  84   PROP_METADATA,
  85   PROP_STREAMINFO,
  86   PROP_MAX_GAP_TIME
  87 };
  88
  89 #define  DEFAULT_MAX_GAP_TIME      (2 * GST_SECOND)
  90 #define  INVALID_DATA_THRESHOLD    (2 * 1024 * 1024)
  91
  92 static GstStaticPadTemplate sink_templ = GST_STATIC_PAD_TEMPLATE ("sink",
  93     GST_PAD_SINK,
  94     GST_PAD_ALWAYS,
  95     GST_STATIC_CAPS ("audio/x-matroska; video/x-matroska; "
  96         "video/x-matroska-3d; audio/webm; video/webm")
  97     );
  98
  99 /* TODO: fill in caps! */
 100
 101 static GstStaticPadTemplate audio_src_templ =
 102 GST_STATIC_PAD_TEMPLATE ("audio_%u",
 103     GST_PAD_SRC,
 104     GST_PAD_SOMETIMES,
 105     GST_STATIC_CAPS ("ANY")
 106     );
 107
 108 static GstStaticPadTemplate video_src_templ =
 109 GST_STATIC_PAD_TEMPLATE ("video_%u",
 110     GST_PAD_SRC,
 111     GST_PAD_SOMETIMES,
 112     GST_STATIC_CAPS ("ANY")
 113     );
 114
 115 static GstStaticPadTemplate subtitle_src_templ =
 116     GST_STATIC_PAD_TEMPLATE ("subtitle_%u",
 117     GST_PAD_SRC,
 118     GST_PAD_SOMETIMES,
 119     GST_STATIC_CAPS ("text/x-raw, format=pango-markup; application/x-ssa; "
 120         "application/x-ass;application/x-usf; subpicture/x-dvd; "
 121         "subpicture/x-pgs; subtitle/x-kate; " "application/x-subtitle-unknown")
 122     );
 123
 124 static GstFlowReturn gst_matroska_demux_parse_id (GstMatroskaDemux * demux,
 125     guint32 id, guint64 length, guint needed);
 126
 127 /* element functions */
 128 static void gst_matroska_demux_loop (GstPad * pad);
 129
 130 static gboolean gst_matroska_demux_element_send_event (GstElement * element,
 131     GstEvent * event);
 132 static gboolean gst_matroska_demux_element_query (GstElement * element,
 133     GstQuery * query);
 134
 135 /* pad functions */
 136 static gboolean gst_matroska_demux_sink_activate (GstPad * sinkpad,
 137     GstObject * parent);
 138 static gboolean gst_matroska_demux_sink_activate_mode (GstPad * sinkpad,
 139     GstObject * parent, GstPadMode mode, gboolean active);
 140
 141 static gboolean gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux,
 142     GstPad * pad, GstEvent * event);
 143 static gboolean gst_matroska_demux_handle_src_event (GstPad * pad,
 144     GstObject * parent, GstEvent * event);
 145 static gboolean gst_matroska_demux_handle_src_query (GstPad * pad,
 146     GstObject * parent, GstQuery * query);
 147
 148 static gboolean gst_matroska_demux_handle_sink_event (GstPad * pad,
 149     GstObject * parent, GstEvent * event);
 150 static GstFlowReturn gst_matroska_demux_chain (GstPad * pad,
 151     GstObject * object, GstBuffer * buffer);
 152
 153 static GstStateChangeReturn
 154 gst_matroska_demux_change_state (GstElement * element,
 155     GstStateChange transition);
 156 #if 0
 157 static void
 158 gst_matroska_demux_set_index (GstElement * element, GstIndex * index);
 159 static GstIndex *gst_matroska_demux_get_index (GstElement * element);
 160 #endif
 161
 162 /* caps functions */
 163 static GstCaps *gst_matroska_demux_video_caps (GstMatroskaTrackVideoContext
 164     * videocontext, const gchar * codec_id, guint8 * data, guint size,
 165     gchar ** codec_name, guint32 * riff_fourcc);
 166 static GstCaps *gst_matroska_demux_audio_caps (GstMatroskaTrackAudioContext
 167     * audiocontext, const gchar * codec_id, guint8 * data, guint size,
 168     gchar ** codec_name, guint16 * riff_audio_fmt);
 169 static GstCaps
 170     * gst_matroska_demux_subtitle_caps (GstMatroskaTrackSubtitleContext *
 171     subtitlecontext, const gchar * codec_id, gpointer data, guint size);
 172
 173 /* stream methods */
 174 static void gst_matroska_demux_reset (GstElement * element);
 175 static gboolean perform_seek_to_offset (GstMatroskaDemux * demux,
 176     gdouble rate, guint64 offset, guint32 seqnum, GstSeekFlags flags);
 177
 178 /* gobject functions */
 179 static void gst_matroska_demux_set_property (GObject * object,
 180     guint prop_id, const GValue * value, GParamSpec * pspec);
 181 static void gst_matroska_demux_get_property (GObject * object,
 182     guint prop_id, GValue * value, GParamSpec * pspec);
 183
 184 GType gst_matroska_demux_get_type (void);
 185 #define parent_class gst_matroska_demux_parent_class
 186 G_DEFINE_TYPE (GstMatroskaDemux, gst_matroska_demux, GST_TYPE_ELEMENT);
 187
 188 static void
 189 gst_matroska_demux_finalize (GObject * object)
 190 {
 191   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (object);
 192
 193   gst_matroska_read_common_finalize (&demux->common);
 194   gst_flow_combiner_free (demux->flowcombiner);
 195   G_OBJECT_CLASS (parent_class)->finalize (object);
 196 }
 197
 198 static void
 199 gst_matroska_demux_class_init (GstMatroskaDemuxClass * klass)
 200 {
 201   GObjectClass *gobject_class = (GObjectClass *) klass;
 202   GstElementClass *gstelement_class = (GstElementClass *) klass;
 203
 204   GST_DEBUG_CATEGORY_INIT (matroskademux_debug, "matroskademux", 0,
 205       "Matroska demuxer");
 206
 207   gobject_class->finalize = gst_matroska_demux_finalize;
 208
 209   gobject_class->get_property = gst_matroska_demux_get_property;
 210   gobject_class->set_property = gst_matroska_demux_set_property;
 211
 212   g_object_class_install_property (gobject_class, PROP_MAX_GAP_TIME,
 213       g_param_spec_uint64 ("max-gap-time", "Maximum gap time",
 214           "The demuxer sends out segment events for skipping "
 215           "gaps longer than this (0 = disabled).", 0, G_MAXUINT64,
 216           DEFAULT_MAX_GAP_TIME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 217
 218   gstelement_class->change_state =
 219       GST_DEBUG_FUNCPTR (gst_matroska_demux_change_state);
 220   gstelement_class->send_event =
 221       GST_DEBUG_FUNCPTR (gst_matroska_demux_element_send_event);
 222   gstelement_class->query =
 223       GST_DEBUG_FUNCPTR (gst_matroska_demux_element_query);
 224 #if 0
 225   gstelement_class->set_index =
 226       GST_DEBUG_FUNCPTR (gst_matroska_demux_set_index);
 227   gstelement_class->get_index =
 228       GST_DEBUG_FUNCPTR (gst_matroska_demux_get_index);
 229 #endif
 230
 231   gst_element_class_add_static_pad_template (gstelement_class,
 232       &video_src_templ);
 233   gst_element_class_add_static_pad_template (gstelement_class,
 234       &audio_src_templ);
 235   gst_element_class_add_static_pad_template (gstelement_class,
 236       &subtitle_src_templ);
 237   gst_element_class_add_static_pad_template (gstelement_class, &sink_templ);
 238
 239   gst_element_class_set_static_metadata (gstelement_class, "Matroska demuxer",
 240       "Codec/Demuxer",
 241       "Demuxes Matroska/WebM streams into video/audio/subtitles",
 242       "GStreamer maintainers <gstreamer-devel@lists.freedesktop.org>");
 243 }
 244
 245 static void
 246 gst_matroska_demux_init (GstMatroskaDemux * demux)
 247 {
 248   demux->common.sinkpad = gst_pad_new_from_static_template (&sink_templ,
 249       "sink");
 250   gst_pad_set_activate_function (demux->common.sinkpad,
 251       GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate));
 252   gst_pad_set_activatemode_function (demux->common.sinkpad,
 253       GST_DEBUG_FUNCPTR (gst_matroska_demux_sink_activate_mode));
 254   gst_pad_set_chain_function (demux->common.sinkpad,
 255       GST_DEBUG_FUNCPTR (gst_matroska_demux_chain));
 256   gst_pad_set_event_function (demux->common.sinkpad,
 257       GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_sink_event));
 258   gst_element_add_pad (GST_ELEMENT (demux), demux->common.sinkpad);
 259
 260   /* init defaults for common read context */
 261   gst_matroska_read_common_init (&demux->common);
 262
 263   /* property defaults */
 264   demux->max_gap_time = DEFAULT_MAX_GAP_TIME;
 265
 266   GST_OBJECT_FLAG_SET (demux, GST_ELEMENT_FLAG_INDEXABLE);
 267
 268   demux->flowcombiner = gst_flow_combiner_new ();
 269
 270   /* finish off */
 271   gst_matroska_demux_reset (GST_ELEMENT (demux));
 272 }
 273
 274 static void
 275 gst_matroska_demux_reset (GstElement * element)
 276 {
 277   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
 278
 279   GST_DEBUG_OBJECT (demux, "Resetting state");
 280
 281   gst_matroska_read_common_reset (GST_ELEMENT (demux), &demux->common);
 282
 283   demux->num_a_streams = 0;
 284   demux->num_t_streams = 0;
 285   demux->num_v_streams = 0;
 286
 287   demux->have_group_id = FALSE;
 288   demux->group_id = G_MAXUINT;
 289
 290   demux->clock = NULL;
 291   demux->tracks_parsed = FALSE;
 292
 293   if (demux->clusters) {
 294     g_array_free (demux->clusters, TRUE);
 295     demux->clusters = NULL;
 296   }
 297
 298   g_list_foreach (demux->seek_parsed,
 299       (GFunc) gst_matroska_read_common_free_parsed_el, NULL);
 300   g_list_free (demux->seek_parsed);
 301   demux->seek_parsed = NULL;
 302
 303   demux->last_stop_end = GST_CLOCK_TIME_NONE;
 304   demux->seek_block = 0;
 305   demux->stream_start_time = GST_CLOCK_TIME_NONE;
 306   demux->to_time = GST_CLOCK_TIME_NONE;
 307   demux->cluster_time = GST_CLOCK_TIME_NONE;
 308   demux->cluster_offset = 0;
 309   demux->next_cluster_offset = 0;
 310   demux->index_offset = 0;
 311   demux->seekable = FALSE;
 312   demux->need_segment = FALSE;
 313   demux->segment_seqnum = 0;
 314   demux->requested_seek_time = GST_CLOCK_TIME_NONE;
 315   demux->seek_offset = -1;
 316   demux->building_index = FALSE;
 317   if (demux->seek_event) {
 318     gst_event_unref (demux->seek_event);
 319     demux->seek_event = NULL;
 320   }
 321
 322   demux->seek_index = NULL;
 323   demux->seek_entry = 0;
 324
 325   if (demux->new_segment) {
 326     gst_event_unref (demux->new_segment);
 327     demux->new_segment = NULL;
 328   }
 329
 330   demux->invalid_duration = FALSE;
 331
 332   demux->cached_length = G_MAXUINT64;
 333
 334   gst_flow_combiner_clear (demux->flowcombiner);
 335 }
 336
 337 static GstBuffer *
 338 gst_matroska_decode_buffer (GstMatroskaTrackContext * context, GstBuffer * buf)
 339 {
 340   GstMapInfo map;
 341   gpointer data;
 342   gsize size;
 343
 344   g_return_val_if_fail (GST_IS_BUFFER (buf), NULL);
 345
 346   GST_DEBUG ("decoding buffer %p", buf);
 347
 348   gst_buffer_map (buf, &map, GST_MAP_READ);
 349   data = map.data;
 350   size = map.size;
 351
 352   g_return_val_if_fail (size > 0, buf);
 353
 354   if (gst_matroska_decode_data (context->encodings, &data, &size,
 355           GST_MATROSKA_TRACK_ENCODING_SCOPE_FRAME, FALSE)) {
 356     gst_buffer_unmap (buf, &map);
 357     gst_buffer_unref (buf);
 358     return gst_buffer_new_wrapped (data, size);
 359   } else {
 360     GST_DEBUG ("decode data failed");
 361     gst_buffer_unmap (buf, &map);
 362     gst_buffer_unref (buf);
 363     return NULL;
 364   }
 365 }
 366
 367 static void
 368 gst_matroska_demux_add_stream_headers_to_caps (GstMatroskaDemux * demux,
 369     GstBufferList * list, GstCaps * caps)
 370 {
 371   GstStructure *s;
 372   GValue arr_val = G_VALUE_INIT;
 373   GValue buf_val = G_VALUE_INIT;
 374   gint i, num;
 375
 376   g_assert (gst_caps_is_writable (caps));
 377
 378   g_value_init (&arr_val, GST_TYPE_ARRAY);
 379   g_value_init (&buf_val, GST_TYPE_BUFFER);
 380
 381   num = gst_buffer_list_length (list);
 382   for (i = 0; i < num; ++i) {
 383     g_value_set_boxed (&buf_val, gst_buffer_list_get (list, i));
 384     gst_value_array_append_value (&arr_val, &buf_val);
 385   }
 386
 387   s = gst_caps_get_structure (caps, 0);
 388   gst_structure_take_value (s, "streamheader", &arr_val);
 389   g_value_unset (&buf_val);
 390 }
 391
 392 static GstFlowReturn
 393 gst_matroska_demux_add_stream (GstMatroskaDemux * demux, GstEbmlRead * ebml)
 394 {
 395   GstElementClass *klass = GST_ELEMENT_GET_CLASS (demux);
 396   GstMatroskaTrackContext *context;
 397   GstPadTemplate *templ = NULL;
 398   GstStreamFlags stream_flags;
 399   GstCaps *caps = NULL;
 400   GstTagList *cached_taglist;
 401   gchar *padname = NULL;
 402   GstFlowReturn ret;
 403   guint32 id, riff_fourcc = 0;
 404   guint16 riff_audio_fmt = 0;
 405   GstEvent *stream_start;
 406   gchar *codec = NULL;
 407   gchar *stream_id;
 408
 409   DEBUG_ELEMENT_START (demux, ebml, "TrackEntry");
 410
 411   /* start with the master */
 412   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
 413     DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret);
 414     return ret;
 415   }
 416
 417   /* allocate generic... if we know the type, we'll g_renew()
 418    * with the precise type */
 419   context = g_new0 (GstMatroskaTrackContext, 1);
 420   g_ptr_array_add (demux->common.src, context);
 421   context->index = demux->common.num_streams;
 422   context->index_writer_id = -1;
 423   context->type = 0;            /* no type yet */
 424   context->default_duration = 0;
 425   context->pos = 0;
 426   context->set_discont = TRUE;
 427   context->timecodescale = 1.0;
 428   context->flags =
 429       GST_MATROSKA_TRACK_ENABLED | GST_MATROSKA_TRACK_DEFAULT |
 430       GST_MATROSKA_TRACK_LACING;
 431   context->from_time = GST_CLOCK_TIME_NONE;
 432   context->from_offset = -1;
 433   context->to_offset = G_MAXINT64;
 434   context->alignment = 1;
 435   context->dts_only = FALSE;
 436   context->intra_only = FALSE;
 437   context->tags = gst_tag_list_new_empty ();
 438   demux->common.num_streams++;
 439   g_assert (demux->common.src->len == demux->common.num_streams);
 440
 441   GST_DEBUG_OBJECT (demux, "Stream number %d", context->index);
 442
 443   /* try reading the trackentry headers */
 444   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
 445     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
 446       break;
 447
 448     switch (id) {
 449         /* track number (unique stream ID) */
 450       case GST_MATROSKA_ID_TRACKNUMBER:{
 451         guint64 num;
 452
 453         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 454           break;
 455
 456         if (num == 0) {
 457           GST_ERROR_OBJECT (demux, "Invalid TrackNumber 0");
 458           ret = GST_FLOW_ERROR;
 459           break;
 460         } else if (!gst_matroska_read_common_tracknumber_unique (&demux->common,
 461                 num)) {
 462           GST_ERROR_OBJECT (demux, "TrackNumber %" G_GUINT64_FORMAT
 463               " is not unique", num);
 464           ret = GST_FLOW_ERROR;
 465           break;
 466         }
 467
 468         GST_DEBUG_OBJECT (demux, "TrackNumber: %" G_GUINT64_FORMAT, num);
 469         context->num = num;
 470         break;
 471       }
 472         /* track UID (unique identifier) */
 473       case GST_MATROSKA_ID_TRACKUID:{
 474         guint64 num;
 475
 476         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 477           break;
 478
 479         if (num == 0) {
 480           GST_ERROR_OBJECT (demux, "Invalid TrackUID 0");
 481           ret = GST_FLOW_ERROR;
 482           break;
 483         }
 484
 485         GST_DEBUG_OBJECT (demux, "TrackUID: %" G_GUINT64_FORMAT, num);
 486         context->uid = num;
 487         break;
 488       }
 489
 490         /* track type (video, audio, combined, subtitle, etc.) */
 491       case GST_MATROSKA_ID_TRACKTYPE:{
 492         guint64 track_type;
 493
 494         if ((ret = gst_ebml_read_uint (ebml, &id, &track_type)) != GST_FLOW_OK) {
 495           break;
 496         }
 497
 498         if (context->type != 0 && context->type != track_type) {
 499           GST_WARNING_OBJECT (demux,
 500               "More than one tracktype defined in a TrackEntry - skipping");
 501           break;
 502         } else if (track_type < 1 || track_type > 254) {
 503           GST_WARNING_OBJECT (demux, "Invalid TrackType %" G_GUINT64_FORMAT,
 504               track_type);
 505           break;
 506         }
 507
 508         GST_DEBUG_OBJECT (demux, "TrackType: %" G_GUINT64_FORMAT, track_type);
 509
 510         /* ok, so we're actually going to reallocate this thing */
 511         switch (track_type) {
 512           case GST_MATROSKA_TRACK_TYPE_VIDEO:
 513             gst_matroska_track_init_video_context (&context);
 514             break;
 515           case GST_MATROSKA_TRACK_TYPE_AUDIO:
 516             gst_matroska_track_init_audio_context (&context);
 517             break;
 518           case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
 519             gst_matroska_track_init_subtitle_context (&context);
 520             break;
 521           case GST_MATROSKA_TRACK_TYPE_COMPLEX:
 522           case GST_MATROSKA_TRACK_TYPE_LOGO:
 523           case GST_MATROSKA_TRACK_TYPE_BUTTONS:
 524           case GST_MATROSKA_TRACK_TYPE_CONTROL:
 525           default:
 526             GST_WARNING_OBJECT (demux,
 527                 "Unknown or unsupported TrackType %" G_GUINT64_FORMAT,
 528                 track_type);
 529             context->type = 0;
 530             break;
 531         }
 532         g_ptr_array_index (demux->common.src, demux->common.num_streams - 1)
 533             = context;
 534         break;
 535       }
 536
 537         /* tracktype specific stuff for video */
 538       case GST_MATROSKA_ID_TRACKVIDEO:{
 539         GstMatroskaTrackVideoContext *videocontext;
 540
 541         DEBUG_ELEMENT_START (demux, ebml, "TrackVideo");
 542
 543         if (!gst_matroska_track_init_video_context (&context)) {
 544           GST_WARNING_OBJECT (demux,
 545               "TrackVideo element in non-video track - ignoring track");
 546           ret = GST_FLOW_ERROR;
 547           break;
 548         } else if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
 549           break;
 550         }
 551         videocontext = (GstMatroskaTrackVideoContext *) context;
 552         g_ptr_array_index (demux->common.src, demux->common.num_streams - 1)
 553             = context;
 554
 555         while (ret == GST_FLOW_OK &&
 556             gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
 557           if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
 558             break;
 559
 560           switch (id) {
 561               /* Should be one level up but some broken muxers write it here. */
 562             case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{
 563               guint64 num;
 564
 565               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 566                 break;
 567
 568               if (num == 0) {
 569                 GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0");
 570                 break;
 571               }
 572
 573               GST_DEBUG_OBJECT (demux,
 574                   "TrackDefaultDuration: %" G_GUINT64_FORMAT, num);
 575               context->default_duration = num;
 576               break;
 577             }
 578
 579               /* video framerate */
 580               /* NOTE: This one is here only for backward compatibility.
 581                * Use _TRACKDEFAULDURATION one level up. */
 582             case GST_MATROSKA_ID_VIDEOFRAMERATE:{
 583               gdouble num;
 584
 585               if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
 586                 break;
 587
 588               if (num <= 0.0) {
 589                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoFPS %lf", num);
 590                 break;
 591               }
 592
 593               GST_DEBUG_OBJECT (demux, "TrackVideoFrameRate: %lf", num);
 594               if (context->default_duration == 0)
 595                 context->default_duration =
 596                     gst_gdouble_to_guint64 ((gdouble) GST_SECOND * (1.0 / num));
 597               videocontext->default_fps = num;
 598               break;
 599             }
 600
 601               /* width of the size to display the video at */
 602             case GST_MATROSKA_ID_VIDEODISPLAYWIDTH:{
 603               guint64 num;
 604
 605               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 606                 break;
 607
 608               if (num == 0) {
 609                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayWidth 0");
 610                 break;
 611               }
 612
 613               GST_DEBUG_OBJECT (demux,
 614                   "TrackVideoDisplayWidth: %" G_GUINT64_FORMAT, num);
 615               videocontext->display_width = num;
 616               break;
 617             }
 618
 619               /* height of the size to display the video at */
 620             case GST_MATROSKA_ID_VIDEODISPLAYHEIGHT:{
 621               guint64 num;
 622
 623               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 624                 break;
 625
 626               if (num == 0) {
 627                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoDisplayHeight 0");
 628                 break;
 629               }
 630
 631               GST_DEBUG_OBJECT (demux,
 632                   "TrackVideoDisplayHeight: %" G_GUINT64_FORMAT, num);
 633               videocontext->display_height = num;
 634               break;
 635             }
 636
 637               /* width of the video in the file */
 638             case GST_MATROSKA_ID_VIDEOPIXELWIDTH:{
 639               guint64 num;
 640
 641               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 642                 break;
 643
 644               if (num == 0) {
 645                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelWidth 0");
 646                 break;
 647               }
 648
 649               GST_DEBUG_OBJECT (demux,
 650                   "TrackVideoPixelWidth: %" G_GUINT64_FORMAT, num);
 651               videocontext->pixel_width = num;
 652               break;
 653             }
 654
 655               /* height of the video in the file */
 656             case GST_MATROSKA_ID_VIDEOPIXELHEIGHT:{
 657               guint64 num;
 658
 659               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 660                 break;
 661
 662               if (num == 0) {
 663                 GST_WARNING_OBJECT (demux, "Invalid TrackVideoPixelHeight 0");
 664                 break;
 665               }
 666
 667               GST_DEBUG_OBJECT (demux,
 668                   "TrackVideoPixelHeight: %" G_GUINT64_FORMAT, num);
 669               videocontext->pixel_height = num;
 670               break;
 671             }
 672
 673               /* whether the video is interlaced */
 674             case GST_MATROSKA_ID_VIDEOFLAGINTERLACED:{
 675               guint64 num;
 676
 677               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 678                 break;
 679
 680               if (num)
 681                 context->flags |= GST_MATROSKA_VIDEOTRACK_INTERLACED;
 682               else
 683                 context->flags &= ~GST_MATROSKA_VIDEOTRACK_INTERLACED;
 684               GST_DEBUG_OBJECT (demux, "TrackVideoInterlaced: %d",
 685                   (context->flags & GST_MATROSKA_VIDEOTRACK_INTERLACED) ? 1 :
 686                   0);
 687               break;
 688             }
 689
 690               /* aspect ratio behaviour */
 691             case GST_MATROSKA_ID_VIDEOASPECTRATIOTYPE:{
 692               guint64 num;
 693
 694               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 695                 break;
 696
 697               if (num != GST_MATROSKA_ASPECT_RATIO_MODE_FREE &&
 698                   num != GST_MATROSKA_ASPECT_RATIO_MODE_KEEP &&
 699                   num != GST_MATROSKA_ASPECT_RATIO_MODE_FIXED) {
 700                 GST_WARNING_OBJECT (demux,
 701                     "Unknown TrackVideoAspectRatioType 0x%x", (guint) num);
 702                 break;
 703               }
 704               GST_DEBUG_OBJECT (demux,
 705                   "TrackVideoAspectRatioType: %" G_GUINT64_FORMAT, num);
 706               videocontext->asr_mode = num;
 707               break;
 708             }
 709
 710               /* colourspace (only matters for raw video) fourcc */
 711             case GST_MATROSKA_ID_VIDEOCOLOURSPACE:{
 712               guint8 *data;
 713               guint64 datalen;
 714
 715               if ((ret =
 716                       gst_ebml_read_binary (ebml, &id, &data,
 717                           &datalen)) != GST_FLOW_OK)
 718                 break;
 719
 720               if (datalen != 4) {
 721                 g_free (data);
 722                 GST_WARNING_OBJECT (demux,
 723                     "Invalid TrackVideoColourSpace length %" G_GUINT64_FORMAT,
 724                     datalen);
 725                 break;
 726               }
 727
 728               memcpy (&videocontext->fourcc, data, 4);
 729               GST_DEBUG_OBJECT (demux,
 730                   "TrackVideoColourSpace: %" GST_FOURCC_FORMAT,
 731                   GST_FOURCC_ARGS (videocontext->fourcc));
 732               g_free (data);
 733               break;
 734             }
 735             case GST_MATROSKA_ID_VIDEOSTEREOMODE:
 736             {
 737               guint64 num;
 738
 739               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 740                 break;
 741
 742               GST_DEBUG_OBJECT (demux, "StereoMode: %" G_GUINT64_FORMAT, num);
 743
 744               switch (num) {
 745                 case GST_MATROSKA_STEREO_MODE_SBS_RL:
 746                   videocontext->multiview_flags =
 747                       GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
 748                   /* fall through */
 749                 case GST_MATROSKA_STEREO_MODE_SBS_LR:
 750                   videocontext->multiview_mode =
 751                       GST_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE;
 752                   break;
 753                 case GST_MATROSKA_STEREO_MODE_TB_RL:
 754                   videocontext->multiview_flags =
 755                       GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
 756                   /* fall through */
 757                 case GST_MATROSKA_STEREO_MODE_TB_LR:
 758                   videocontext->multiview_mode =
 759                       GST_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM;
 760                   break;
 761                 case GST_MATROSKA_STEREO_MODE_CHECKER_RL:
 762                   videocontext->multiview_flags =
 763                       GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
 764                   /* fall through */
 765                 case GST_MATROSKA_STEREO_MODE_CHECKER_LR:
 766                   videocontext->multiview_mode =
 767                       GST_VIDEO_MULTIVIEW_MODE_CHECKERBOARD;
 768                   break;
 769                 case GST_MATROSKA_STEREO_MODE_FBF_RL:
 770                   videocontext->multiview_flags =
 771                       GST_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST;
 772                   /* fall through */
 773                 case GST_MATROSKA_STEREO_MODE_FBF_LR:
 774                   videocontext->multiview_mode =
 775                       GST_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME;
 776                   /* FIXME: In frame-by-frame mode, left/right frame buffers are
 777                    * laced within one block, and we'll need to apply FIRST_IN_BUNDLE
 778                    * accordingly. See http://www.matroska.org/technical/specs/index.html#StereoMode */
 779                   GST_FIXME_OBJECT (demux,
 780                       "Frame-by-frame stereoscopic mode not fully implemented");
 781                   break;
 782               }
 783               break;
 784             }
 785
 786             default:
 787               GST_WARNING_OBJECT (demux,
 788                   "Unknown TrackVideo subelement 0x%x - ignoring", id);
 789               /* fall through */
 790             case GST_MATROSKA_ID_VIDEODISPLAYUNIT:
 791             case GST_MATROSKA_ID_VIDEOPIXELCROPBOTTOM:
 792             case GST_MATROSKA_ID_VIDEOPIXELCROPTOP:
 793             case GST_MATROSKA_ID_VIDEOPIXELCROPLEFT:
 794             case GST_MATROSKA_ID_VIDEOPIXELCROPRIGHT:
 795             case GST_MATROSKA_ID_VIDEOGAMMAVALUE:
 796               ret = gst_ebml_read_skip (ebml);
 797               break;
 798           }
 799         }
 800
 801         DEBUG_ELEMENT_STOP (demux, ebml, "TrackVideo", ret);
 802         break;
 803       }
 804
 805         /* tracktype specific stuff for audio */
 806       case GST_MATROSKA_ID_TRACKAUDIO:{
 807         GstMatroskaTrackAudioContext *audiocontext;
 808
 809         DEBUG_ELEMENT_START (demux, ebml, "TrackAudio");
 810
 811         if (!gst_matroska_track_init_audio_context (&context)) {
 812           GST_WARNING_OBJECT (demux,
 813               "TrackAudio element in non-audio track - ignoring track");
 814           ret = GST_FLOW_ERROR;
 815           break;
 816         }
 817
 818         if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK)
 819           break;
 820
 821         audiocontext = (GstMatroskaTrackAudioContext *) context;
 822         g_ptr_array_index (demux->common.src, demux->common.num_streams - 1)
 823             = context;
 824
 825         while (ret == GST_FLOW_OK &&
 826             gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
 827           if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
 828             break;
 829
 830           switch (id) {
 831               /* samplerate */
 832             case GST_MATROSKA_ID_AUDIOSAMPLINGFREQ:{
 833               gdouble num;
 834
 835               if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
 836                 break;
 837
 838
 839               if (num <= 0.0) {
 840                 GST_WARNING_OBJECT (demux,
 841                     "Invalid TrackAudioSamplingFrequency %lf", num);
 842                 break;
 843               }
 844
 845               GST_DEBUG_OBJECT (demux, "TrackAudioSamplingFrequency: %lf", num);
 846               audiocontext->samplerate = num;
 847               break;
 848             }
 849
 850               /* bitdepth */
 851             case GST_MATROSKA_ID_AUDIOBITDEPTH:{
 852               guint64 num;
 853
 854               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 855                 break;
 856
 857               if (num == 0) {
 858                 GST_WARNING_OBJECT (demux, "Invalid TrackAudioBitDepth 0");
 859                 break;
 860               }
 861
 862               GST_DEBUG_OBJECT (demux, "TrackAudioBitDepth: %" G_GUINT64_FORMAT,
 863                   num);
 864               audiocontext->bitdepth = num;
 865               break;
 866             }
 867
 868               /* channels */
 869             case GST_MATROSKA_ID_AUDIOCHANNELS:{
 870               guint64 num;
 871
 872               if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 873                 break;
 874
 875               if (num == 0) {
 876                 GST_WARNING_OBJECT (demux, "Invalid TrackAudioChannels 0");
 877                 break;
 878               }
 879
 880               GST_DEBUG_OBJECT (demux, "TrackAudioChannels: %" G_GUINT64_FORMAT,
 881                   num);
 882               audiocontext->channels = num;
 883               break;
 884             }
 885
 886             default:
 887               GST_WARNING_OBJECT (demux,
 888                   "Unknown TrackAudio subelement 0x%x - ignoring", id);
 889               /* fall through */
 890             case GST_MATROSKA_ID_AUDIOCHANNELPOSITIONS:
 891             case GST_MATROSKA_ID_AUDIOOUTPUTSAMPLINGFREQ:
 892               ret = gst_ebml_read_skip (ebml);
 893               break;
 894           }
 895         }
 896
 897         DEBUG_ELEMENT_STOP (demux, ebml, "TrackAudio", ret);
 898
 899         break;
 900       }
 901
 902         /* codec identifier */
 903       case GST_MATROSKA_ID_CODECID:{
 904         gchar *text;
 905
 906         if ((ret = gst_ebml_read_ascii (ebml, &id, &text)) != GST_FLOW_OK)
 907           break;
 908
 909         GST_DEBUG_OBJECT (demux, "CodecID: %s", GST_STR_NULL (text));
 910         context->codec_id = text;
 911         break;
 912       }
 913
 914         /* codec private data */
 915       case GST_MATROSKA_ID_CODECPRIVATE:{
 916         guint8 *data;
 917         guint64 size;
 918
 919         if ((ret =
 920                 gst_ebml_read_binary (ebml, &id, &data, &size)) != GST_FLOW_OK)
 921           break;
 922
 923         context->codec_priv = data;
 924         context->codec_priv_size = size;
 925
 926         GST_DEBUG_OBJECT (demux, "CodecPrivate of size %" G_GUINT64_FORMAT,
 927             size);
 928         break;
 929       }
 930
 931         /* name of the codec */
 932       case GST_MATROSKA_ID_CODECNAME:{
 933         gchar *text;
 934
 935         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
 936           break;
 937
 938         GST_DEBUG_OBJECT (demux, "CodecName: %s", GST_STR_NULL (text));
 939         context->codec_name = text;
 940         break;
 941       }
 942
 943         /* codec delay */
 944       case GST_MATROSKA_ID_CODECDELAY:{
 945         guint64 num;
 946
 947         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 948           break;
 949
 950         context->codec_delay = num;
 951
 952         GST_DEBUG_OBJECT (demux, "CodecDelay: %" GST_TIME_FORMAT,
 953             GST_TIME_ARGS (num));
 954         break;
 955       }
 956
 957         /* codec delay */
 958       case GST_MATROSKA_ID_SEEKPREROLL:{
 959         guint64 num;
 960
 961         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
 962           break;
 963
 964         context->seek_preroll = num;
 965
 966         GST_DEBUG_OBJECT (demux, "SeekPreroll: %" GST_TIME_FORMAT,
 967             GST_TIME_ARGS (num));
 968         break;
 969       }
 970
 971         /* name of this track */
 972       case GST_MATROSKA_ID_TRACKNAME:{
 973         gchar *text;
 974
 975         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
 976           break;
 977
 978         context->name = text;
 979         GST_DEBUG_OBJECT (demux, "TrackName: %s", GST_STR_NULL (text));
 980         break;
 981       }
 982
 983         /* language (matters for audio/subtitles, mostly) */
 984       case GST_MATROSKA_ID_TRACKLANGUAGE:{
 985         gchar *text;
 986
 987         if ((ret = gst_ebml_read_utf8 (ebml, &id, &text)) != GST_FLOW_OK)
 988           break;
 989
 990
 991         context->language = text;
 992
 993         /* fre-ca => fre */
 994         if (strlen (context->language) >= 4 && context->language[3] == '-')
 995           context->language[3] = '\0';
 996
 997         GST_DEBUG_OBJECT (demux, "TrackLanguage: %s",
 998             GST_STR_NULL (context->language));
 999         break;
1000       }
1001
1002         /* whether this is actually used */
1003       case GST_MATROSKA_ID_TRACKFLAGENABLED:{
1004         guint64 num;
1005
1006         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1007           break;
1008
1009         if (num)
1010           context->flags |= GST_MATROSKA_TRACK_ENABLED;
1011         else
1012           context->flags &= ~GST_MATROSKA_TRACK_ENABLED;
1013
1014         GST_DEBUG_OBJECT (demux, "TrackEnabled: %d",
1015             (context->flags & GST_MATROSKA_TRACK_ENABLED) ? 1 : 0);
1016         break;
1017       }
1018
1019         /* whether it's the default for this track type */
1020       case GST_MATROSKA_ID_TRACKFLAGDEFAULT:{
1021         guint64 num;
1022
1023         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1024           break;
1025
1026         if (num)
1027           context->flags |= GST_MATROSKA_TRACK_DEFAULT;
1028         else
1029           context->flags &= ~GST_MATROSKA_TRACK_DEFAULT;
1030
1031         GST_DEBUG_OBJECT (demux, "TrackDefault: %d",
1032             (context->flags & GST_MATROSKA_TRACK_DEFAULT) ? 1 : 0);
1033         break;
1034       }
1035
1036         /* whether the track must be used during playback */
1037       case GST_MATROSKA_ID_TRACKFLAGFORCED:{
1038         guint64 num;
1039
1040         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1041           break;
1042
1043         if (num)
1044           context->flags |= GST_MATROSKA_TRACK_FORCED;
1045         else
1046           context->flags &= ~GST_MATROSKA_TRACK_FORCED;
1047
1048         GST_DEBUG_OBJECT (demux, "TrackForced: %d",
1049             (context->flags & GST_MATROSKA_TRACK_FORCED) ? 1 : 0);
1050         break;
1051       }
1052
1053         /* lacing (like MPEG, where blocks don't end/start on frame
1054          * boundaries) */
1055       case GST_MATROSKA_ID_TRACKFLAGLACING:{
1056         guint64 num;
1057
1058         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1059           break;
1060
1061         if (num)
1062           context->flags |= GST_MATROSKA_TRACK_LACING;
1063         else
1064           context->flags &= ~GST_MATROSKA_TRACK_LACING;
1065
1066         GST_DEBUG_OBJECT (demux, "TrackLacing: %d",
1067             (context->flags & GST_MATROSKA_TRACK_LACING) ? 1 : 0);
1068         break;
1069       }
1070
1071         /* default length (in time) of one data block in this track */
1072       case GST_MATROSKA_ID_TRACKDEFAULTDURATION:{
1073         guint64 num;
1074
1075         if ((ret = gst_ebml_read_uint (ebml, &id, &num)) != GST_FLOW_OK)
1076           break;
1077
1078
1079         if (num == 0) {
1080           GST_WARNING_OBJECT (demux, "Invalid TrackDefaultDuration 0");
1081           break;
1082         }
1083
1084         GST_DEBUG_OBJECT (demux, "TrackDefaultDuration: %" G_GUINT64_FORMAT,
1085             num);
1086         context->default_duration = num;
1087         break;
1088       }
1089
1090       case GST_MATROSKA_ID_CONTENTENCODINGS:{
1091         ret = gst_matroska_read_common_read_track_encodings (&demux->common,
1092             ebml, context);
1093         break;
1094       }
1095
1096       case GST_MATROSKA_ID_TRACKTIMECODESCALE:{
1097         gdouble num;
1098
1099         if ((ret = gst_ebml_read_float (ebml, &id, &num)) != GST_FLOW_OK)
1100           break;
1101
1102         if (num <= 0.0) {
1103           GST_WARNING_OBJECT (demux, "Invalid TrackTimeCodeScale %lf", num);
1104           break;
1105         }
1106
1107         GST_DEBUG_OBJECT (demux, "TrackTimeCodeScale: %lf", num);
1108         context->timecodescale = num;
1109         break;
1110       }
1111
1112       default:
1113         GST_WARNING ("Unknown TrackEntry subelement 0x%x - ignoring", id);
1114         /* pass-through */
1115
1116         /* we ignore these because they're nothing useful (i.e. crap)
1117          * or simply not implemented yet. */
1118       case GST_MATROSKA_ID_TRACKMINCACHE:
1119       case GST_MATROSKA_ID_TRACKMAXCACHE:
1120       case GST_MATROSKA_ID_MAXBLOCKADDITIONID:
1121       case GST_MATROSKA_ID_TRACKATTACHMENTLINK:
1122       case GST_MATROSKA_ID_TRACKOVERLAY:
1123       case GST_MATROSKA_ID_TRACKTRANSLATE:
1124       case GST_MATROSKA_ID_TRACKOFFSET:
1125       case GST_MATROSKA_ID_CODECSETTINGS:
1126       case GST_MATROSKA_ID_CODECINFOURL:
1127       case GST_MATROSKA_ID_CODECDOWNLOADURL:
1128       case GST_MATROSKA_ID_CODECDECODEALL:
1129         ret = gst_ebml_read_skip (ebml);
1130         break;
1131     }
1132   }
1133
1134   DEBUG_ELEMENT_STOP (demux, ebml, "TrackEntry", ret);
1135
1136   /* Decode codec private data if necessary */
1137   if (context->encodings && context->encodings->len > 0 && context->codec_priv
1138       && context->codec_priv_size > 0) {
1139     if (!gst_matroska_decode_data (context->encodings,
1140             &context->codec_priv, &context->codec_priv_size,
1141             GST_MATROSKA_TRACK_ENCODING_SCOPE_CODEC_DATA, TRUE)) {
1142       GST_WARNING_OBJECT (demux, "Decoding codec private data failed");
1143       ret = GST_FLOW_ERROR;
1144     }
1145   }
1146
1147   if (context->type == 0 || context->codec_id == NULL || (ret != GST_FLOW_OK
1148           && ret != GST_FLOW_EOS)) {
1149     if (ret == GST_FLOW_OK || ret == GST_FLOW_EOS)
1150       GST_WARNING_OBJECT (ebml, "Unknown stream/codec in track entry header");
1151
1152     demux->common.num_streams--;
1153     g_ptr_array_remove_index (demux->common.src, demux->common.num_streams);
1154     g_assert (demux->common.src->len == demux->common.num_streams);
1155     gst_matroska_track_free (context);
1156
1157     return ret;
1158   }
1159
1160   /* check for a cached track taglist  */
1161   cached_taglist =
1162       (GstTagList *) g_hash_table_lookup (demux->common.cached_track_taglists,
1163       GUINT_TO_POINTER (context->uid));
1164   if (cached_taglist)
1165     gst_tag_list_insert (context->tags, cached_taglist, GST_TAG_MERGE_APPEND);
1166
1167   /* now create the GStreamer connectivity */
1168   switch (context->type) {
1169     case GST_MATROSKA_TRACK_TYPE_VIDEO:{
1170       GstMatroskaTrackVideoContext *videocontext =
1171           (GstMatroskaTrackVideoContext *) context;
1172
1173       padname = g_strdup_printf ("video_%u", demux->num_v_streams++);
1174       templ = gst_element_class_get_pad_template (klass, "video_%u");
1175       caps = gst_matroska_demux_video_caps (videocontext,
1176           context->codec_id, context->codec_priv,
1177           context->codec_priv_size, &codec, &riff_fourcc);
1178
1179       if (codec) {
1180         gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE,
1181             GST_TAG_VIDEO_CODEC, codec, NULL);
1182         context->tags_changed = TRUE;
1183         g_free (codec);
1184       }
1185       break;
1186     }
1187
1188     case GST_MATROSKA_TRACK_TYPE_AUDIO:{
1189       GstMatroskaTrackAudioContext *audiocontext =
1190           (GstMatroskaTrackAudioContext *) context;
1191
1192       padname = g_strdup_printf ("audio_%u", demux->num_a_streams++);
1193       templ = gst_element_class_get_pad_template (klass, "audio_%u");
1194       caps = gst_matroska_demux_audio_caps (audiocontext,
1195           context->codec_id, context->codec_priv, context->codec_priv_size,
1196           &codec, &riff_audio_fmt);
1197
1198       if (codec) {
1199         gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE,
1200             GST_TAG_AUDIO_CODEC, codec, NULL);
1201         context->tags_changed = TRUE;
1202         g_free (codec);
1203       }
1204       break;
1205     }
1206
1207     case GST_MATROSKA_TRACK_TYPE_SUBTITLE:{
1208       GstMatroskaTrackSubtitleContext *subtitlecontext =
1209           (GstMatroskaTrackSubtitleContext *) context;
1210
1211       padname = g_strdup_printf ("subtitle_%u", demux->num_t_streams++);
1212       templ = gst_element_class_get_pad_template (klass, "subtitle_%u");
1213       caps = gst_matroska_demux_subtitle_caps (subtitlecontext,
1214           context->codec_id, context->codec_priv, context->codec_priv_size);
1215       break;
1216     }
1217
1218     case GST_MATROSKA_TRACK_TYPE_COMPLEX:
1219     case GST_MATROSKA_TRACK_TYPE_LOGO:
1220     case GST_MATROSKA_TRACK_TYPE_BUTTONS:
1221     case GST_MATROSKA_TRACK_TYPE_CONTROL:
1222     default:
1223       /* we should already have quit by now */
1224       g_assert_not_reached ();
1225   }
1226
1227   if ((context->language == NULL || *context->language == '\0') &&
1228       (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO ||
1229           context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)) {
1230     GST_LOG ("stream %d: language=eng (assuming default)", context->index);
1231     context->language = g_strdup ("eng");
1232   }
1233
1234   if (context->language) {
1235     const gchar *lang;
1236
1237     /* Matroska contains ISO 639-2B codes, we want ISO 639-1 */
1238     lang = gst_tag_get_language_code (context->language);
1239     gst_tag_list_add (context->tags, GST_TAG_MERGE_REPLACE,
1240         GST_TAG_LANGUAGE_CODE, (lang) ? lang : context->language, NULL);
1241     context->tags_changed = TRUE;
1242   }
1243
1244   if (caps == NULL) {
1245     GST_WARNING_OBJECT (demux, "could not determine caps for stream with "
1246         "codec_id='%s'", context->codec_id);
1247     switch (context->type) {
1248       case GST_MATROSKA_TRACK_TYPE_VIDEO:
1249         caps = gst_caps_new_empty_simple ("video/x-unknown");
1250         break;
1251       case GST_MATROSKA_TRACK_TYPE_AUDIO:
1252         caps = gst_caps_new_empty_simple ("audio/x-unknown");
1253         break;
1254       case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
1255         caps = gst_caps_new_empty_simple ("application/x-subtitle-unknown");
1256         break;
1257       case GST_MATROSKA_TRACK_TYPE_COMPLEX:
1258       default:
1259         caps = gst_caps_new_empty_simple ("application/x-matroska-unknown");
1260         break;
1261     }
1262     gst_caps_set_simple (caps, "codec-id", G_TYPE_STRING, context->codec_id,
1263         NULL);
1264
1265     /* add any unrecognised riff fourcc / audio format, but after codec-id */
1266     if (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO && riff_audio_fmt != 0)
1267       gst_caps_set_simple (caps, "format", G_TYPE_INT, riff_audio_fmt, NULL);
1268     else if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO && riff_fourcc != 0) {
1269       gchar *fstr = g_strdup_printf ("%" GST_FOURCC_FORMAT,
1270           GST_FOURCC_ARGS (riff_fourcc));
1271       gst_caps_set_simple (caps, "fourcc", G_TYPE_STRING, fstr, NULL);
1272       g_free (fstr);
1273     }
1274   } else if (context->stream_headers != NULL) {
1275     gst_matroska_demux_add_stream_headers_to_caps (demux,
1276         context->stream_headers, caps);
1277   }
1278
1279   /* the pad in here */
1280   context->pad = gst_pad_new_from_template (templ, padname);
1281   context->caps = caps;
1282
1283   gst_pad_set_event_function (context->pad,
1284       GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_event));
1285   gst_pad_set_query_function (context->pad,
1286       GST_DEBUG_FUNCPTR (gst_matroska_demux_handle_src_query));
1287
1288   GST_INFO_OBJECT (demux, "Adding pad '%s' with caps %" GST_PTR_FORMAT,
1289       padname, caps);
1290
1291   gst_pad_set_element_private (context->pad, context);
1292
1293   gst_pad_use_fixed_caps (context->pad);
1294   gst_pad_set_active (context->pad, TRUE);
1295
1296   stream_id =
1297       gst_pad_create_stream_id_printf (context->pad, GST_ELEMENT_CAST (demux),
1298       "%03" G_GUINT64_FORMAT ":%03" G_GUINT64_FORMAT,
1299       context->num, context->uid);
1300   stream_start =
1301       gst_pad_get_sticky_event (demux->common.sinkpad, GST_EVENT_STREAM_START,
1302       0);
1303   if (stream_start) {
1304     if (gst_event_parse_group_id (stream_start, &demux->group_id))
1305       demux->have_group_id = TRUE;
1306     else
1307       demux->have_group_id = FALSE;
1308     gst_event_unref (stream_start);
1309   } else if (!demux->have_group_id) {
1310     demux->have_group_id = TRUE;
1311     demux->group_id = gst_util_group_id_next ();
1312   }
1313
1314   stream_start = gst_event_new_stream_start (stream_id);
1315   g_free (stream_id);
1316   if (demux->have_group_id)
1317     gst_event_set_group_id (stream_start, demux->group_id);
1318   stream_flags = GST_STREAM_FLAG_NONE;
1319   if (context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)
1320     stream_flags |= GST_STREAM_FLAG_SPARSE;
1321   if (context->flags & GST_MATROSKA_TRACK_DEFAULT)
1322     stream_flags |= GST_STREAM_FLAG_SELECT;
1323   gst_event_set_stream_flags (stream_start, stream_flags);
1324   gst_pad_push_event (context->pad, stream_start);
1325   gst_pad_set_caps (context->pad, context->caps);
1326
1327
1328   if (demux->common.global_tags) {
1329     GstEvent *tag_event;
1330
1331     gst_tag_list_add (demux->common.global_tags, GST_TAG_MERGE_REPLACE,
1332         GST_TAG_CONTAINER_FORMAT, "Matroska", NULL);
1333     GST_DEBUG_OBJECT (context->pad, "Sending global_tags %p: %" GST_PTR_FORMAT,
1334         demux->common.global_tags, demux->common.global_tags);
1335
1336     tag_event =
1337         gst_event_new_tag (gst_tag_list_copy (demux->common.global_tags));
1338
1339     gst_pad_push_event (context->pad, tag_event);
1340   }
1341
1342   if (G_UNLIKELY (context->tags_changed)) {
1343     GST_DEBUG_OBJECT (context->pad, "Sending tags %p: %"
1344         GST_PTR_FORMAT, context->tags, context->tags);
1345     gst_pad_push_event (context->pad,
1346         gst_event_new_tag (gst_tag_list_copy (context->tags)));
1347     context->tags_changed = FALSE;
1348   }
1349
1350   gst_element_add_pad (GST_ELEMENT (demux), context->pad);
1351   gst_flow_combiner_add_pad (demux->flowcombiner, context->pad);
1352
1353   g_free (padname);
1354
1355   /* tadaah! */
1356   return ret;
1357 }
1358
1359 static gboolean
1360 gst_matroska_demux_query (GstMatroskaDemux * demux, GstPad * pad,
1361     GstQuery * query)
1362 {
1363   gboolean res = FALSE;
1364   GstMatroskaTrackContext *context = NULL;
1365
1366   if (pad) {
1367     context = gst_pad_get_element_private (pad);
1368   }
1369
1370   switch (GST_QUERY_TYPE (query)) {
1371     case GST_QUERY_POSITION:
1372     {
1373       GstFormat format;
1374
1375       gst_query_parse_position (query, &format, NULL);
1376
1377       res = TRUE;
1378       if (format == GST_FORMAT_TIME) {
1379         GST_OBJECT_LOCK (demux);
1380         if (context)
1381           gst_query_set_position (query, GST_FORMAT_TIME,
1382               MAX (context->pos, demux->stream_start_time) -
1383               demux->stream_start_time);
1384         else
1385           gst_query_set_position (query, GST_FORMAT_TIME,
1386               MAX (demux->common.segment.position, demux->stream_start_time) -
1387               demux->stream_start_time);
1388         GST_OBJECT_UNLOCK (demux);
1389       } else if (format == GST_FORMAT_DEFAULT && context
1390           && context->default_duration) {
1391         GST_OBJECT_LOCK (demux);
1392         gst_query_set_position (query, GST_FORMAT_DEFAULT,
1393             context->pos / context->default_duration);
1394         GST_OBJECT_UNLOCK (demux);
1395       } else {
1396         GST_DEBUG_OBJECT (demux,
1397             "only position query in TIME and DEFAULT format is supported");
1398         res = FALSE;
1399       }
1400
1401       break;
1402     }
1403     case GST_QUERY_DURATION:
1404     {
1405       GstFormat format;
1406
1407       gst_query_parse_duration (query, &format, NULL);
1408
1409       res = TRUE;
1410       if (format == GST_FORMAT_TIME) {
1411         GST_OBJECT_LOCK (demux);
1412         gst_query_set_duration (query, GST_FORMAT_TIME,
1413             demux->common.segment.duration);
1414         GST_OBJECT_UNLOCK (demux);
1415       } else if (format == GST_FORMAT_DEFAULT && context
1416           && context->default_duration) {
1417         GST_OBJECT_LOCK (demux);
1418         gst_query_set_duration (query, GST_FORMAT_DEFAULT,
1419             demux->common.segment.duration / context->default_duration);
1420         GST_OBJECT_UNLOCK (demux);
1421       } else {
1422         GST_DEBUG_OBJECT (demux,
1423             "only duration query in TIME and DEFAULT format is supported");
1424         res = FALSE;
1425       }
1426       break;
1427     }
1428
1429     case GST_QUERY_SEEKING:
1430     {
1431       GstFormat fmt;
1432
1433       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
1434       GST_OBJECT_LOCK (demux);
1435       if (fmt == GST_FORMAT_TIME) {
1436         gboolean seekable;
1437
1438         if (demux->streaming) {
1439           /* assuming we'll be able to get an index ... */
1440           seekable = demux->seekable;
1441         } else {
1442           seekable = TRUE;
1443         }
1444
1445         gst_query_set_seeking (query, GST_FORMAT_TIME, seekable,
1446             0, demux->common.segment.duration);
1447         res = TRUE;
1448       }
1449       GST_OBJECT_UNLOCK (demux);
1450       break;
1451     }
1452     case GST_QUERY_SEGMENT:
1453     {
1454       GstFormat format;
1455       gint64 start, stop;
1456
1457       format = demux->common.segment.format;
1458
1459       start =
1460           gst_segment_to_stream_time (&demux->common.segment, format,
1461           demux->common.segment.start);
1462       if ((stop = demux->common.segment.stop) == -1)
1463         stop = demux->common.segment.duration;
1464       else
1465         stop =
1466             gst_segment_to_stream_time (&demux->common.segment, format, stop);
1467
1468       gst_query_set_segment (query, demux->common.segment.rate, format, start,
1469           stop);
1470       res = TRUE;
1471       break;
1472     }
1473     default:
1474       if (pad)
1475         res = gst_pad_query_default (pad, (GstObject *) demux, query);
1476       else
1477         res =
1478             GST_ELEMENT_CLASS (parent_class)->query (GST_ELEMENT_CAST (demux),
1479             query);
1480       break;
1481   }
1482
1483   return res;
1484 }
1485
1486 static gboolean
1487 gst_matroska_demux_element_query (GstElement * element, GstQuery * query)
1488 {
1489   return gst_matroska_demux_query (GST_MATROSKA_DEMUX (element), NULL, query);
1490 }
1491
1492 static gboolean
1493 gst_matroska_demux_handle_src_query (GstPad * pad, GstObject * parent,
1494     GstQuery * query)
1495 {
1496   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
1497
1498   return gst_matroska_demux_query (demux, pad, query);
1499 }
1500
1501 /* returns FALSE if there are no pads to deliver event to,
1502  * otherwise TRUE (whatever the outcome of event sending),
1503  * takes ownership of the passed event! */
1504 static gboolean
1505 gst_matroska_demux_send_event (GstMatroskaDemux * demux, GstEvent * event)
1506 {
1507   gboolean ret = FALSE;
1508   gint i;
1509
1510   g_return_val_if_fail (event != NULL, FALSE);
1511
1512   GST_DEBUG_OBJECT (demux, "Sending event of type %s to all source pads",
1513       GST_EVENT_TYPE_NAME (event));
1514
1515   g_assert (demux->common.src->len == demux->common.num_streams);
1516   for (i = 0; i < demux->common.src->len; i++) {
1517     GstMatroskaTrackContext *stream;
1518
1519     stream = g_ptr_array_index (demux->common.src, i);
1520     gst_event_ref (event);
1521     gst_pad_push_event (stream->pad, event);
1522     ret = TRUE;
1523   }
1524
1525   gst_event_unref (event);
1526   return ret;
1527 }
1528
1529 static void
1530 gst_matroska_demux_send_tags (GstMatroskaDemux * demux)
1531 {
1532   gint i;
1533
1534   if (G_UNLIKELY (demux->common.global_tags_changed)) {
1535     GstEvent *tag_event;
1536     gst_tag_list_add (demux->common.global_tags, GST_TAG_MERGE_REPLACE,
1537         GST_TAG_CONTAINER_FORMAT, "Matroska", NULL);
1538     GST_DEBUG_OBJECT (demux, "Sending global_tags %p : %" GST_PTR_FORMAT,
1539         demux->common.global_tags, demux->common.global_tags);
1540
1541     tag_event =
1542         gst_event_new_tag (gst_tag_list_copy (demux->common.global_tags));
1543
1544     for (i = 0; i < demux->common.src->len; i++) {
1545       GstMatroskaTrackContext *stream;
1546
1547       stream = g_ptr_array_index (demux->common.src, i);
1548       gst_pad_push_event (stream->pad, gst_event_ref (tag_event));
1549     }
1550
1551     gst_event_unref (tag_event);
1552     demux->common.global_tags_changed = FALSE;
1553   }
1554
1555   g_assert (demux->common.src->len == demux->common.num_streams);
1556   for (i = 0; i < demux->common.src->len; i++) {
1557     GstMatroskaTrackContext *stream;
1558
1559     stream = g_ptr_array_index (demux->common.src, i);
1560
1561     if (G_UNLIKELY (stream->tags_changed)) {
1562       GST_DEBUG_OBJECT (demux, "Sending tags %p for pad %s:%s : %"
1563           GST_PTR_FORMAT, stream->tags,
1564           GST_DEBUG_PAD_NAME (stream->pad), stream->tags);
1565       gst_pad_push_event (stream->pad,
1566           gst_event_new_tag (gst_tag_list_copy (stream->tags)));
1567       stream->tags_changed = FALSE;
1568     }
1569   }
1570 }
1571
1572 static gboolean
1573 gst_matroska_demux_element_send_event (GstElement * element, GstEvent * event)
1574 {
1575   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
1576   gboolean res;
1577
1578   g_return_val_if_fail (event != NULL, FALSE);
1579
1580   if (GST_EVENT_TYPE (event) == GST_EVENT_SEEK) {
1581     /* no seeking until we are (safely) ready */
1582     if (demux->common.state != GST_MATROSKA_READ_STATE_DATA) {
1583       GST_DEBUG_OBJECT (demux, "not ready for seeking yet");
1584       gst_event_unref (event);
1585       return FALSE;
1586     }
1587     res = gst_matroska_demux_handle_seek_event (demux, NULL, event);
1588   } else {
1589     GST_WARNING_OBJECT (demux, "Unhandled event of type %s",
1590         GST_EVENT_TYPE_NAME (event));
1591     res = FALSE;
1592   }
1593   gst_event_unref (event);
1594   return res;
1595 }
1596
1597 static gboolean
1598 gst_matroska_demux_move_to_entry (GstMatroskaDemux * demux,
1599     GstMatroskaIndex * entry, gboolean reset, gboolean update)
1600 {
1601   gint i;
1602
1603   GST_OBJECT_LOCK (demux);
1604
1605   if (update) {
1606     /* seek (relative to matroska segment) */
1607     /* position might be invalid; will error when streaming resumes ... */
1608     demux->common.offset = entry->pos + demux->common.ebml_segment_start;
1609     demux->next_cluster_offset = 0;
1610
1611     GST_DEBUG_OBJECT (demux,
1612         "Seeked to offset %" G_GUINT64_FORMAT ", block %d, " "time %"
1613         GST_TIME_FORMAT, entry->pos + demux->common.ebml_segment_start,
1614         entry->block, GST_TIME_ARGS (entry->time));
1615
1616     /* update the time */
1617     gst_matroska_read_common_reset_streams (&demux->common, entry->time, TRUE);
1618     gst_flow_combiner_reset (demux->flowcombiner);
1619     demux->common.segment.position = entry->time;
1620     demux->seek_block = entry->block;
1621     demux->seek_first = TRUE;
1622     demux->last_stop_end = GST_CLOCK_TIME_NONE;
1623   }
1624
1625   for (i = 0; i < demux->common.src->len; i++) {
1626     GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i);
1627
1628     if (reset) {
1629       stream->to_offset = G_MAXINT64;
1630     } else {
1631       if (stream->from_offset != -1)
1632         stream->to_offset = stream->from_offset;
1633     }
1634     stream->from_offset = -1;
1635     stream->from_time = GST_CLOCK_TIME_NONE;
1636   }
1637
1638   GST_OBJECT_UNLOCK (demux);
1639
1640   return TRUE;
1641 }
1642
1643 static gint
1644 gst_matroska_cluster_compare (gint64 * i1, gint64 * i2)
1645 {
1646   if (*i1 < *i2)
1647     return -1;
1648   else if (*i1 > *i2)
1649     return 1;
1650   else
1651     return 0;
1652 }
1653
1654 /* searches for a cluster start from @pos,
1655  * return GST_FLOW_OK and cluster position in @pos if found */
1656 static GstFlowReturn
1657 gst_matroska_demux_search_cluster (GstMatroskaDemux * demux, gint64 * pos)
1658 {
1659   gint64 newpos = *pos;
1660   gint64 orig_offset;
1661   GstFlowReturn ret = GST_FLOW_OK;
1662   const guint chunk = 64 * 1024;
1663   GstBuffer *buf = NULL;
1664   GstMapInfo map;
1665   gpointer data = NULL;
1666   gsize size;
1667   guint64 length;
1668   guint32 id;
1669   guint needed;
1670   gint64 oldpos, oldlength;
1671
1672   orig_offset = demux->common.offset;
1673
1674   GST_LOG_OBJECT (demux, "searching cluster following offset %" G_GINT64_FORMAT,
1675       *pos);
1676
1677   if (demux->clusters) {
1678     gint64 *cpos;
1679
1680     cpos = gst_util_array_binary_search (demux->clusters->data,
1681         demux->clusters->len, sizeof (gint64),
1682         (GCompareDataFunc) gst_matroska_cluster_compare,
1683         GST_SEARCH_MODE_AFTER, pos, NULL);
1684     /* sanity check */
1685     if (cpos) {
1686       GST_DEBUG_OBJECT (demux,
1687           "cluster reported at offset %" G_GINT64_FORMAT, *cpos);
1688       demux->common.offset = *cpos;
1689       ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1690           GST_ELEMENT_CAST (demux), &id, &length, &needed);
1691       if (ret == GST_FLOW_OK && id == GST_MATROSKA_ID_CLUSTER) {
1692         newpos = *cpos;
1693         goto exit;
1694       }
1695     }
1696   }
1697
1698   /* read in at newpos and scan for ebml cluster id */
1699   oldpos = oldlength = -1;
1700   while (1) {
1701     GstByteReader reader;
1702     gint cluster_pos;
1703
1704     if (buf != NULL) {
1705       gst_buffer_unmap (buf, &map);
1706       gst_buffer_unref (buf);
1707       buf = NULL;
1708     }
1709     ret = gst_pad_pull_range (demux->common.sinkpad, newpos, chunk, &buf);
1710     if (ret != GST_FLOW_OK)
1711       break;
1712     GST_DEBUG_OBJECT (demux,
1713         "read buffer size %" G_GSIZE_FORMAT " at offset %" G_GINT64_FORMAT,
1714         gst_buffer_get_size (buf), newpos);
1715     gst_buffer_map (buf, &map, GST_MAP_READ);
1716     data = map.data;
1717     size = map.size;
1718     if (oldpos == newpos && oldlength == map.size) {
1719       GST_ERROR_OBJECT (demux, "Stuck at same position");
1720       ret = GST_FLOW_ERROR;
1721       goto exit;
1722     } else {
1723       oldpos = newpos;
1724       oldlength = map.size;
1725     }
1726
1727     gst_byte_reader_init (&reader, data, size);
1728   resume:
1729     cluster_pos = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff,
1730         GST_MATROSKA_ID_CLUSTER, 0, gst_byte_reader_get_remaining (&reader));
1731     if (cluster_pos >= 0) {
1732       newpos += cluster_pos;
1733       /* prepare resuming at next byte */
1734       if (!gst_byte_reader_skip (&reader, cluster_pos + 1)) {
1735         GST_DEBUG_OBJECT (demux, "Need more data -> continue");
1736         continue;
1737       }
1738       GST_DEBUG_OBJECT (demux,
1739           "found cluster ebml id at offset %" G_GINT64_FORMAT, newpos);
1740       /* extra checks whether we really sync'ed to a cluster:
1741        * - either it is the first and only cluster
1742        * - either there is a cluster after this one
1743        * - either cluster length is undefined
1744        */
1745       /* ok if first cluster (there may not a subsequent one) */
1746       if (newpos == demux->first_cluster_offset) {
1747         GST_DEBUG_OBJECT (demux, "cluster is first cluster -> OK");
1748         break;
1749       }
1750       demux->common.offset = newpos;
1751       ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1752           GST_ELEMENT_CAST (demux), &id, &length, &needed);
1753       if (ret != GST_FLOW_OK) {
1754         GST_DEBUG_OBJECT (demux, "need more data -> continue");
1755         continue;
1756       }
1757       g_assert (id == GST_MATROSKA_ID_CLUSTER);
1758       GST_DEBUG_OBJECT (demux, "cluster size %" G_GUINT64_FORMAT ", prefix %d",
1759           length, needed);
1760       /* ok if undefined length or first cluster */
1761       if (length == GST_EBML_SIZE_UNKNOWN || length == G_MAXUINT64) {
1762         GST_DEBUG_OBJECT (demux, "cluster has undefined length -> OK");
1763         break;
1764       }
1765       /* skip cluster */
1766       demux->common.offset += length + needed;
1767       ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1768           GST_ELEMENT_CAST (demux), &id, &length, &needed);
1769       if (ret != GST_FLOW_OK) {
1770         /* we skipped one byte in the reader above, need to accomodate for
1771          * that when resuming skipping from the reader instead of reading a
1772          * new chunk */
1773         newpos += 1;
1774         goto resume;
1775       }
1776       GST_DEBUG_OBJECT (demux, "next element is %scluster",
1777           id == GST_MATROSKA_ID_CLUSTER ? "" : "not ");
1778       if (id == GST_MATROSKA_ID_CLUSTER)
1779         break;
1780       /* not ok, resume
1781        * we skipped one byte in the reader above, need to accomodate for
1782        * that when resuming skipping from the reader instead of reading a
1783        * new chunk */
1784       newpos += 1;
1785       goto resume;
1786     } else {
1787       /* partial cluster id may have been in tail of buffer */
1788       newpos += MAX (gst_byte_reader_get_remaining (&reader), 4) - 3;
1789     }
1790   }
1791
1792   if (buf) {
1793     gst_buffer_unmap (buf, &map);
1794     gst_buffer_unref (buf);
1795     buf = NULL;
1796   }
1797
1798 exit:
1799   demux->common.offset = orig_offset;
1800   *pos = newpos;
1801   return ret;
1802 }
1803
1804 /* bisect and scan through file for cluster starting before @time,
1805  * returns fake index entry with corresponding info on cluster */
1806 static GstMatroskaIndex *
1807 gst_matroska_demux_search_pos (GstMatroskaDemux * demux, GstClockTime time)
1808 {
1809   GstMatroskaIndex *entry = NULL;
1810   GstMatroskaReadState current_state;
1811   GstClockTime otime, prev_cluster_time, current_cluster_time, cluster_time;
1812   gint64 opos, newpos, startpos = 0, current_offset;
1813   gint64 prev_cluster_offset = -1, current_cluster_offset, cluster_offset;
1814   const guint chunk = 64 * 1024;
1815   GstFlowReturn ret;
1816   guint64 length;
1817   guint32 id;
1818   guint needed;
1819
1820   /* (under)estimate new position, resync using cluster ebml id,
1821    * and scan forward to appropriate cluster
1822    * (and re-estimate if need to go backward) */
1823
1824   prev_cluster_time = GST_CLOCK_TIME_NONE;
1825
1826   /* store some current state */
1827   current_state = demux->common.state;
1828   g_return_val_if_fail (current_state == GST_MATROSKA_READ_STATE_DATA, NULL);
1829
1830   current_cluster_offset = demux->cluster_offset;
1831   current_cluster_time = demux->cluster_time;
1832   current_offset = demux->common.offset;
1833
1834   demux->common.state = GST_MATROSKA_READ_STATE_SCANNING;
1835
1836   /* estimate using start and current position */
1837   GST_OBJECT_LOCK (demux);
1838   opos = demux->common.offset - demux->common.ebml_segment_start;
1839   otime = demux->common.segment.position;
1840   GST_OBJECT_UNLOCK (demux);
1841
1842   /* sanitize */
1843   time = MAX (time, demux->stream_start_time);
1844
1845   /* avoid division by zero in first estimation below */
1846   if (otime <= demux->stream_start_time)
1847     otime = time;
1848
1849 retry:
1850   GST_LOG_OBJECT (demux,
1851       "opos: %" G_GUINT64_FORMAT ", otime: %" GST_TIME_FORMAT ", %"
1852       GST_TIME_FORMAT " in stream time (start %" GST_TIME_FORMAT "), time %"
1853       GST_TIME_FORMAT, opos, GST_TIME_ARGS (otime),
1854       GST_TIME_ARGS (otime - demux->stream_start_time),
1855       GST_TIME_ARGS (demux->stream_start_time), GST_TIME_ARGS (time));
1856
1857   if (otime <= demux->stream_start_time) {
1858     newpos = 0;
1859   } else {
1860     newpos =
1861         gst_util_uint64_scale (opos - demux->common.ebml_segment_start,
1862         time - demux->stream_start_time,
1863         otime - demux->stream_start_time) - chunk;
1864     if (newpos < 0)
1865       newpos = 0;
1866   }
1867   /* favour undershoot */
1868   newpos = newpos * 90 / 100;
1869   newpos += demux->common.ebml_segment_start;
1870
1871   GST_DEBUG_OBJECT (demux,
1872       "estimated offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
1873       GST_TIME_ARGS (time), newpos);
1874
1875   /* and at least start scanning before previous scan start to avoid looping */
1876   startpos = startpos * 90 / 100;
1877   if (startpos && startpos < newpos)
1878     newpos = startpos;
1879
1880   /* read in at newpos and scan for ebml cluster id */
1881   startpos = newpos;
1882   while (1) {
1883
1884     ret = gst_matroska_demux_search_cluster (demux, &newpos);
1885     if (ret == GST_FLOW_EOS) {
1886       /* heuristic HACK */
1887       newpos = startpos * 80 / 100;
1888       GST_DEBUG_OBJECT (demux, "EOS; "
1889           "new estimated offset for %" GST_TIME_FORMAT ": %" G_GINT64_FORMAT,
1890           GST_TIME_ARGS (time), newpos);
1891       startpos = newpos;
1892       continue;
1893     } else if (ret != GST_FLOW_OK) {
1894       goto exit;
1895     } else {
1896       break;
1897     }
1898   }
1899
1900   /* then start scanning and parsing for cluster time,
1901    * re-estimate if overshoot, otherwise next cluster and so on */
1902   demux->common.offset = newpos;
1903   demux->cluster_time = cluster_time = GST_CLOCK_TIME_NONE;
1904   while (1) {
1905     guint64 cluster_size = 0;
1906
1907     /* peek and parse some elements */
1908     ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
1909         GST_ELEMENT_CAST (demux), &id, &length, &needed);
1910     if (ret != GST_FLOW_OK)
1911       goto error;
1912     GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
1913         "size %" G_GUINT64_FORMAT ", needed %d", demux->common.offset, id,
1914         length, needed);
1915     ret = gst_matroska_demux_parse_id (demux, id, length, needed);
1916     if (ret != GST_FLOW_OK)
1917       goto error;
1918
1919     if (id == GST_MATROSKA_ID_CLUSTER) {
1920       cluster_time = GST_CLOCK_TIME_NONE;
1921       if (length == G_MAXUINT64)
1922         cluster_size = 0;
1923       else
1924         cluster_size = length + needed;
1925     }
1926     if (demux->cluster_time != GST_CLOCK_TIME_NONE &&
1927         cluster_time == GST_CLOCK_TIME_NONE) {
1928       cluster_time = demux->cluster_time * demux->common.time_scale;
1929       cluster_offset = demux->cluster_offset;
1930       GST_DEBUG_OBJECT (demux, "found cluster at offset %" G_GINT64_FORMAT
1931           " with time %" GST_TIME_FORMAT, cluster_offset,
1932           GST_TIME_ARGS (cluster_time));
1933       if (cluster_time > time) {
1934         GST_DEBUG_OBJECT (demux, "overshot target");
1935         /* cluster overshoots */
1936         if (cluster_offset == demux->first_cluster_offset) {
1937           /* but no prev one */
1938           GST_DEBUG_OBJECT (demux, "but using first cluster anyway");
1939           prev_cluster_time = cluster_time;
1940           prev_cluster_offset = cluster_offset;
1941           break;
1942         }
1943         if (prev_cluster_time != GST_CLOCK_TIME_NONE) {
1944           /* prev cluster did not overshoot, so prev cluster is target */
1945           break;
1946         } else {
1947           /* re-estimate using this new position info */
1948           opos = cluster_offset;
1949           otime = cluster_time;
1950           goto retry;
1951         }
1952       } else {
1953         /* cluster undershoots, goto next one */
1954         prev_cluster_time = cluster_time;
1955         prev_cluster_offset = cluster_offset;
1956         /* skip cluster if length is defined,
1957          * otherwise will be skippingly parsed into */
1958         if (cluster_size) {
1959           GST_DEBUG_OBJECT (demux, "skipping to next cluster");
1960           demux->common.offset = cluster_offset + cluster_size;
1961           demux->cluster_time = GST_CLOCK_TIME_NONE;
1962         } else {
1963           GST_DEBUG_OBJECT (demux, "parsing/skipping cluster elements");
1964         }
1965       }
1966     }
1967     continue;
1968
1969   error:
1970     if (ret == GST_FLOW_EOS) {
1971       if (prev_cluster_time != GST_CLOCK_TIME_NONE)
1972         break;
1973     }
1974     goto exit;
1975   }
1976
1977   entry = g_new0 (GstMatroskaIndex, 1);
1978   entry->time = prev_cluster_time;
1979   entry->pos = prev_cluster_offset - demux->common.ebml_segment_start;
1980   GST_DEBUG_OBJECT (demux, "simulated index entry; time %" GST_TIME_FORMAT
1981       ", pos %" G_GUINT64_FORMAT, GST_TIME_ARGS (entry->time), entry->pos);
1982
1983 exit:
1984
1985   /* restore some state */
1986   demux->cluster_offset = current_cluster_offset;
1987   demux->cluster_time = current_cluster_time;
1988   demux->common.offset = current_offset;
1989   demux->common.state = current_state;
1990
1991   return entry;
1992 }
1993
1994 static gboolean
1995 gst_matroska_demux_handle_seek_event (GstMatroskaDemux * demux,
1996     GstPad * pad, GstEvent * event)
1997 {
1998   GstMatroskaIndex *entry = NULL;
1999   GstMatroskaIndex scan_entry;
2000   GstSeekFlags flags;
2001   GstSeekType cur_type, stop_type;
2002   GstFormat format;
2003   gboolean flush, keyunit, before, after, snap_next;
2004   gdouble rate;
2005   gint64 cur, stop;
2006   GstMatroskaTrackContext *track = NULL;
2007   GstSegment seeksegment = { 0, };
2008   gboolean update = TRUE;
2009   gboolean pad_locked = FALSE;
2010   guint32 seqnum;
2011   GstSearchMode snap_dir;
2012
2013   g_return_val_if_fail (event != NULL, FALSE);
2014
2015   if (pad)
2016     track = gst_pad_get_element_private (pad);
2017
2018   GST_DEBUG_OBJECT (demux, "Have seek %" GST_PTR_FORMAT, event);
2019
2020   gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
2021       &stop_type, &stop);
2022   seqnum = gst_event_get_seqnum (event);
2023
2024   /* we can only seek on time */
2025   if (format != GST_FORMAT_TIME) {
2026     GST_DEBUG_OBJECT (demux, "Can only seek on TIME");
2027     return FALSE;
2028   }
2029
2030   /* copy segment, we need this because we still need the old
2031    * segment when we close the current segment. */
2032   memcpy (&seeksegment, &demux->common.segment, sizeof (GstSegment));
2033
2034   /* pull mode without index means that the actual duration is not known,
2035    * we might be playing a file that's still being recorded
2036    * so, invalidate our current duration, which is only a moving target,
2037    * and should not be used to clamp anything */
2038   if (!demux->streaming && !demux->common.index && demux->invalid_duration) {
2039     seeksegment.duration = GST_CLOCK_TIME_NONE;
2040   }
2041
2042   GST_DEBUG_OBJECT (demux, "configuring seek");
2043   /* Subtract stream_start_time so we always seek on a segment
2044    * in stream time */
2045   if (GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) {
2046     seeksegment.start -= demux->stream_start_time;
2047     seeksegment.position -= demux->stream_start_time;
2048     if (GST_CLOCK_TIME_IS_VALID (seeksegment.stop))
2049       seeksegment.stop -= demux->stream_start_time;
2050     else
2051       seeksegment.stop = seeksegment.duration;
2052   }
2053
2054   gst_segment_do_seek (&seeksegment, rate, format, flags,
2055       cur_type, cur, stop_type, stop, &update);
2056
2057   /* Restore the clip timestamp offset */
2058   if (GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) {
2059     seeksegment.position += demux->stream_start_time;
2060     seeksegment.start += demux->stream_start_time;
2061     if (!GST_CLOCK_TIME_IS_VALID (seeksegment.stop))
2062       seeksegment.stop = seeksegment.duration;
2063     if (GST_CLOCK_TIME_IS_VALID (seeksegment.stop))
2064       seeksegment.stop += demux->stream_start_time;
2065   }
2066
2067   /* restore segment duration (if any effect),
2068    * would be determined again when parsing, but anyway ... */
2069   seeksegment.duration = demux->common.segment.duration;
2070
2071   flush = ! !(flags & GST_SEEK_FLAG_FLUSH);
2072   keyunit = ! !(flags & GST_SEEK_FLAG_KEY_UNIT);
2073   after = ! !(flags & GST_SEEK_FLAG_SNAP_AFTER);
2074   before = ! !(flags & GST_SEEK_FLAG_SNAP_BEFORE);
2075
2076   /* always do full update if flushing,
2077    * otherwise problems might arise downstream with missing keyframes etc */
2078   update = update || flush;
2079
2080   GST_DEBUG_OBJECT (demux, "New segment %" GST_SEGMENT_FORMAT, &seeksegment);
2081
2082   /* check sanity before we start flushing and all that */
2083   snap_next = after && !before;
2084   if (seeksegment.rate < 0)
2085     snap_dir = snap_next ? GST_SEARCH_MODE_BEFORE : GST_SEARCH_MODE_AFTER;
2086   else
2087     snap_dir = snap_next ? GST_SEARCH_MODE_AFTER : GST_SEARCH_MODE_BEFORE;
2088
2089   GST_OBJECT_LOCK (demux);
2090   track = gst_matroska_read_common_get_seek_track (&demux->common, track);
2091   if ((entry = gst_matroska_read_common_do_index_seek (&demux->common, track,
2092               seeksegment.position, &demux->seek_index, &demux->seek_entry,
2093               snap_dir)) == NULL) {
2094     /* pull mode without index can scan later on */
2095     if (demux->streaming) {
2096       GST_DEBUG_OBJECT (demux, "No matching seek entry in index");
2097       GST_OBJECT_UNLOCK (demux);
2098       return FALSE;
2099     } else if (rate < 0.0) {
2100       /* FIXME: We should build an index during playback or when scanning
2101        * that can be used here. The reverse playback code requires seek_index
2102        * and seek_entry to be set!
2103        */
2104       GST_DEBUG_OBJECT (demux,
2105           "No matching seek entry in index, needed for reverse playback");
2106       GST_OBJECT_UNLOCK (demux);
2107       return FALSE;
2108     }
2109   }
2110   GST_DEBUG_OBJECT (demux, "Seek position looks sane");
2111   GST_OBJECT_UNLOCK (demux);
2112
2113   if (!update) {
2114     /* only have to update some segment,
2115      * but also still have to honour flush and so on */
2116     GST_DEBUG_OBJECT (demux, "... no update");
2117     /* bad goto, bad ... */
2118     goto next;
2119   }
2120
2121   if (demux->streaming)
2122     goto finish;
2123
2124 next:
2125   if (flush) {
2126     GstEvent *flush_event = gst_event_new_flush_start ();
2127     gst_event_set_seqnum (flush_event, seqnum);
2128     GST_DEBUG_OBJECT (demux, "Starting flush");
2129     gst_pad_push_event (demux->common.sinkpad, gst_event_ref (flush_event));
2130     gst_matroska_demux_send_event (demux, flush_event);
2131   } else {
2132     GST_DEBUG_OBJECT (demux, "Non-flushing seek, pausing task");
2133     gst_pad_pause_task (demux->common.sinkpad);
2134   }
2135   /* ouch */
2136   if (!update) {
2137     GST_PAD_STREAM_LOCK (demux->common.sinkpad);
2138     pad_locked = TRUE;
2139     goto exit;
2140   }
2141
2142   /* now grab the stream lock so that streaming cannot continue, for
2143    * non flushing seeks when the element is in PAUSED this could block
2144    * forever. */
2145   GST_DEBUG_OBJECT (demux, "Waiting for streaming to stop");
2146   GST_PAD_STREAM_LOCK (demux->common.sinkpad);
2147   pad_locked = TRUE;
2148
2149   /* pull mode without index can do some scanning */
2150   if (!demux->streaming && !entry) {
2151     GstEvent *flush_event;
2152
2153     /* need to stop flushing upstream as we need it next */
2154     if (flush) {
2155       flush_event = gst_event_new_flush_stop (TRUE);
2156       gst_event_set_seqnum (flush_event, seqnum);
2157       gst_pad_push_event (demux->common.sinkpad, flush_event);
2158     }
2159     entry = gst_matroska_demux_search_pos (demux, seeksegment.position);
2160     /* keep local copy */
2161     if (entry) {
2162       scan_entry = *entry;
2163       g_free (entry);
2164       entry = &scan_entry;
2165     } else {
2166       GST_DEBUG_OBJECT (demux, "Scan failed to find matching position");
2167       if (flush) {
2168         flush_event = gst_event_new_flush_stop (TRUE);
2169         gst_event_set_seqnum (flush_event, seqnum);
2170         gst_matroska_demux_send_event (demux, flush_event);
2171       }
2172       goto seek_error;
2173     }
2174   }
2175
2176 finish:
2177   if (keyunit) {
2178     GST_DEBUG_OBJECT (demux, "seek to key unit, adjusting segment start from %"
2179         GST_TIME_FORMAT " to %" GST_TIME_FORMAT,
2180         GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (entry->time));
2181     seeksegment.start = MAX (entry->time, demux->stream_start_time);
2182     seeksegment.position = seeksegment.start;
2183     seeksegment.time = seeksegment.start - demux->stream_start_time;
2184   }
2185
2186   if (demux->streaming) {
2187     GST_OBJECT_LOCK (demux);
2188     /* track real position we should start at */
2189     GST_DEBUG_OBJECT (demux, "storing segment start");
2190     demux->requested_seek_time = seeksegment.position;
2191     demux->seek_offset = entry->pos + demux->common.ebml_segment_start;
2192     GST_OBJECT_UNLOCK (demux);
2193     /* need to seek to cluster start to pick up cluster time */
2194     /* upstream takes care of flushing and all that
2195      * ... and newsegment event handling takes care of the rest */
2196     return perform_seek_to_offset (demux, rate,
2197         entry->pos + demux->common.ebml_segment_start, seqnum, flags);
2198   }
2199
2200 exit:
2201   if (flush) {
2202     GstEvent *flush_event = gst_event_new_flush_stop (TRUE);
2203     gst_event_set_seqnum (flush_event, seqnum);
2204     GST_DEBUG_OBJECT (demux, "Stopping flush");
2205     gst_pad_push_event (demux->common.sinkpad, gst_event_ref (flush_event));
2206     gst_matroska_demux_send_event (demux, flush_event);
2207   }
2208
2209   GST_OBJECT_LOCK (demux);
2210   /* now update the real segment info */
2211   GST_DEBUG_OBJECT (demux, "Committing new seek segment");
2212   memcpy (&demux->common.segment, &seeksegment, sizeof (GstSegment));
2213   GST_OBJECT_UNLOCK (demux);
2214
2215   /* update some (segment) state */
2216   if (!gst_matroska_demux_move_to_entry (demux, entry, TRUE, update))
2217     goto seek_error;
2218
2219   /* notify start of new segment */
2220   if (demux->common.segment.flags & GST_SEEK_FLAG_SEGMENT) {
2221     GstMessage *msg;
2222
2223     msg = gst_message_new_segment_start (GST_OBJECT (demux),
2224         GST_FORMAT_TIME, demux->common.segment.start);
2225     gst_message_set_seqnum (msg, seqnum);
2226     gst_element_post_message (GST_ELEMENT (demux), msg);
2227   }
2228
2229   GST_OBJECT_LOCK (demux);
2230   if (demux->new_segment)
2231     gst_event_unref (demux->new_segment);
2232
2233   /* On port from 0.10, discarded !update (for segment.update) here, FIXME? */
2234   demux->new_segment = gst_event_new_segment (&demux->common.segment);
2235   gst_event_set_seqnum (demux->new_segment, seqnum);
2236   if (demux->common.segment.rate < 0 && demux->common.segment.stop == -1)
2237     demux->to_time = demux->common.segment.position;
2238   else
2239     demux->to_time = GST_CLOCK_TIME_NONE;
2240   demux->segment_seqnum = seqnum;
2241   GST_OBJECT_UNLOCK (demux);
2242
2243   /* restart our task since it might have been stopped when we did the
2244    * flush. */
2245   gst_pad_start_task (demux->common.sinkpad,
2246       (GstTaskFunction) gst_matroska_demux_loop, demux->common.sinkpad, NULL);
2247
2248   /* streaming can continue now */
2249   if (pad_locked) {
2250     GST_PAD_STREAM_UNLOCK (demux->common.sinkpad);
2251   }
2252
2253   return TRUE;
2254
2255 seek_error:
2256   {
2257     if (pad_locked) {
2258       GST_PAD_STREAM_UNLOCK (demux->common.sinkpad);
2259     }
2260     GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Got a seek error"));
2261     return FALSE;
2262   }
2263 }
2264
2265 /*
2266  * Handle whether we can perform the seek event or if we have to let the chain
2267  * function handle seeks to build the seek indexes first.
2268  */
2269 static gboolean
2270 gst_matroska_demux_handle_seek_push (GstMatroskaDemux * demux, GstPad * pad,
2271     GstEvent * event)
2272 {
2273   GstSeekFlags flags;
2274   GstSeekType cur_type, stop_type;
2275   GstFormat format;
2276   gdouble rate;
2277   gint64 cur, stop;
2278
2279   gst_event_parse_seek (event, &rate, &format, &flags, &cur_type, &cur,
2280       &stop_type, &stop);
2281
2282   /* sanity checks */
2283
2284   /* we can only seek on time */
2285   if (format != GST_FORMAT_TIME) {
2286     GST_DEBUG_OBJECT (demux, "Can only seek on TIME");
2287     return FALSE;
2288   }
2289
2290   if (stop_type != GST_SEEK_TYPE_NONE && stop != GST_CLOCK_TIME_NONE) {
2291     GST_DEBUG_OBJECT (demux, "Seek end-time not supported in streaming mode");
2292     return FALSE;
2293   }
2294
2295   if (!(flags & GST_SEEK_FLAG_FLUSH)) {
2296     GST_DEBUG_OBJECT (demux,
2297         "Non-flushing seek not supported in streaming mode");
2298     return FALSE;
2299   }
2300
2301   if (flags & GST_SEEK_FLAG_SEGMENT) {
2302     GST_DEBUG_OBJECT (demux, "Segment seek not supported in streaming mode");
2303     return FALSE;
2304   }
2305
2306   /* check for having parsed index already */
2307   if (!demux->common.index_parsed) {
2308     gboolean building_index;
2309     guint64 offset = 0;
2310
2311     if (!demux->index_offset) {
2312       GST_DEBUG_OBJECT (demux, "no index (location); no seek in push mode");
2313       return FALSE;
2314     }
2315
2316     GST_OBJECT_LOCK (demux);
2317     /* handle the seek event in the chain function */
2318     demux->common.state = GST_MATROSKA_READ_STATE_SEEK;
2319     /* no more seek can be issued until state reset to _DATA */
2320
2321     /* copy the event */
2322     if (demux->seek_event)
2323       gst_event_unref (demux->seek_event);
2324     demux->seek_event = gst_event_ref (event);
2325
2326     /* set the building_index flag so that only one thread can setup the
2327      * structures for index seeking. */
2328     building_index = demux->building_index;
2329     if (!building_index) {
2330       demux->building_index = TRUE;
2331       offset = demux->index_offset;
2332     }
2333     GST_OBJECT_UNLOCK (demux);
2334
2335     if (!building_index) {
2336       /* seek to the first subindex or legacy index */
2337       GST_INFO_OBJECT (demux, "Seeking to Cues at %" G_GUINT64_FORMAT, offset);
2338       return perform_seek_to_offset (demux, rate, offset,
2339           gst_event_get_seqnum (event), GST_SEEK_FLAG_NONE);
2340     }
2341
2342     /* well, we are handling it already */
2343     return TRUE;
2344   }
2345
2346   /* delegate to tweaked regular seek */
2347   return gst_matroska_demux_handle_seek_event (demux, pad, event);
2348 }
2349
2350 static gboolean
2351 gst_matroska_demux_handle_src_event (GstPad * pad, GstObject * parent,
2352     GstEvent * event)
2353 {
2354   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
2355   gboolean res = TRUE;
2356
2357   switch (GST_EVENT_TYPE (event)) {
2358     case GST_EVENT_SEEK:
2359       /* no seeking until we are (safely) ready */
2360       if (demux->common.state != GST_MATROSKA_READ_STATE_DATA) {
2361         GST_DEBUG_OBJECT (demux, "not ready for seeking yet");
2362         gst_event_unref (event);
2363         return FALSE;
2364       }
2365       if (!demux->streaming)
2366         res = gst_matroska_demux_handle_seek_event (demux, pad, event);
2367       else
2368         res = gst_matroska_demux_handle_seek_push (demux, pad, event);
2369       gst_event_unref (event);
2370       break;
2371
2372     case GST_EVENT_QOS:
2373     {
2374       GstMatroskaTrackContext *context = gst_pad_get_element_private (pad);
2375       if (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
2376         GstMatroskaTrackVideoContext *videocontext =
2377             (GstMatroskaTrackVideoContext *) context;
2378         gdouble proportion;
2379         GstClockTimeDiff diff;
2380         GstClockTime timestamp;
2381
2382         gst_event_parse_qos (event, NULL, &proportion, &diff, &timestamp);
2383
2384         GST_OBJECT_LOCK (demux);
2385         videocontext->earliest_time = timestamp + diff;
2386         GST_OBJECT_UNLOCK (demux);
2387       }
2388       res = TRUE;
2389       gst_event_unref (event);
2390       break;
2391     }
2392
2393     case GST_EVENT_TOC_SELECT:
2394     {
2395       char *uid = NULL;
2396       GstTocEntry *entry = NULL;
2397       GstEvent *seek_event;
2398       gint64 start_pos;
2399
2400       if (!demux->common.toc) {
2401         GST_DEBUG_OBJECT (demux, "no TOC to select");
2402         return FALSE;
2403       } else {
2404         gst_event_parse_toc_select (event, &uid);
2405         if (uid != NULL) {
2406           GST_OBJECT_LOCK (demux);
2407           entry = gst_toc_find_entry (demux->common.toc, uid);
2408           if (entry == NULL) {
2409             GST_OBJECT_UNLOCK (demux);
2410             GST_WARNING_OBJECT (demux, "no TOC entry with given UID: %s", uid);
2411             res = FALSE;
2412           } else {
2413             gst_toc_entry_get_start_stop_times (entry, &start_pos, NULL);
2414             GST_OBJECT_UNLOCK (demux);
2415             seek_event = gst_event_new_seek (1.0,
2416                 GST_FORMAT_TIME,
2417                 GST_SEEK_FLAG_FLUSH,
2418                 GST_SEEK_TYPE_SET, start_pos, GST_SEEK_TYPE_SET, -1);
2419             res = gst_matroska_demux_handle_seek_event (demux, pad, seek_event);
2420             gst_event_unref (seek_event);
2421           }
2422           g_free (uid);
2423         } else {
2424           GST_WARNING_OBJECT (demux, "received empty TOC select event");
2425           res = FALSE;
2426         }
2427       }
2428       gst_event_unref (event);
2429       break;
2430     }
2431
2432       /* events we don't need to handle */
2433     case GST_EVENT_NAVIGATION:
2434       gst_event_unref (event);
2435       res = FALSE;
2436       break;
2437
2438     case GST_EVENT_LATENCY:
2439     default:
2440       res = gst_pad_push_event (demux->common.sinkpad, event);
2441       break;
2442   }
2443
2444   return res;
2445 }
2446
2447 static GstFlowReturn
2448 gst_matroska_demux_seek_to_previous_keyframe (GstMatroskaDemux * demux)
2449 {
2450   GstFlowReturn ret = GST_FLOW_EOS;
2451   gboolean done = TRUE;
2452   gint i;
2453
2454   g_return_val_if_fail (demux->seek_index, GST_FLOW_EOS);
2455   g_return_val_if_fail (demux->seek_entry < demux->seek_index->len,
2456       GST_FLOW_EOS);
2457
2458   GST_DEBUG_OBJECT (demux, "locating previous keyframe");
2459
2460   if (!demux->seek_entry) {
2461     GST_DEBUG_OBJECT (demux, "no earlier index entry");
2462     goto exit;
2463   }
2464
2465   for (i = 0; i < demux->common.src->len; i++) {
2466     GstMatroskaTrackContext *stream = g_ptr_array_index (demux->common.src, i);
2467
2468     GST_DEBUG_OBJECT (demux, "segment start %" GST_TIME_FORMAT
2469         ", stream %d at %" GST_TIME_FORMAT,
2470         GST_TIME_ARGS (demux->common.segment.start), stream->index,
2471         GST_TIME_ARGS (stream->from_time));
2472     if (GST_CLOCK_TIME_IS_VALID (stream->from_time)) {
2473       if (stream->from_time > demux->common.segment.start) {
2474         GST_DEBUG_OBJECT (demux, "stream %d not finished yet", stream->index);
2475         done = FALSE;
2476       }
2477     } else {
2478       /* nothing pushed for this stream;
2479        * likely seek entry did not start at keyframe, so all was skipped.
2480        * So we need an earlier entry */
2481       done = FALSE;
2482     }
2483   }
2484
2485   if (!done) {
2486     GstMatroskaIndex *entry;
2487
2488     entry = &g_array_index (demux->seek_index, GstMatroskaIndex,
2489         --demux->seek_entry);
2490     if (!gst_matroska_demux_move_to_entry (demux, entry, FALSE, TRUE))
2491       goto exit;
2492
2493     ret = GST_FLOW_OK;
2494   }
2495
2496 exit:
2497   return ret;
2498 }
2499
2500 static GstFlowReturn
2501 gst_matroska_demux_parse_tracks (GstMatroskaDemux * demux, GstEbmlRead * ebml)
2502 {
2503   GstFlowReturn ret = GST_FLOW_OK;
2504   guint32 id;
2505
2506   DEBUG_ELEMENT_START (demux, ebml, "Tracks");
2507
2508   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
2509     DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
2510     return ret;
2511   }
2512
2513   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
2514     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
2515       break;
2516
2517     switch (id) {
2518         /* one track within the "all-tracks" header */
2519       case GST_MATROSKA_ID_TRACKENTRY:
2520         ret = gst_matroska_demux_add_stream (demux, ebml);
2521         break;
2522
2523       default:
2524         ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
2525             "Track", id);
2526         break;
2527     }
2528   }
2529   DEBUG_ELEMENT_STOP (demux, ebml, "Tracks", ret);
2530
2531   demux->tracks_parsed = TRUE;
2532
2533   return ret;
2534 }
2535
2536 /*
2537  * Read signed/unsigned "EBML" numbers.
2538  * Return: number of bytes processed.
2539  */
2540
2541 static gint
2542 gst_matroska_ebmlnum_uint (guint8 * data, guint size, guint64 * num)
2543 {
2544   gint len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
2545   guint64 total;
2546
2547   if (size <= 0) {
2548     return -1;
2549   }
2550
2551   total = data[0];
2552   while (read <= 8 && !(total & len_mask)) {
2553     read++;
2554     len_mask >>= 1;
2555   }
2556   if (read > 8)
2557     return -1;
2558
2559   if ((total &= (len_mask - 1)) == len_mask - 1)
2560     num_ffs++;
2561   if (size < read)
2562     return -1;
2563   while (n < read) {
2564     if (data[n] == 0xff)
2565       num_ffs++;
2566     total = (total << 8) | data[n];
2567     n++;
2568   }
2569
2570   if (read == num_ffs && total != 0)
2571     *num = G_MAXUINT64;
2572   else
2573     *num = total;
2574
2575   return read;
2576 }
2577
2578 static gint
2579 gst_matroska_ebmlnum_sint (guint8 * data, guint size, gint64 * num)
2580 {
2581   guint64 unum;
2582   gint res;
2583
2584   /* read as unsigned number first */
2585   if ((res = gst_matroska_ebmlnum_uint (data, size, &unum)) < 0)
2586     return -1;
2587
2588   /* make signed */
2589   if (unum == G_MAXUINT64)
2590     *num = G_MAXINT64;
2591   else
2592     *num = unum - ((1 << ((7 * res) - 1)) - 1);
2593
2594   return res;
2595 }
2596
2597 /*
2598  * Mostly used for subtitles. We add void filler data for each
2599  * lagging stream to make sure we don't deadlock.
2600  */
2601
2602 static void
2603 gst_matroska_demux_sync_streams (GstMatroskaDemux * demux)
2604 {
2605   GstClockTime gap_threshold;
2606   gint stream_nr;
2607
2608   GST_OBJECT_LOCK (demux);
2609
2610   GST_LOG_OBJECT (demux, "Sync to %" GST_TIME_FORMAT,
2611       GST_TIME_ARGS (demux->common.segment.position));
2612
2613   g_assert (demux->common.num_streams == demux->common.src->len);
2614   for (stream_nr = 0; stream_nr < demux->common.src->len; stream_nr++) {
2615     GstMatroskaTrackContext *context;
2616
2617     context = g_ptr_array_index (demux->common.src, stream_nr);
2618
2619     GST_LOG_OBJECT (demux,
2620         "Checking for resync on stream %d (%" GST_TIME_FORMAT ")", stream_nr,
2621         GST_TIME_ARGS (context->pos));
2622
2623     /* Only send gap events on non-subtitle streams if lagging way behind.
2624      * The 0.5 second threshold for subtitle streams is also quite random. */
2625     if (context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE)
2626       gap_threshold = GST_SECOND / 2;
2627     else
2628       gap_threshold = 3 * GST_SECOND;
2629
2630     /* Lag need only be considered if we have advanced into requested segment */
2631     if (GST_CLOCK_TIME_IS_VALID (context->pos) &&
2632         GST_CLOCK_TIME_IS_VALID (demux->common.segment.position) &&
2633         demux->common.segment.position > demux->common.segment.start &&
2634         context->pos + gap_threshold < demux->common.segment.position) {
2635
2636       GstEvent *event;
2637       guint64 start = context->pos;
2638       guint64 stop = demux->common.segment.position - gap_threshold;
2639
2640       GST_DEBUG_OBJECT (demux,
2641           "Synchronizing stream %d with other by advancing time from %"
2642           GST_TIME_FORMAT " to %" GST_TIME_FORMAT, stream_nr,
2643           GST_TIME_ARGS (start), GST_TIME_ARGS (stop));
2644
2645       context->pos = stop;
2646
2647       event = gst_event_new_gap (start, stop - start);
2648       GST_OBJECT_UNLOCK (demux);
2649       gst_pad_push_event (context->pad, event);
2650       GST_OBJECT_LOCK (demux);
2651     }
2652   }
2653
2654   GST_OBJECT_UNLOCK (demux);
2655 }
2656
2657 static GstFlowReturn
2658 gst_matroska_demux_push_stream_headers (GstMatroskaDemux * demux,
2659     GstMatroskaTrackContext * stream)
2660 {
2661   GstFlowReturn ret = GST_FLOW_OK;
2662   gint i, num;
2663
2664   num = gst_buffer_list_length (stream->stream_headers);
2665   for (i = 0; i < num; ++i) {
2666     GstBuffer *buf;
2667
2668     buf = gst_buffer_list_get (stream->stream_headers, i);
2669     buf = gst_buffer_copy (buf);
2670
2671     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER);
2672
2673     if (stream->set_discont) {
2674       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
2675       stream->set_discont = FALSE;
2676     } else {
2677       GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
2678     }
2679
2680     /* push out all headers in one go and use last flow return */
2681     ret = gst_pad_push (stream->pad, buf);
2682   }
2683
2684   /* don't need these any  longer */
2685   gst_buffer_list_unref (stream->stream_headers);
2686   stream->stream_headers = NULL;
2687
2688   /* combine flows */
2689   ret = gst_flow_combiner_update_flow (demux->flowcombiner, ret);
2690
2691   return ret;
2692 }
2693
2694 static void
2695 gst_matroska_demux_push_dvd_clut_change_event (GstMatroskaDemux * demux,
2696     GstMatroskaTrackContext * stream)
2697 {
2698   gchar *buf, *start;
2699
2700   g_assert (!strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_VOBSUB));
2701
2702   if (!stream->codec_priv)
2703     return;
2704
2705   /* ideally, VobSub private data should be parsed and stored more convenient
2706    * elsewhere, but for now, only interested in a small part */
2707
2708   /* make sure we have terminating 0 */
2709   buf = g_strndup (stream->codec_priv, stream->codec_priv_size);
2710
2711   /* just locate and parse palette part */
2712   start = strstr (buf, "palette:");
2713   if (start) {
2714     gint i;
2715     guint32 clut[16];
2716     guint32 col;
2717     guint8 r, g, b, y, u, v;
2718
2719     start += 8;
2720     while (g_ascii_isspace (*start))
2721       start++;
2722     for (i = 0; i < 16; i++) {
2723       if (sscanf (start, "%06x", &col) != 1)
2724         break;
2725       start += 6;
2726       while ((*start == ',') || g_ascii_isspace (*start))
2727         start++;
2728       /* sigh, need to convert this from vobsub pseudo-RGB to YUV */
2729       r = (col >> 16) & 0xff;
2730       g = (col >> 8) & 0xff;
2731       b = col & 0xff;
2732       y = CLAMP ((0.1494 * r + 0.6061 * g + 0.2445 * b) * 219 / 255 + 16, 0,
2733           255);
2734       u = CLAMP (0.6066 * r - 0.4322 * g - 0.1744 * b + 128, 0, 255);
2735       v = CLAMP (-0.08435 * r - 0.3422 * g + 0.4266 * b + 128, 0, 255);
2736       clut[i] = (y << 16) | (u << 8) | v;
2737     }
2738
2739     /* got them all without problems; build and send event */
2740     if (i == 16) {
2741       GstStructure *s;
2742
2743       s = gst_structure_new ("application/x-gst-dvd", "event", G_TYPE_STRING,
2744           "dvd-spu-clut-change", "clut00", G_TYPE_INT, clut[0], "clut01",
2745           G_TYPE_INT, clut[1], "clut02", G_TYPE_INT, clut[2], "clut03",
2746           G_TYPE_INT, clut[3], "clut04", G_TYPE_INT, clut[4], "clut05",
2747           G_TYPE_INT, clut[5], "clut06", G_TYPE_INT, clut[6], "clut07",
2748           G_TYPE_INT, clut[7], "clut08", G_TYPE_INT, clut[8], "clut09",
2749           G_TYPE_INT, clut[9], "clut10", G_TYPE_INT, clut[10], "clut11",
2750           G_TYPE_INT, clut[11], "clut12", G_TYPE_INT, clut[12], "clut13",
2751           G_TYPE_INT, clut[13], "clut14", G_TYPE_INT, clut[14], "clut15",
2752           G_TYPE_INT, clut[15], NULL);
2753
2754       gst_pad_push_event (stream->pad,
2755           gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_STICKY, s));
2756     }
2757   }
2758   g_free (buf);
2759 }
2760
2761 static void
2762 gst_matroska_demux_push_codec_data_all (GstMatroskaDemux * demux)
2763 {
2764   gint stream_nr;
2765
2766   g_assert (demux->common.num_streams == demux->common.src->len);
2767   for (stream_nr = 0; stream_nr < demux->common.src->len; stream_nr++) {
2768     GstMatroskaTrackContext *stream;
2769
2770     stream = g_ptr_array_index (demux->common.src, stream_nr);
2771
2772     if (stream->send_stream_headers) {
2773       if (stream->stream_headers != NULL) {
2774         gst_matroska_demux_push_stream_headers (demux, stream);
2775       } else {
2776         /* FIXME: perhaps we can just disable and skip this stream then */
2777         GST_ELEMENT_ERROR (demux, STREAM, DECODE, (NULL),
2778             ("Failed to extract stream headers from codec private data"));
2779       }
2780       stream->send_stream_headers = FALSE;
2781     }
2782
2783     if (stream->send_dvd_event) {
2784       gst_matroska_demux_push_dvd_clut_change_event (demux, stream);
2785       /* FIXME: should we send this event again after (flushing) seek ? */
2786       stream->send_dvd_event = FALSE;
2787     }
2788   }
2789
2790 }
2791
2792 static GstFlowReturn
2793 gst_matroska_demux_add_mpeg_seq_header (GstElement * element,
2794     GstMatroskaTrackContext * stream, GstBuffer ** buf)
2795 {
2796   guint8 *seq_header;
2797   guint seq_header_len;
2798   guint32 header, tmp;
2799
2800   if (stream->codec_state) {
2801     seq_header = stream->codec_state;
2802     seq_header_len = stream->codec_state_size;
2803   } else if (stream->codec_priv) {
2804     seq_header = stream->codec_priv;
2805     seq_header_len = stream->codec_priv_size;
2806   } else {
2807     return GST_FLOW_OK;
2808   }
2809
2810   /* Sequence header only needed for keyframes */
2811   if (GST_BUFFER_FLAG_IS_SET (*buf, GST_BUFFER_FLAG_DELTA_UNIT))
2812     return GST_FLOW_OK;
2813
2814   if (gst_buffer_get_size (*buf) < 4)
2815     return GST_FLOW_OK;
2816
2817   gst_buffer_extract (*buf, 0, &tmp, sizeof (guint32));
2818   header = GUINT32_FROM_BE (tmp);
2819
2820   /* Sequence start code, if not found prepend */
2821   if (header != 0x000001b3) {
2822     GstBuffer *newbuf;
2823
2824     GST_DEBUG_OBJECT (element, "Prepending MPEG sequence header");
2825
2826     newbuf = gst_buffer_new_wrapped (g_memdup (seq_header, seq_header_len),
2827         seq_header_len);
2828
2829     gst_buffer_copy_into (newbuf, *buf, GST_BUFFER_COPY_TIMESTAMPS |
2830         GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_MEMORY, 0,
2831         gst_buffer_get_size (*buf));
2832
2833     gst_buffer_unref (*buf);
2834     *buf = newbuf;
2835   }
2836
2837   return GST_FLOW_OK;
2838 }
2839
2840 static GstFlowReturn
2841 gst_matroska_demux_add_wvpk_header (GstElement * element,
2842     GstMatroskaTrackContext * stream, GstBuffer ** buf)
2843 {
2844   GstMatroskaTrackAudioContext *audiocontext =
2845       (GstMatroskaTrackAudioContext *) stream;
2846   GstBuffer *newbuf = NULL;
2847   GstMapInfo map, outmap;
2848   guint8 *buf_data, *data;
2849   Wavpack4Header wvh;
2850
2851   wvh.ck_id[0] = 'w';
2852   wvh.ck_id[1] = 'v';
2853   wvh.ck_id[2] = 'p';
2854   wvh.ck_id[3] = 'k';
2855
2856   wvh.version = GST_READ_UINT16_LE (stream->codec_priv);
2857   wvh.track_no = 0;
2858   wvh.index_no = 0;
2859   wvh.total_samples = -1;
2860   wvh.block_index = audiocontext->wvpk_block_index;
2861
2862   if (audiocontext->channels <= 2) {
2863     guint32 block_samples, tmp;
2864     gsize size = gst_buffer_get_size (*buf);
2865
2866     gst_buffer_extract (*buf, 0, &tmp, sizeof (guint32));
2867     block_samples = GUINT32_FROM_LE (tmp);
2868     /* we need to reconstruct the header of the wavpack block */
2869
2870     /* -20 because ck_size is the size of the wavpack block -8
2871      * and lace_size is the size of the wavpack block + 12
2872      * (the three guint32 of the header that already are in the buffer) */
2873     wvh.ck_size = size + sizeof (Wavpack4Header) - 20;
2874
2875     /* block_samples, flags and crc are already in the buffer */
2876     newbuf = gst_buffer_new_allocate (NULL, sizeof (Wavpack4Header) - 12, NULL);
2877
2878     gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
2879     data = outmap.data;
2880     data[0] = 'w';
2881     data[1] = 'v';
2882     data[2] = 'p';
2883     data[3] = 'k';
2884     GST_WRITE_UINT32_LE (data + 4, wvh.ck_size);
2885     GST_WRITE_UINT16_LE (data + 8, wvh.version);
2886     GST_WRITE_UINT8 (data + 10, wvh.track_no);
2887     GST_WRITE_UINT8 (data + 11, wvh.index_no);
2888     GST_WRITE_UINT32_LE (data + 12, wvh.total_samples);
2889     GST_WRITE_UINT32_LE (data + 16, wvh.block_index);
2890     gst_buffer_unmap (newbuf, &outmap);
2891
2892     /* Append data from buf: */
2893     gst_buffer_copy_into (newbuf, *buf, GST_BUFFER_COPY_TIMESTAMPS |
2894         GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_MEMORY, 0, size);
2895
2896     gst_buffer_unref (*buf);
2897     *buf = newbuf;
2898     audiocontext->wvpk_block_index += block_samples;
2899   } else {
2900     guint8 *outdata = NULL;
2901     guint outpos = 0;
2902     gsize buf_size, size, out_size = 0;
2903     guint32 block_samples, flags, crc, blocksize;
2904
2905     gst_buffer_map (*buf, &map, GST_MAP_READ);
2906     buf_data = map.data;
2907     buf_size = map.size;
2908
2909     if (buf_size < 4) {
2910       GST_ERROR_OBJECT (element, "Too small wavpack buffer");
2911       gst_buffer_unmap (*buf, &map);
2912       return GST_FLOW_ERROR;
2913     }
2914
2915     data = buf_data;
2916     size = buf_size;
2917
2918     block_samples = GST_READ_UINT32_LE (data);
2919     data += 4;
2920     size -= 4;
2921
2922     while (size > 12) {
2923       flags = GST_READ_UINT32_LE (data);
2924       data += 4;
2925       size -= 4;
2926       crc = GST_READ_UINT32_LE (data);
2927       data += 4;
2928       size -= 4;
2929       blocksize = GST_READ_UINT32_LE (data);
2930       data += 4;
2931       size -= 4;
2932
2933       if (blocksize == 0 || size < blocksize)
2934         break;
2935
2936       g_assert ((newbuf == NULL) == (outdata == NULL));
2937
2938       if (newbuf == NULL) {
2939         out_size = sizeof (Wavpack4Header) + blocksize;
2940         newbuf = gst_buffer_new_allocate (NULL, out_size, NULL);
2941
2942         gst_buffer_copy_into (newbuf, *buf,
2943             GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS, 0, -1);
2944
2945         outpos = 0;
2946         gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
2947         outdata = outmap.data;
2948       } else {
2949         gst_buffer_unmap (newbuf, &outmap);
2950         out_size += sizeof (Wavpack4Header) + blocksize;
2951         gst_buffer_set_size (newbuf, out_size);
2952         gst_buffer_map (newbuf, &outmap, GST_MAP_WRITE);
2953         outdata = outmap.data;
2954       }
2955
2956       outdata[outpos] = 'w';
2957       outdata[outpos + 1] = 'v';
2958       outdata[outpos + 2] = 'p';
2959       outdata[outpos + 3] = 'k';
2960       outpos += 4;
2961
2962       GST_WRITE_UINT32_LE (outdata + outpos,
2963           blocksize + sizeof (Wavpack4Header) - 8);
2964       GST_WRITE_UINT16_LE (outdata + outpos + 4, wvh.version);
2965       GST_WRITE_UINT8 (outdata + outpos + 6, wvh.track_no);
2966       GST_WRITE_UINT8 (outdata + outpos + 7, wvh.index_no);
2967       GST_WRITE_UINT32_LE (outdata + outpos + 8, wvh.total_samples);
2968       GST_WRITE_UINT32_LE (outdata + outpos + 12, wvh.block_index);
2969       GST_WRITE_UINT32_LE (outdata + outpos + 16, block_samples);
2970       GST_WRITE_UINT32_LE (outdata + outpos + 20, flags);
2971       GST_WRITE_UINT32_LE (outdata + outpos + 24, crc);
2972       outpos += 28;
2973
2974       memmove (outdata + outpos, data, blocksize);
2975       outpos += blocksize;
2976       data += blocksize;
2977       size -= blocksize;
2978     }
2979     gst_buffer_unmap (*buf, &map);
2980     gst_buffer_unref (*buf);
2981
2982     if (newbuf)
2983       gst_buffer_unmap (newbuf, &outmap);
2984
2985     *buf = newbuf;
2986     audiocontext->wvpk_block_index += block_samples;
2987   }
2988
2989   return GST_FLOW_OK;
2990 }
2991
2992 static GstFlowReturn
2993 gst_matroska_demux_add_prores_header (GstElement * element,
2994     GstMatroskaTrackContext * stream, GstBuffer ** buf)
2995 {
2996   GstBuffer *newbuf = gst_buffer_new_allocate (NULL, 8, NULL);
2997   GstMapInfo map;
2998   guint32 frame_size;
2999
3000   if (!gst_buffer_map (newbuf, &map, GST_MAP_WRITE)) {
3001     GST_ERROR ("Failed to map newly allocated buffer");
3002     return GST_FLOW_ERROR;
3003   }
3004
3005   frame_size = gst_buffer_get_size (*buf);
3006
3007   GST_WRITE_UINT32_BE (map.data, frame_size);
3008   map.data[4] = 'i';
3009   map.data[5] = 'c';
3010   map.data[6] = 'p';
3011   map.data[7] = 'f';
3012
3013   gst_buffer_unmap (newbuf, &map);
3014   *buf = gst_buffer_append (newbuf, *buf);
3015
3016   return GST_FLOW_OK;
3017 }
3018
3019 /* @text must be null-terminated */
3020 static gboolean
3021 gst_matroska_demux_subtitle_chunk_has_tag (GstElement * element,
3022     const gchar * text)
3023 {
3024   gchar *tag;
3025
3026   g_return_val_if_fail (text != NULL, FALSE);
3027
3028   /* yes, this might all lead to false positives ... */
3029   tag = (gchar *) text;
3030   while ((tag = strchr (tag, '<'))) {
3031     tag++;
3032     if (*tag != '\0' && *(tag + 1) == '>') {
3033       /* some common convenience ones */
3034       /* maybe any character will do here ? */
3035       switch (*tag) {
3036         case 'b':
3037         case 'i':
3038         case 'u':
3039         case 's':
3040           return TRUE;
3041         default:
3042           return FALSE;
3043       }
3044     }
3045   }
3046
3047   if (strstr (text, "<span"))
3048     return TRUE;
3049
3050   return FALSE;
3051 }
3052
3053 static GstFlowReturn
3054 gst_matroska_demux_check_subtitle_buffer (GstElement * element,
3055     GstMatroskaTrackContext * stream, GstBuffer ** buf)
3056 {
3057   GstMatroskaTrackSubtitleContext *sub_stream;
3058   const gchar *encoding;
3059   GError *err = NULL;
3060   GstBuffer *newbuf;
3061   gchar *utf8;
3062   GstMapInfo map;
3063   gboolean needs_unmap = TRUE;
3064
3065   sub_stream = (GstMatroskaTrackSubtitleContext *) stream;
3066
3067   if (!gst_buffer_get_size (*buf) || !gst_buffer_map (*buf, &map, GST_MAP_READ))
3068     return GST_FLOW_OK;
3069
3070   /* The subtitle buffer we push out should not include a NUL terminator as
3071    * part of the data. */
3072   if (map.data[map.size - 1] == '\0') {
3073     gst_buffer_set_size (*buf, map.size - 1);
3074     gst_buffer_unmap (*buf, &map);
3075     gst_buffer_map (*buf, &map, GST_MAP_READ);
3076   }
3077
3078   if (!sub_stream->invalid_utf8) {
3079     if (g_utf8_validate ((gchar *) map.data, map.size, NULL)) {
3080       goto next;
3081     }
3082     GST_WARNING_OBJECT (element, "subtitle stream %" G_GUINT64_FORMAT
3083         " is not valid UTF-8, this is broken according to the matroska"
3084         " specification", stream->num);
3085     sub_stream->invalid_utf8 = TRUE;
3086   }
3087
3088   /* file with broken non-UTF8 subtitle, do the best we can do to fix it */
3089   encoding = g_getenv ("GST_SUBTITLE_ENCODING");
3090   if (encoding == NULL || *encoding == '\0') {
3091     /* if local encoding is UTF-8 and no encoding specified
3092      * via the environment variable, assume ISO-8859-15 */
3093     if (g_get_charset (&encoding)) {
3094       encoding = "ISO-8859-15";
3095     }
3096   }
3097
3098   utf8 =
3099       g_convert_with_fallback ((gchar *) map.data, map.size, "UTF-8", encoding,
3100       (char *) "*", NULL, NULL, &err);
3101
3102   if (err) {
3103     GST_LOG_OBJECT (element, "could not convert string from '%s' to UTF-8: %s",
3104         encoding, err->message);
3105     g_error_free (err);
3106     g_free (utf8);
3107
3108     /* invalid input encoding, fall back to ISO-8859-15 (always succeeds) */
3109     encoding = "ISO-8859-15";
3110     utf8 =
3111         g_convert_with_fallback ((gchar *) map.data, map.size, "UTF-8",
3112         encoding, (char *) "*", NULL, NULL, NULL);
3113   }
3114
3115   GST_LOG_OBJECT (element, "converted subtitle text from %s to UTF-8 %s",
3116       encoding, (err) ? "(using ISO-8859-15 as fallback)" : "");
3117
3118   if (utf8 == NULL)
3119     utf8 = g_strdup ("invalid subtitle");
3120
3121   newbuf = gst_buffer_new_wrapped (utf8, strlen (utf8));
3122   gst_buffer_unmap (*buf, &map);
3123   gst_buffer_copy_into (newbuf, *buf,
3124       GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_META,
3125       0, -1);
3126   gst_buffer_unref (*buf);
3127
3128   *buf = newbuf;
3129   gst_buffer_map (*buf, &map, GST_MAP_READ);
3130
3131 next:
3132
3133   if (sub_stream->check_markup) {
3134     /* caps claim markup text, so we need to escape text,
3135      * except if text is already markup and then needs no further escaping */
3136     sub_stream->seen_markup_tag = sub_stream->seen_markup_tag ||
3137         gst_matroska_demux_subtitle_chunk_has_tag (element, (gchar *) map.data);
3138
3139     if (!sub_stream->seen_markup_tag) {
3140       utf8 = g_markup_escape_text ((gchar *) map.data, map.size);
3141
3142       newbuf = gst_buffer_new_wrapped (utf8, strlen (utf8));
3143       gst_buffer_unmap (*buf, &map);
3144       gst_buffer_copy_into (newbuf, *buf,
3145           GST_BUFFER_COPY_TIMESTAMPS | GST_BUFFER_COPY_FLAGS |
3146           GST_BUFFER_COPY_META, 0, -1);
3147       gst_buffer_unref (*buf);
3148
3149       *buf = newbuf;
3150       needs_unmap = FALSE;
3151     }
3152   }
3153
3154   if (needs_unmap)
3155     gst_buffer_unmap (*buf, &map);
3156
3157   return GST_FLOW_OK;
3158 }
3159
3160 static GstFlowReturn
3161 gst_matroska_demux_check_aac (GstElement * element,
3162     GstMatroskaTrackContext * stream, GstBuffer ** buf)
3163 {
3164   guint8 data[2];
3165   guint size;
3166
3167   gst_buffer_extract (*buf, 0, data, 2);
3168   size = gst_buffer_get_size (*buf);
3169
3170   if (size > 2 && data[0] == 0xff && (data[1] >> 4 == 0x0f)) {
3171     GstStructure *s;
3172
3173     /* tss, ADTS data, remove codec_data
3174      * still assume it is at least parsed */
3175     stream->caps = gst_caps_make_writable (stream->caps);
3176     s = gst_caps_get_structure (stream->caps, 0);
3177     g_assert (s);
3178     gst_structure_remove_field (s, "codec_data");
3179     gst_pad_set_caps (stream->pad, stream->caps);
3180     GST_DEBUG_OBJECT (element, "ADTS AAC audio data; removing codec-data, "
3181         "new caps: %" GST_PTR_FORMAT, stream->caps);
3182   }
3183
3184   /* disable subsequent checking */
3185   stream->postprocess_frame = NULL;
3186
3187   return GST_FLOW_OK;
3188 }
3189
3190 static GstBuffer *
3191 gst_matroska_demux_align_buffer (GstMatroskaDemux * demux,
3192     GstBuffer * buffer, gsize alignment)
3193 {
3194   GstMapInfo map;
3195
3196   gst_buffer_map (buffer, &map, GST_MAP_READ);
3197
3198   if (map.size < sizeof (guintptr)) {
3199     gst_buffer_unmap (buffer, &map);
3200     return buffer;
3201   }
3202
3203   if (((guintptr) map.data) & (alignment - 1)) {
3204     GstBuffer *new_buffer;
3205     GstAllocationParams params = { 0, alignment - 1, 0, 0, };
3206
3207     new_buffer = gst_buffer_new_allocate (NULL,
3208         gst_buffer_get_size (buffer), &params);
3209
3210     /* Copy data "by hand", so ensure alignment is kept: */
3211     gst_buffer_fill (new_buffer, 0, map.data, map.size);
3212
3213     gst_buffer_copy_into (new_buffer, buffer, GST_BUFFER_COPY_METADATA, 0, -1);
3214     GST_DEBUG_OBJECT (demux,
3215         "We want output aligned on %" G_GSIZE_FORMAT ", reallocated",
3216         alignment);
3217
3218     gst_buffer_unmap (buffer, &map);
3219     gst_buffer_unref (buffer);
3220
3221     return new_buffer;
3222   }
3223
3224   gst_buffer_unmap (buffer, &map);
3225   return buffer;
3226 }
3227
3228 static GstFlowReturn
3229 gst_matroska_demux_parse_blockgroup_or_simpleblock (GstMatroskaDemux * demux,
3230     GstEbmlRead * ebml, guint64 cluster_time, guint64 cluster_offset,
3231     gboolean is_simpleblock)
3232 {
3233   GstMatroskaTrackContext *stream = NULL;
3234   GstFlowReturn ret = GST_FLOW_OK;
3235   gboolean readblock = FALSE;
3236   guint32 id;
3237   guint64 block_duration = -1;
3238   gint64 block_discardpadding = 0;
3239   GstBuffer *buf = NULL;
3240   GstMapInfo map;
3241   gint stream_num = -1, n, laces = 0;
3242   guint size = 0;
3243   gint *lace_size = NULL;
3244   gint64 time = 0;
3245   gint flags = 0;
3246   gint64 referenceblock = 0;
3247   gint64 offset;
3248   GstClockTime buffer_timestamp;
3249
3250   offset = gst_ebml_read_get_offset (ebml);
3251
3252   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
3253     if (!is_simpleblock) {
3254       if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK) {
3255         goto data_error;
3256       }
3257     } else {
3258       id = GST_MATROSKA_ID_SIMPLEBLOCK;
3259     }
3260
3261     switch (id) {
3262         /* one block inside the group. Note, block parsing is one
3263          * of the harder things, so this code is a bit complicated.
3264          * See http://www.matroska.org/ for documentation. */
3265       case GST_MATROSKA_ID_SIMPLEBLOCK:
3266       case GST_MATROSKA_ID_BLOCK:
3267       {
3268         guint64 num;
3269         guint8 *data;
3270
3271         if (buf) {
3272           gst_buffer_unmap (buf, &map);
3273           gst_buffer_unref (buf);
3274           buf = NULL;
3275         }
3276         if ((ret = gst_ebml_read_buffer (ebml, &id, &buf)) != GST_FLOW_OK)
3277           break;
3278
3279         gst_buffer_map (buf, &map, GST_MAP_READ);
3280         data = map.data;
3281         size = map.size;
3282
3283         /* first byte(s): blocknum */
3284         if ((n = gst_matroska_ebmlnum_uint (data, size, &num)) < 0)
3285           goto data_error;
3286         data += n;
3287         size -= n;
3288
3289         /* fetch stream from num */
3290         stream_num = gst_matroska_read_common_stream_from_num (&demux->common,
3291             num);
3292         if (G_UNLIKELY (size < 3)) {
3293           GST_WARNING_OBJECT (demux, "Invalid size %u", size);
3294           /* non-fatal, try next block(group) */
3295           ret = GST_FLOW_OK;
3296           goto done;
3297         } else if (G_UNLIKELY (stream_num < 0 ||
3298                 stream_num >= demux->common.num_streams)) {
3299           /* let's not give up on a stray invalid track number */
3300           GST_WARNING_OBJECT (demux,
3301               "Invalid stream %d for track number %" G_GUINT64_FORMAT
3302               "; ignoring block", stream_num, num);
3303           goto done;
3304         }
3305
3306         stream = g_ptr_array_index (demux->common.src, stream_num);
3307
3308         /* time (relative to cluster time) */
3309         time = ((gint16) GST_READ_UINT16_BE (data));
3310         data += 2;
3311         size -= 2;
3312         flags = GST_READ_UINT8 (data);
3313         data += 1;
3314         size -= 1;
3315
3316         GST_LOG_OBJECT (demux, "time %" G_GUINT64_FORMAT ", flags %d", time,
3317             flags);
3318
3319         switch ((flags & 0x06) >> 1) {
3320           case 0x0:            /* no lacing */
3321             laces = 1;
3322             lace_size = g_new (gint, 1);
3323             lace_size[0] = size;
3324             break;
3325
3326           case 0x1:            /* xiph lacing */
3327           case 0x2:            /* fixed-size lacing */
3328           case 0x3:            /* EBML lacing */
3329             if (size == 0)
3330               goto invalid_lacing;
3331             laces = GST_READ_UINT8 (data) + 1;
3332             data += 1;
3333             size -= 1;
3334             lace_size = g_new0 (gint, laces);
3335
3336             switch ((flags & 0x06) >> 1) {
3337               case 0x1:        /* xiph lacing */  {
3338                 guint temp, total = 0;
3339
3340                 for (n = 0; ret == GST_FLOW_OK && n < laces - 1; n++) {
3341                   while (1) {
3342                     if (size == 0)
3343                       goto invalid_lacing;
3344                     temp = GST_READ_UINT8 (data);
3345                     lace_size[n] += temp;
3346                     data += 1;
3347                     size -= 1;
3348                     if (temp != 0xff)
3349                       break;
3350                   }
3351                   total += lace_size[n];
3352                 }
3353                 lace_size[n] = size - total;
3354                 break;
3355               }
3356
3357               case 0x2:        /* fixed-size lacing */
3358                 for (n = 0; n < laces; n++)
3359                   lace_size[n] = size / laces;
3360                 break;
3361
3362               case 0x3:        /* EBML lacing */  {
3363                 guint total;
3364
3365                 if ((n = gst_matroska_ebmlnum_uint (data, size, &num)) < 0)
3366                   goto data_error;
3367                 data += n;
3368                 size -= n;
3369                 total = lace_size[0] = num;
3370                 for (n = 1; ret == GST_FLOW_OK && n < laces - 1; n++) {
3371                   gint64 snum;
3372                   gint r;
3373
3374                   if ((r = gst_matroska_ebmlnum_sint (data, size, &snum)) < 0)
3375                     goto data_error;
3376                   data += r;
3377                   size -= r;
3378                   lace_size[n] = lace_size[n - 1] + snum;
3379                   total += lace_size[n];
3380                 }
3381                 if (n < laces)
3382                   lace_size[n] = size - total;
3383                 break;
3384               }
3385             }
3386             break;
3387         }
3388
3389         if (ret != GST_FLOW_OK)
3390           break;
3391
3392         readblock = TRUE;
3393         break;
3394       }
3395
3396       case GST_MATROSKA_ID_BLOCKDURATION:{
3397         ret = gst_ebml_read_uint (ebml, &id, &block_duration);
3398         GST_DEBUG_OBJECT (demux, "BlockDuration: %" G_GUINT64_FORMAT,
3399             block_duration);
3400         break;
3401       }
3402
3403       case GST_MATROSKA_ID_DISCARDPADDING:{
3404         ret = gst_ebml_read_sint (ebml, &id, &block_discardpadding);
3405         GST_DEBUG_OBJECT (demux, "DiscardPadding: %" GST_STIME_FORMAT,
3406             GST_STIME_ARGS (block_discardpadding));
3407         break;
3408       }
3409
3410       case GST_MATROSKA_ID_REFERENCEBLOCK:{
3411         ret = gst_ebml_read_sint (ebml, &id, &referenceblock);
3412         GST_DEBUG_OBJECT (demux, "ReferenceBlock: %" G_GINT64_FORMAT,
3413             referenceblock);
3414         break;
3415       }
3416
3417       case GST_MATROSKA_ID_CODECSTATE:{
3418         guint8 *data;
3419         guint64 data_len = 0;
3420
3421         if ((ret =
3422                 gst_ebml_read_binary (ebml, &id, &data,
3423                     &data_len)) != GST_FLOW_OK)
3424           break;
3425
3426         if (G_UNLIKELY (stream == NULL)) {
3427           GST_WARNING_OBJECT (demux,
3428               "Unexpected CodecState subelement - ignoring");
3429           break;
3430         }
3431
3432         g_free (stream->codec_state);
3433         stream->codec_state = data;
3434         stream->codec_state_size = data_len;
3435
3436         /* Decode if necessary */
3437         if (stream->encodings && stream->encodings->len > 0
3438             && stream->codec_state && stream->codec_state_size > 0) {
3439           if (!gst_matroska_decode_data (stream->encodings,
3440                   &stream->codec_state, &stream->codec_state_size,
3441                   GST_MATROSKA_TRACK_ENCODING_SCOPE_CODEC_DATA, TRUE)) {
3442             GST_WARNING_OBJECT (demux, "Decoding codec state failed");
3443           }
3444         }
3445
3446         GST_DEBUG_OBJECT (demux, "CodecState of %" G_GSIZE_FORMAT " bytes",
3447             stream->codec_state_size);
3448         break;
3449       }
3450
3451       default:
3452         ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
3453             "BlockGroup", id);
3454         break;
3455
3456       case GST_MATROSKA_ID_BLOCKVIRTUAL:
3457       case GST_MATROSKA_ID_BLOCKADDITIONS:
3458       case GST_MATROSKA_ID_REFERENCEPRIORITY:
3459       case GST_MATROSKA_ID_REFERENCEVIRTUAL:
3460       case GST_MATROSKA_ID_SLICES:
3461         GST_DEBUG_OBJECT (demux,
3462             "Skipping BlockGroup subelement 0x%x - ignoring", id);
3463         ret = gst_ebml_read_skip (ebml);
3464         break;
3465     }
3466
3467     if (is_simpleblock)
3468       break;
3469   }
3470
3471   /* reading a number or so could have failed */
3472   if (ret != GST_FLOW_OK)
3473     goto data_error;
3474
3475   if (ret == GST_FLOW_OK && readblock) {
3476     gboolean invisible_frame = FALSE;
3477     gboolean delta_unit = FALSE;
3478     guint64 duration = 0;
3479     gint64 lace_time = 0;
3480
3481     stream = g_ptr_array_index (demux->common.src, stream_num);
3482
3483     if (cluster_time != GST_CLOCK_TIME_NONE) {
3484       /* FIXME: What to do with negative timestamps? Give timestamp 0 or -1?
3485        * Drop unless the lace contains timestamp 0? */
3486       if (time < 0 && (-time) > cluster_time) {
3487         lace_time = 0;
3488       } else {
3489         if (stream->timecodescale == 1.0)
3490           lace_time = (cluster_time + time) * demux->common.time_scale;
3491         else
3492           lace_time =
3493               gst_util_guint64_to_gdouble ((cluster_time + time) *
3494               demux->common.time_scale) * stream->timecodescale;
3495       }
3496     } else {
3497       lace_time = GST_CLOCK_TIME_NONE;
3498     }
3499
3500     /* need to refresh segment info ASAP */
3501     if (GST_CLOCK_TIME_IS_VALID (lace_time) && demux->need_segment) {
3502       GstSegment *segment = &demux->common.segment;
3503       guint64 clace_time;
3504       GstEvent *segment_event;
3505
3506       if (!GST_CLOCK_TIME_IS_VALID (demux->stream_start_time)) {
3507         demux->stream_start_time = lace_time;
3508         GST_DEBUG_OBJECT (demux,
3509             "Setting stream start time to %" GST_TIME_FORMAT,
3510             GST_TIME_ARGS (lace_time));
3511       }
3512       clace_time = MAX (lace_time, demux->stream_start_time);
3513       if (GST_CLOCK_TIME_IS_VALID (demux->common.segment.position) &&
3514           demux->common.segment.position != 0) {
3515         GST_DEBUG_OBJECT (demux,
3516             "using stored seek position %" GST_TIME_FORMAT,
3517             GST_TIME_ARGS (demux->common.segment.position));
3518         clace_time = demux->common.segment.position + demux->stream_start_time;
3519         segment->position = GST_CLOCK_TIME_NONE;
3520       }
3521       segment->start = clace_time;
3522       segment->stop = GST_CLOCK_TIME_NONE;
3523       segment->time = segment->start - demux->stream_start_time;
3524       segment->position = segment->start - demux->stream_start_time;
3525       GST_DEBUG_OBJECT (demux,
3526           "generated segment starting at %" GST_TIME_FORMAT ": %"
3527           GST_SEGMENT_FORMAT, GST_TIME_ARGS (lace_time), segment);
3528       /* now convey our segment notion downstream */
3529       segment_event = gst_event_new_segment (segment);
3530       if (demux->segment_seqnum)
3531         gst_event_set_seqnum (segment_event, demux->segment_seqnum);
3532       gst_matroska_demux_send_event (demux, segment_event);
3533       demux->need_segment = FALSE;
3534       demux->segment_seqnum = 0;
3535     }
3536
3537     /* send pending codec data headers for all streams,
3538      * before we perform sync across all streams */
3539     gst_matroska_demux_push_codec_data_all (demux);
3540
3541     if (block_duration != -1) {
3542       if (stream->timecodescale == 1.0)
3543         duration = gst_util_uint64_scale (block_duration,
3544             demux->common.time_scale, 1);
3545       else
3546         duration =
3547             gst_util_gdouble_to_guint64 (gst_util_guint64_to_gdouble
3548             (gst_util_uint64_scale (block_duration, demux->common.time_scale,
3549                     1)) * stream->timecodescale);
3550     } else if (stream->default_duration) {
3551       duration = stream->default_duration * laces;
3552     }
3553     /* else duration is diff between timecode of this and next block */
3554
3555     if (stream->type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
3556       /* For SimpleBlock, look at the keyframe bit in flags. Otherwise,
3557          a ReferenceBlock implies that this is not a keyframe. In either
3558          case, it only makes sense for video streams. */
3559       if ((is_simpleblock && !(flags & 0x80)) || referenceblock) {
3560         delta_unit = TRUE;
3561         invisible_frame = ((flags & 0x08)) &&
3562             (!strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP8) ||
3563             !strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP9));
3564       }
3565
3566       /* If we're doing a keyframe-only trickmode, only push keyframes on video
3567        * streams */
3568       if (delta_unit
3569           && demux->common.
3570           segment.flags & GST_SEGMENT_FLAG_TRICKMODE_KEY_UNITS) {
3571         GST_LOG_OBJECT (demux, "Skipping non-keyframe on stream %d",
3572             stream->index);
3573         ret = GST_FLOW_OK;
3574         goto done;
3575       }
3576     }
3577
3578     for (n = 0; n < laces; n++) {
3579       GstBuffer *sub;
3580
3581       if (G_UNLIKELY (lace_size[n] > size)) {
3582         GST_WARNING_OBJECT (demux, "Invalid lace size");
3583         break;
3584       }
3585
3586       /* QoS for video track with an index. the assumption is that
3587          index entries point to keyframes, but if that is not true we
3588          will instad skip until the next keyframe. */
3589       if (GST_CLOCK_TIME_IS_VALID (lace_time) &&
3590           stream->type == GST_MATROSKA_TRACK_TYPE_VIDEO &&
3591           stream->index_table && demux->common.segment.rate > 0.0) {
3592         GstMatroskaTrackVideoContext *videocontext =
3593             (GstMatroskaTrackVideoContext *) stream;
3594         GstClockTime earliest_time;
3595         GstClockTime earliest_stream_time;
3596
3597         GST_OBJECT_LOCK (demux);
3598         earliest_time = videocontext->earliest_time;
3599         GST_OBJECT_UNLOCK (demux);
3600         earliest_stream_time =
3601             gst_segment_position_from_running_time (&demux->common.segment,
3602             GST_FORMAT_TIME, earliest_time);
3603
3604         if (GST_CLOCK_TIME_IS_VALID (lace_time) &&
3605             GST_CLOCK_TIME_IS_VALID (earliest_stream_time) &&
3606             lace_time <= earliest_stream_time) {
3607           /* find index entry (keyframe) <= earliest_stream_time */
3608           GstMatroskaIndex *entry =
3609               gst_util_array_binary_search (stream->index_table->data,
3610               stream->index_table->len, sizeof (GstMatroskaIndex),
3611               (GCompareDataFunc) gst_matroska_index_seek_find,
3612               GST_SEARCH_MODE_BEFORE, &earliest_stream_time, NULL);
3613
3614           /* if that entry (keyframe) is after the current the current
3615              buffer, we can skip pushing (and thus decoding) all
3616              buffers until that keyframe. */
3617           if (entry && GST_CLOCK_TIME_IS_VALID (entry->time) &&
3618               entry->time > lace_time) {
3619             GST_LOG_OBJECT (demux, "Skipping lace before late keyframe");
3620             stream->set_discont = TRUE;
3621             goto next_lace;
3622           }
3623         }
3624       }
3625
3626       sub = gst_buffer_copy_region (buf, GST_BUFFER_COPY_ALL,
3627           gst_buffer_get_size (buf) - size, lace_size[n]);
3628       GST_DEBUG_OBJECT (demux, "created subbuffer %p", sub);
3629
3630       if (delta_unit)
3631         GST_BUFFER_FLAG_SET (sub, GST_BUFFER_FLAG_DELTA_UNIT);
3632       else
3633         GST_BUFFER_FLAG_UNSET (sub, GST_BUFFER_FLAG_DELTA_UNIT);
3634
3635       if (invisible_frame)
3636         GST_BUFFER_FLAG_SET (sub, GST_BUFFER_FLAG_DECODE_ONLY);
3637
3638       if (stream->encodings != NULL && stream->encodings->len > 0)
3639         sub = gst_matroska_decode_buffer (stream, sub);
3640
3641       if (sub == NULL) {
3642         GST_WARNING_OBJECT (demux, "Decoding buffer failed");
3643         goto next_lace;
3644       }
3645
3646       if (!stream->dts_only) {
3647         GST_BUFFER_PTS (sub) = lace_time;
3648       } else {
3649         GST_BUFFER_DTS (sub) = lace_time;
3650         if (stream->intra_only)
3651           GST_BUFFER_PTS (sub) = lace_time;
3652       }
3653
3654       buffer_timestamp = gst_matroska_track_get_buffer_timestamp (stream, sub);
3655
3656       if (GST_CLOCK_TIME_IS_VALID (lace_time)) {
3657         GstClockTime last_stop_end;
3658
3659         /* Check if this stream is after segment stop */
3660         if (GST_CLOCK_TIME_IS_VALID (demux->common.segment.stop) &&
3661             lace_time >= demux->common.segment.stop) {
3662           GST_DEBUG_OBJECT (demux,
3663               "Stream %d after segment stop %" GST_TIME_FORMAT, stream->index,
3664               GST_TIME_ARGS (demux->common.segment.stop));
3665           gst_buffer_unref (sub);
3666           goto eos;
3667         }
3668         if (offset >= stream->to_offset
3669             || (GST_CLOCK_TIME_IS_VALID (demux->to_time)
3670                 && lace_time > demux->to_time)) {
3671           GST_DEBUG_OBJECT (demux, "Stream %d after playback section",
3672               stream->index);
3673           gst_buffer_unref (sub);
3674           goto eos;
3675         }
3676
3677         /* handle gaps, e.g. non-zero start-time, or an cue index entry
3678          * that landed us with timestamps not quite intended */
3679         GST_OBJECT_LOCK (demux);
3680         if (demux->max_gap_time &&
3681             GST_CLOCK_TIME_IS_VALID (demux->last_stop_end) &&
3682             demux->common.segment.rate > 0.0) {
3683           GstClockTimeDiff diff;
3684
3685           /* only send segments with increasing start times,
3686            * otherwise if these go back and forth downstream (sinks) increase
3687            * accumulated time and running_time */
3688           diff = GST_CLOCK_DIFF (demux->last_stop_end, lace_time);
3689           if (diff > 0 && diff > demux->max_gap_time
3690               && lace_time > demux->common.segment.start
3691               && (!GST_CLOCK_TIME_IS_VALID (demux->common.segment.stop)
3692                   || lace_time < demux->common.segment.stop)) {
3693             GstEvent *event;
3694             GST_DEBUG_OBJECT (demux,
3695                 "Gap of %" G_GINT64_FORMAT " ns detected in"
3696                 "stream %d (%" GST_TIME_FORMAT " -> %" GST_TIME_FORMAT "). "
3697                 "Sending updated SEGMENT events", diff,
3698                 stream->index, GST_TIME_ARGS (stream->pos),
3699                 GST_TIME_ARGS (lace_time));
3700
3701             event = gst_event_new_gap (demux->last_stop_end, diff);
3702             GST_OBJECT_UNLOCK (demux);
3703             gst_pad_push_event (stream->pad, event);
3704             GST_OBJECT_LOCK (demux);
3705           }
3706         }
3707
3708         if (!GST_CLOCK_TIME_IS_VALID (demux->common.segment.position)
3709             || demux->common.segment.position < lace_time) {
3710           demux->common.segment.position = lace_time;
3711         }
3712         GST_OBJECT_UNLOCK (demux);
3713
3714         last_stop_end = lace_time;
3715         if (duration) {
3716           GST_BUFFER_DURATION (sub) = duration / laces;
3717           last_stop_end += GST_BUFFER_DURATION (sub);
3718         }
3719
3720         if (!GST_CLOCK_TIME_IS_VALID (demux->last_stop_end) ||
3721             demux->last_stop_end < last_stop_end)
3722           demux->last_stop_end = last_stop_end;
3723
3724         GST_OBJECT_LOCK (demux);
3725         if (demux->common.segment.duration == -1 ||
3726             demux->stream_start_time + demux->common.segment.duration <
3727             last_stop_end) {
3728           demux->common.segment.duration =
3729               last_stop_end - demux->stream_start_time;
3730           GST_OBJECT_UNLOCK (demux);
3731           if (!demux->invalid_duration) {
3732             gst_element_post_message (GST_ELEMENT_CAST (demux),
3733                 gst_message_new_duration_changed (GST_OBJECT_CAST (demux)));
3734             demux->invalid_duration = TRUE;
3735           }
3736         } else {
3737           GST_OBJECT_UNLOCK (demux);
3738         }
3739       }
3740
3741       stream->pos = lace_time;
3742
3743       gst_matroska_demux_sync_streams (demux);
3744
3745       if (stream->set_discont) {
3746         GST_DEBUG_OBJECT (demux, "marking DISCONT");
3747         GST_BUFFER_FLAG_SET (sub, GST_BUFFER_FLAG_DISCONT);
3748         stream->set_discont = FALSE;
3749       } else {
3750         GST_BUFFER_FLAG_UNSET (sub, GST_BUFFER_FLAG_DISCONT);
3751       }
3752
3753       /* reverse playback book-keeping */
3754       if (!GST_CLOCK_TIME_IS_VALID (stream->from_time))
3755         stream->from_time = lace_time;
3756       if (stream->from_offset == -1)
3757         stream->from_offset = offset;
3758
3759       GST_DEBUG_OBJECT (demux,
3760           "Pushing lace %d, data of size %" G_GSIZE_FORMAT
3761           " for stream %d, time=%" GST_TIME_FORMAT " and duration=%"
3762           GST_TIME_FORMAT, n, gst_buffer_get_size (sub), stream_num,
3763           GST_TIME_ARGS (buffer_timestamp),
3764           GST_TIME_ARGS (GST_BUFFER_DURATION (sub)));
3765
3766 #if 0
3767       if (demux->common.element_index) {
3768         if (stream->index_writer_id == -1)
3769           gst_index_get_writer_id (demux->common.element_index,
3770               GST_OBJECT (stream->pad), &stream->index_writer_id);
3771
3772         GST_LOG_OBJECT (demux, "adding association %" GST_TIME_FORMAT "-> %"
3773             G_GUINT64_FORMAT " for writer id %d",
3774             GST_TIME_ARGS (buffer_timestamp), cluster_offset,
3775             stream->index_writer_id);
3776         gst_index_add_association (demux->common.element_index,
3777             stream->index_writer_id, GST_BUFFER_FLAG_IS_SET (sub,
3778                 GST_BUFFER_FLAG_DELTA_UNIT) ? 0 : GST_ASSOCIATION_FLAG_KEY_UNIT,
3779             GST_FORMAT_TIME, buffer_timestamp, GST_FORMAT_BYTES, cluster_offset,
3780             NULL);
3781       }
3782 #endif
3783
3784       /* Postprocess the buffers depending on the codec used */
3785       if (stream->postprocess_frame) {
3786         GST_LOG_OBJECT (demux, "running post process");
3787         ret = stream->postprocess_frame (GST_ELEMENT (demux), stream, &sub);
3788       }
3789
3790       /* At this point, we have a sub-buffer pointing at data within a larger
3791          buffer. This data might not be aligned with anything. If the data is
3792          raw samples though, we want it aligned to the raw type (eg, 4 bytes
3793          for 32 bit samples, etc), or bad things will happen downstream as
3794          elements typically assume minimal alignment.
3795          Therefore, create an aligned copy if necessary. */
3796       sub = gst_matroska_demux_align_buffer (demux, sub, stream->alignment);
3797
3798       if (!strcmp (stream->codec_id, GST_MATROSKA_CODEC_ID_AUDIO_OPUS)) {
3799         guint64 start_clip = 0, end_clip = 0;
3800
3801         /* Codec delay is part of the timestamps */
3802         if (GST_BUFFER_PTS_IS_VALID (sub) && stream->codec_delay) {
3803           if (GST_BUFFER_PTS (sub) > stream->codec_delay) {
3804             GST_BUFFER_PTS (sub) -= stream->codec_delay;
3805           } else {
3806             GST_BUFFER_PTS (sub) = 0;
3807             start_clip =
3808                 gst_util_uint64_scale_round (stream->codec_delay, 48000,
3809                 GST_SECOND);
3810
3811             if (GST_BUFFER_DURATION_IS_VALID (sub)) {
3812               if (GST_BUFFER_DURATION (sub) > stream->codec_delay)
3813                 GST_BUFFER_DURATION (sub) -= stream->codec_delay;
3814               else
3815                 GST_BUFFER_DURATION (sub) = 0;
3816             }
3817           }
3818         }
3819
3820         if (block_discardpadding) {
3821           end_clip =
3822               gst_util_uint64_scale_round (block_discardpadding, 48000,
3823               GST_SECOND);
3824         }
3825
3826         if (start_clip || end_clip) {
3827           gst_buffer_add_audio_clipping_meta (sub, GST_FORMAT_DEFAULT,
3828               start_clip, end_clip);
3829         }
3830       }
3831
3832       if (GST_BUFFER_PTS_IS_VALID (sub)) {
3833         stream->pos = GST_BUFFER_PTS (sub);
3834         if (GST_BUFFER_DURATION_IS_VALID (sub))
3835           stream->pos += GST_BUFFER_DURATION (sub);
3836       } else if (GST_BUFFER_DTS_IS_VALID (sub)) {
3837         stream->pos = GST_BUFFER_DTS (sub);
3838         if (GST_BUFFER_DURATION_IS_VALID (sub))
3839           stream->pos += GST_BUFFER_DURATION (sub);
3840       }
3841
3842       ret = gst_pad_push (stream->pad, sub);
3843
3844       if (demux->common.segment.rate < 0) {
3845         if (lace_time > demux->common.segment.stop && ret == GST_FLOW_EOS) {
3846           /* In reverse playback we can get a GST_FLOW_EOS when
3847            * we are at the end of the segment, so we just need to jump
3848            * back to the previous section. */
3849           GST_DEBUG_OBJECT (demux, "downstream has reached end of segment");
3850           ret = GST_FLOW_OK;
3851         }
3852       }
3853       /* combine flows */
3854       ret = gst_flow_combiner_update_pad_flow (demux->flowcombiner,
3855           stream->pad, ret);
3856
3857     next_lace:
3858       size -= lace_size[n];
3859       if (lace_time != GST_CLOCK_TIME_NONE && duration)
3860         lace_time += duration / laces;
3861       else
3862         lace_time = GST_CLOCK_TIME_NONE;
3863     }
3864   }
3865
3866 done:
3867   if (buf) {
3868     gst_buffer_unmap (buf, &map);
3869     gst_buffer_unref (buf);
3870   }
3871   g_free (lace_size);
3872
3873   return ret;
3874
3875   /* EXITS */
3876 eos:
3877   {
3878     stream->eos = TRUE;
3879     ret = GST_FLOW_OK;
3880     /* combine flows */
3881     ret = gst_flow_combiner_update_pad_flow (demux->flowcombiner, stream->pad,
3882         ret);
3883     goto done;
3884   }
3885 invalid_lacing:
3886   {
3887     GST_ELEMENT_WARNING (demux, STREAM, DEMUX, (NULL), ("Invalid lacing size"));
3888     /* non-fatal, try next block(group) */
3889     ret = GST_FLOW_OK;
3890     goto done;
3891   }
3892 data_error:
3893   {
3894     GST_ELEMENT_WARNING (demux, STREAM, DEMUX, (NULL), ("Data error"));
3895     /* non-fatal, try next block(group) */
3896     ret = GST_FLOW_OK;
3897     goto done;
3898   }
3899 }
3900
3901 /* return FALSE if block(group) should be skipped (due to a seek) */
3902 static inline gboolean
3903 gst_matroska_demux_seek_block (GstMatroskaDemux * demux)
3904 {
3905   if (G_UNLIKELY (demux->seek_block)) {
3906     if (!(--demux->seek_block)) {
3907       return TRUE;
3908     } else {
3909       GST_LOG_OBJECT (demux, "should skip block due to seek");
3910       return FALSE;
3911     }
3912   } else {
3913     return TRUE;
3914   }
3915 }
3916
3917 static GstFlowReturn
3918 gst_matroska_demux_parse_contents_seekentry (GstMatroskaDemux * demux,
3919     GstEbmlRead * ebml)
3920 {
3921   GstFlowReturn ret;
3922   guint64 seek_pos = (guint64) - 1;
3923   guint32 seek_id = 0;
3924   guint32 id;
3925
3926   DEBUG_ELEMENT_START (demux, ebml, "Seek");
3927
3928   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
3929     DEBUG_ELEMENT_STOP (demux, ebml, "Seek", ret);
3930     return ret;
3931   }
3932
3933   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
3934     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
3935       break;
3936
3937     switch (id) {
3938       case GST_MATROSKA_ID_SEEKID:
3939       {
3940         guint64 t;
3941
3942         if ((ret = gst_ebml_read_uint (ebml, &id, &t)) != GST_FLOW_OK)
3943           break;
3944
3945         GST_DEBUG_OBJECT (demux, "SeekID: %" G_GUINT64_FORMAT, t);
3946         seek_id = t;
3947         break;
3948       }
3949
3950       case GST_MATROSKA_ID_SEEKPOSITION:
3951       {
3952         guint64 t;
3953
3954         if ((ret = gst_ebml_read_uint (ebml, &id, &t)) != GST_FLOW_OK)
3955           break;
3956
3957         if (t > G_MAXINT64) {
3958           GST_WARNING_OBJECT (demux,
3959               "Too large SeekPosition %" G_GUINT64_FORMAT, t);
3960           break;
3961         }
3962
3963         GST_DEBUG_OBJECT (demux, "SeekPosition: %" G_GUINT64_FORMAT, t);
3964         seek_pos = t;
3965         break;
3966       }
3967
3968       default:
3969         ret = gst_matroska_read_common_parse_skip (&demux->common, ebml,
3970             "SeekHead", id);
3971         break;
3972     }
3973   }
3974
3975   if (ret != GST_FLOW_OK && ret != GST_FLOW_EOS)
3976     return ret;
3977
3978   if (!seek_id || seek_pos == (guint64) - 1) {
3979     GST_WARNING_OBJECT (demux, "Incomplete seekhead entry (0x%x/%"
3980         G_GUINT64_FORMAT ")", seek_id, seek_pos);
3981     return GST_FLOW_OK;
3982   }
3983
3984   switch (seek_id) {
3985     case GST_MATROSKA_ID_SEEKHEAD:
3986     {
3987     }
3988     case GST_MATROSKA_ID_CUES:
3989     case GST_MATROSKA_ID_TAGS:
3990     case GST_MATROSKA_ID_TRACKS:
3991     case GST_MATROSKA_ID_SEGMENTINFO:
3992     case GST_MATROSKA_ID_ATTACHMENTS:
3993     case GST_MATROSKA_ID_CHAPTERS:
3994     {
3995       guint64 before_pos, length;
3996       guint needed;
3997
3998       /* remember */
3999       length = gst_matroska_read_common_get_length (&demux->common);
4000       before_pos = demux->common.offset;
4001
4002       if (length == (guint64) - 1) {
4003         GST_DEBUG_OBJECT (demux, "no upstream length, skipping SeakHead entry");
4004         break;
4005       }
4006
4007       /* check for validity */
4008       if (seek_pos + demux->common.ebml_segment_start + 12 >= length) {
4009         GST_WARNING_OBJECT (demux,
4010             "SeekHead reference lies outside file!" " (%"
4011             G_GUINT64_FORMAT "+%" G_GUINT64_FORMAT "+12 >= %"
4012             G_GUINT64_FORMAT ")", seek_pos, demux->common.ebml_segment_start,
4013             length);
4014         break;
4015       }
4016
4017       /* only pick up index location when streaming */
4018       if (demux->streaming) {
4019         if (seek_id == GST_MATROSKA_ID_CUES) {
4020           demux->index_offset = seek_pos + demux->common.ebml_segment_start;
4021           GST_DEBUG_OBJECT (demux, "Cues located at offset %" G_GUINT64_FORMAT,
4022               demux->index_offset);
4023         }
4024         break;
4025       }
4026
4027       /* seek */
4028       demux->common.offset = seek_pos + demux->common.ebml_segment_start;
4029
4030       /* check ID */
4031       if ((ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
4032                   GST_ELEMENT_CAST (demux), &id, &length, &needed)) !=
4033           GST_FLOW_OK)
4034         goto finish;
4035
4036       if (id != seek_id) {
4037         GST_WARNING_OBJECT (demux,
4038             "We looked for ID=0x%x but got ID=0x%x (pos=%" G_GUINT64_FORMAT ")",
4039             seek_id, id, seek_pos + demux->common.ebml_segment_start);
4040       } else {
4041         /* now parse */
4042         ret = gst_matroska_demux_parse_id (demux, id, length, needed);
4043       }
4044
4045     finish:
4046       /* seek back */
4047       demux->common.offset = before_pos;
4048       break;
4049     }
4050
4051     case GST_MATROSKA_ID_CLUSTER:
4052     {
4053       guint64 pos = seek_pos + demux->common.ebml_segment_start;
4054
4055       GST_LOG_OBJECT (demux, "Cluster position");
4056       if (G_UNLIKELY (!demux->clusters))
4057         demux->clusters = g_array_sized_new (TRUE, TRUE, sizeof (guint64), 100);
4058       g_array_append_val (demux->clusters, pos);
4059       break;
4060     }
4061
4062     default:
4063       GST_DEBUG_OBJECT (demux, "Ignoring Seek entry for ID=0x%x", seek_id);
4064       break;
4065   }
4066   DEBUG_ELEMENT_STOP (demux, ebml, "Seek", ret);
4067
4068   return ret;
4069 }
4070
4071 static GstFlowReturn
4072 gst_matroska_demux_parse_contents (GstMatroskaDemux * demux, GstEbmlRead * ebml)
4073 {
4074   GstFlowReturn ret = GST_FLOW_OK;
4075   guint32 id;
4076
4077   DEBUG_ELEMENT_START (demux, ebml, "SeekHead");
4078
4079   if ((ret = gst_ebml_read_master (ebml, &id)) != GST_FLOW_OK) {
4080     DEBUG_ELEMENT_STOP (demux, ebml, "SeekHead", ret);
4081     return ret;
4082   }
4083
4084   while (ret == GST_FLOW_OK && gst_ebml_read_has_remaining (ebml, 1, TRUE)) {
4085     if ((ret = gst_ebml_peek_id (ebml, &id)) != GST_FLOW_OK)
4086       break;
4087
4088     switch (id) {
4089       case GST_MATROSKA_ID_SEEKENTRY:
4090       {
4091         ret = gst_matroska_demux_parse_contents_seekentry (demux, ebml);
4092         /* Ignore EOS and errors here */
4093         if (ret != GST_FLOW_OK) {
4094           GST_DEBUG_OBJECT (demux, "Ignoring %s", gst_flow_get_name (ret));
4095           ret = GST_FLOW_OK;
4096         }
4097         break;
4098       }
4099
4100       default:
4101         ret = gst_matroska_read_common_parse_skip (&demux->common,
4102             ebml, "SeekHead", id);
4103         break;
4104     }
4105   }
4106
4107   DEBUG_ELEMENT_STOP (demux, ebml, "SeekHead", ret);
4108
4109   /* Sort clusters by position for easier searching */
4110   if (demux->clusters)
4111     g_array_sort (demux->clusters, (GCompareFunc) gst_matroska_cluster_compare);
4112
4113   return ret;
4114 }
4115
4116 #define GST_FLOW_OVERFLOW   GST_FLOW_CUSTOM_ERROR
4117
4118 #define MAX_BLOCK_SIZE (15 * 1024 * 1024)
4119
4120 static inline GstFlowReturn
4121 gst_matroska_demux_check_read_size (GstMatroskaDemux * demux, guint64 bytes)
4122 {
4123   if (G_UNLIKELY (bytes > MAX_BLOCK_SIZE)) {
4124     /* only a few blocks are expected/allowed to be large,
4125      * and will be recursed into, whereas others will be read and must fit */
4126     if (demux->streaming) {
4127       /* fatal in streaming case, as we can't step over easily */
4128       GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
4129           ("reading large block of size %" G_GUINT64_FORMAT " not supported; "
4130               "file might be corrupt.", bytes));
4131       return GST_FLOW_ERROR;
4132     } else {
4133       /* indicate higher level to quietly give up */
4134       GST_DEBUG_OBJECT (demux,
4135           "too large block of size %" G_GUINT64_FORMAT, bytes);
4136       return GST_FLOW_ERROR;
4137     }
4138   } else {
4139     return GST_FLOW_OK;
4140   }
4141 }
4142
4143 /* returns TRUE if we truely are in error state, and should give up */
4144 static inline GstFlowReturn
4145 gst_matroska_demux_check_parse_error (GstMatroskaDemux * demux)
4146 {
4147   if (!demux->streaming && demux->next_cluster_offset > 0) {
4148     /* just repositioning to where next cluster should be and try from there */
4149     GST_WARNING_OBJECT (demux, "parse error, trying next cluster expected at %"
4150         G_GUINT64_FORMAT, demux->next_cluster_offset);
4151     demux->common.offset = demux->next_cluster_offset;
4152     demux->next_cluster_offset = 0;
4153     return GST_FLOW_OK;
4154   } else {
4155     gint64 pos;
4156     GstFlowReturn ret;
4157
4158     /* sigh, one last attempt above and beyond call of duty ...;
4159      * search for cluster mark following current pos */
4160     pos = demux->common.offset;
4161     GST_WARNING_OBJECT (demux, "parse error, looking for next cluster");
4162     if ((ret = gst_matroska_demux_search_cluster (demux, &pos)) != GST_FLOW_OK) {
4163       /* did not work, give up */
4164       return ret;
4165     } else {
4166       GST_DEBUG_OBJECT (demux, "... found at  %" G_GUINT64_FORMAT, pos);
4167       /* try that position */
4168       demux->common.offset = pos;
4169       return GST_FLOW_OK;
4170     }
4171   }
4172 }
4173
4174 static inline GstFlowReturn
4175 gst_matroska_demux_flush (GstMatroskaDemux * demux, guint flush)
4176 {
4177   GST_LOG_OBJECT (demux, "skipping %d bytes", flush);
4178   demux->common.offset += flush;
4179   if (demux->streaming) {
4180     GstFlowReturn ret;
4181
4182     /* hard to skip large blocks when streaming */
4183     ret = gst_matroska_demux_check_read_size (demux, flush);
4184     if (ret != GST_FLOW_OK)
4185       return ret;
4186     if (flush <= gst_adapter_available (demux->common.adapter))
4187       gst_adapter_flush (demux->common.adapter, flush);
4188     else
4189       return GST_FLOW_EOS;
4190   }
4191   return GST_FLOW_OK;
4192 }
4193
4194 /* initializes @ebml with @bytes from input stream at current offset.
4195  * Returns EOS if insufficient available,
4196  * ERROR if too much was attempted to read. */
4197 static inline GstFlowReturn
4198 gst_matroska_demux_take (GstMatroskaDemux * demux, guint64 bytes,
4199     GstEbmlRead * ebml)
4200 {
4201   GstBuffer *buffer = NULL;
4202   GstFlowReturn ret = GST_FLOW_OK;
4203
4204   GST_LOG_OBJECT (demux, "taking %" G_GUINT64_FORMAT " bytes for parsing",
4205       bytes);
4206   ret = gst_matroska_demux_check_read_size (demux, bytes);
4207   if (G_UNLIKELY (ret != GST_FLOW_OK)) {
4208     if (!demux->streaming) {
4209       /* in pull mode, we can skip */
4210       if ((ret = gst_matroska_demux_flush (demux, bytes)) == GST_FLOW_OK)
4211         ret = GST_FLOW_OVERFLOW;
4212     } else {
4213       /* otherwise fatal */
4214       ret = GST_FLOW_ERROR;
4215     }
4216     goto exit;
4217   }
4218   if (demux->streaming) {
4219     if (gst_adapter_available (demux->common.adapter) >= bytes)
4220       buffer = gst_adapter_take_buffer (demux->common.adapter, bytes);
4221     else
4222       ret = GST_FLOW_EOS;
4223   } else
4224     ret = gst_matroska_read_common_peek_bytes (&demux->common,
4225         demux->common.offset, bytes, &buffer, NULL);
4226   if (G_LIKELY (buffer)) {
4227     gst_ebml_read_init (ebml, GST_ELEMENT_CAST (demux), buffer,
4228         demux->common.offset);
4229     demux->common.offset += bytes;
4230   }
4231 exit:
4232   return ret;
4233 }
4234
4235 static void
4236 gst_matroska_demux_check_seekability (GstMatroskaDemux * demux)
4237 {
4238   GstQuery *query;
4239   gboolean seekable = FALSE;
4240   gint64 start = -1, stop = -1;
4241
4242   query = gst_query_new_seeking (GST_FORMAT_BYTES);
4243   if (!gst_pad_peer_query (demux->common.sinkpad, query)) {
4244     GST_DEBUG_OBJECT (demux, "seeking query failed");
4245     goto done;
4246   }
4247
4248   gst_query_parse_seeking (query, NULL, &seekable, &start, &stop);
4249
4250   /* try harder to query upstream size if we didn't get it the first time */
4251   if (seekable && stop == -1) {
4252     GST_DEBUG_OBJECT (demux, "doing duration query to fix up unset stop");
4253     gst_pad_peer_query_duration (demux->common.sinkpad, GST_FORMAT_BYTES,
4254         &stop);
4255   }
4256
4257   /* if upstream doesn't know the size, it's likely that it's not seekable in
4258    * practice even if it technically may be seekable */
4259   if (seekable && (start != 0 || stop <= start)) {
4260     GST_DEBUG_OBJECT (demux, "seekable but unknown start/stop -> disable");
4261     seekable = FALSE;
4262   }
4263
4264 done:
4265   GST_INFO_OBJECT (demux, "seekable: %d (%" G_GUINT64_FORMAT " - %"
4266       G_GUINT64_FORMAT ")", seekable, start, stop);
4267   demux->seekable = seekable;
4268
4269   gst_query_unref (query);
4270 }
4271
4272 static GstFlowReturn
4273 gst_matroska_demux_find_tracks (GstMatroskaDemux * demux)
4274 {
4275   guint32 id;
4276   guint64 before_pos;
4277   guint64 length;
4278   guint needed;
4279   GstFlowReturn ret = GST_FLOW_OK;
4280
4281   GST_WARNING_OBJECT (demux,
4282       "Found Cluster element before Tracks, searching Tracks");
4283
4284   /* remember */
4285   before_pos = demux->common.offset;
4286
4287   /* Search Tracks element */
4288   while (TRUE) {
4289     ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
4290         GST_ELEMENT_CAST (demux), &id, &length, &needed);
4291     if (ret != GST_FLOW_OK)
4292       break;
4293
4294     if (id != GST_MATROSKA_ID_TRACKS) {
4295       /* we may be skipping large cluster here, so forego size check etc */
4296       /* ... but we can't skip undefined size; force error */
4297       if (length == G_MAXUINT64) {
4298         ret = gst_matroska_demux_check_read_size (demux, length);
4299         break;
4300       } else {
4301         demux->common.offset += needed;
4302         demux->common.offset += length;
4303       }
4304       continue;
4305     }
4306
4307     /* will lead to track parsing ... */
4308     ret = gst_matroska_demux_parse_id (demux, id, length, needed);
4309     break;
4310   }
4311
4312   /* seek back */
4313   demux->common.offset = before_pos;
4314
4315   return ret;
4316 }
4317
4318 #define GST_READ_CHECK(stmt)  \
4319 G_STMT_START { \
4320   if (G_UNLIKELY ((ret = (stmt)) != GST_FLOW_OK)) { \
4321     if (ret == GST_FLOW_OVERFLOW) { \
4322       ret = GST_FLOW_OK; \
4323     } \
4324     goto read_error; \
4325   } \
4326 } G_STMT_END
4327
4328 static GstFlowReturn
4329 gst_matroska_demux_parse_id (GstMatroskaDemux * demux, guint32 id,
4330     guint64 length, guint needed)
4331 {
4332   GstEbmlRead ebml = { 0, };
4333   GstFlowReturn ret = GST_FLOW_OK;
4334   guint64 read;
4335
4336   GST_LOG_OBJECT (demux, "Parsing Element id 0x%x, "
4337       "size %" G_GUINT64_FORMAT ", prefix %d", id, length, needed);
4338
4339   /* if we plan to read and parse this element, we need prefix (id + length)
4340    * and the contents */
4341   /* mind about overflow wrap-around when dealing with undefined size */
4342   read = length;
4343   if (G_LIKELY (length != G_MAXUINT64))
4344     read += needed;
4345
4346   switch (demux->common.state) {
4347     case GST_MATROSKA_READ_STATE_START:
4348       switch (id) {
4349         case GST_EBML_ID_HEADER:
4350           GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4351           ret = gst_matroska_read_common_parse_header (&demux->common, &ebml);
4352           if (ret != GST_FLOW_OK)
4353             goto parse_failed;
4354           demux->common.state = GST_MATROSKA_READ_STATE_SEGMENT;
4355           gst_matroska_demux_check_seekability (demux);
4356           break;
4357         default:
4358           goto invalid_header;
4359           break;
4360       }
4361       break;
4362     case GST_MATROSKA_READ_STATE_SEGMENT:
4363       switch (id) {
4364         case GST_MATROSKA_ID_SEGMENT:
4365           /* eat segment prefix */
4366           GST_READ_CHECK (gst_matroska_demux_flush (demux, needed));
4367           GST_DEBUG_OBJECT (demux,
4368               "Found Segment start at offset %" G_GUINT64_FORMAT " with size %"
4369               G_GUINT64_FORMAT, demux->common.offset, length);
4370           /* seeks are from the beginning of the segment,
4371            * after the segment ID/length */
4372           demux->common.ebml_segment_start = demux->common.offset;
4373           if (length == 0)
4374             length = G_MAXUINT64;
4375           demux->common.ebml_segment_length = length;
4376           demux->common.state = GST_MATROSKA_READ_STATE_HEADER;
4377           break;
4378         default:
4379           GST_WARNING_OBJECT (demux,
4380               "Expected a Segment ID (0x%x), but received 0x%x!",
4381               GST_MATROSKA_ID_SEGMENT, id);
4382           GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
4383           break;
4384       }
4385       break;
4386     case GST_MATROSKA_READ_STATE_SCANNING:
4387       if (id != GST_MATROSKA_ID_CLUSTER &&
4388           id != GST_MATROSKA_ID_CLUSTERTIMECODE) {
4389         if (demux->common.start_resync_offset != -1) {
4390           /* we need to skip byte per byte if we are scanning for a new cluster
4391            * after invalid data is found
4392            */
4393           read = 1;
4394         }
4395         goto skip;
4396       } else {
4397         if (demux->common.start_resync_offset != -1) {
4398           GST_LOG_OBJECT (demux, "Resync done, new cluster found!");
4399           demux->common.start_resync_offset = -1;
4400           demux->common.state = demux->common.state_to_restore;
4401         }
4402       }
4403       /* fall-through */
4404     case GST_MATROSKA_READ_STATE_HEADER:
4405     case GST_MATROSKA_READ_STATE_DATA:
4406     case GST_MATROSKA_READ_STATE_SEEK:
4407       switch (id) {
4408         case GST_MATROSKA_ID_SEGMENTINFO:
4409           if (!demux->common.segmentinfo_parsed) {
4410             GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4411             ret = gst_matroska_read_common_parse_info (&demux->common,
4412                 GST_ELEMENT_CAST (demux), &ebml);
4413             if (ret == GST_FLOW_OK)
4414               gst_matroska_demux_send_tags (demux);
4415           } else {
4416             GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
4417           }
4418           break;
4419         case GST_MATROSKA_ID_TRACKS:
4420           if (!demux->tracks_parsed) {
4421             GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4422             ret = gst_matroska_demux_parse_tracks (demux, &ebml);
4423           } else {
4424             GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
4425           }
4426           break;
4427         case GST_MATROSKA_ID_CLUSTER:
4428           if (G_UNLIKELY (!demux->tracks_parsed)) {
4429             if (demux->streaming) {
4430               GST_DEBUG_OBJECT (demux, "Cluster before Track");
4431               goto not_streamable;
4432             } else {
4433               ret = gst_matroska_demux_find_tracks (demux);
4434               if (!demux->tracks_parsed)
4435                 goto no_tracks;
4436             }
4437           }
4438           if (G_UNLIKELY (demux->common.state
4439                   == GST_MATROSKA_READ_STATE_HEADER)) {
4440             demux->common.state = GST_MATROSKA_READ_STATE_DATA;
4441             demux->first_cluster_offset = demux->common.offset;
4442             GST_DEBUG_OBJECT (demux, "signaling no more pads");
4443             gst_element_no_more_pads (GST_ELEMENT (demux));
4444             /* send initial segment - we wait till we know the first
4445                incoming timestamp, so we can properly set the start of
4446                the segment. */
4447             demux->need_segment = TRUE;
4448           }
4449           demux->cluster_time = GST_CLOCK_TIME_NONE;
4450           demux->cluster_offset = demux->common.offset;
4451           if (G_UNLIKELY (!demux->seek_first && demux->seek_block)) {
4452             GST_DEBUG_OBJECT (demux, "seek target block %" G_GUINT64_FORMAT
4453                 " not found in Cluster, trying next Cluster's first block instead",
4454                 demux->seek_block);
4455             demux->seek_block = 0;
4456           }
4457           demux->seek_first = FALSE;
4458           /* record next cluster for recovery */
4459           if (read != G_MAXUINT64)
4460             demux->next_cluster_offset = demux->cluster_offset + read;
4461           /* eat cluster prefix */
4462           gst_matroska_demux_flush (demux, needed);
4463           break;
4464         case GST_MATROSKA_ID_CLUSTERTIMECODE:
4465         {
4466           guint64 num;
4467
4468           GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4469           if ((ret = gst_ebml_read_uint (&ebml, &id, &num)) != GST_FLOW_OK)
4470             goto parse_failed;
4471           GST_DEBUG_OBJECT (demux, "ClusterTimeCode: %" G_GUINT64_FORMAT, num);
4472           demux->cluster_time = num;
4473 #if 0
4474           if (demux->common.element_index) {
4475             if (demux->common.element_index_writer_id == -1)
4476               gst_index_get_writer_id (demux->common.element_index,
4477                   GST_OBJECT (demux), &demux->common.element_index_writer_id);
4478             GST_LOG_OBJECT (demux, "adding association %" GST_TIME_FORMAT "-> %"
4479                 G_GUINT64_FORMAT " for writer id %d",
4480                 GST_TIME_ARGS (demux->cluster_time), demux->cluster_offset,
4481                 demux->common.element_index_writer_id);
4482             gst_index_add_association (demux->common.element_index,
4483                 demux->common.element_index_writer_id,
4484                 GST_ASSOCIATION_FLAG_KEY_UNIT,
4485                 GST_FORMAT_TIME, demux->cluster_time,
4486                 GST_FORMAT_BYTES, demux->cluster_offset, NULL);
4487           }
4488 #endif
4489           break;
4490         }
4491         case GST_MATROSKA_ID_BLOCKGROUP:
4492           if (!gst_matroska_demux_seek_block (demux))
4493             goto skip;
4494           GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4495           DEBUG_ELEMENT_START (demux, &ebml, "BlockGroup");
4496           if ((ret = gst_ebml_read_master (&ebml, &id)) == GST_FLOW_OK) {
4497             ret = gst_matroska_demux_parse_blockgroup_or_simpleblock (demux,
4498                 &ebml, demux->cluster_time, demux->cluster_offset, FALSE);
4499           }
4500           DEBUG_ELEMENT_STOP (demux, &ebml, "BlockGroup", ret);
4501           break;
4502         case GST_MATROSKA_ID_SIMPLEBLOCK:
4503           if (!gst_matroska_demux_seek_block (demux))
4504             goto skip;
4505           GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4506           DEBUG_ELEMENT_START (demux, &ebml, "SimpleBlock");
4507           ret = gst_matroska_demux_parse_blockgroup_or_simpleblock (demux,
4508               &ebml, demux->cluster_time, demux->cluster_offset, TRUE);
4509           DEBUG_ELEMENT_STOP (demux, &ebml, "SimpleBlock", ret);
4510           break;
4511         case GST_MATROSKA_ID_ATTACHMENTS:
4512           if (!demux->common.attachments_parsed) {
4513             GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4514             ret = gst_matroska_read_common_parse_attachments (&demux->common,
4515                 GST_ELEMENT_CAST (demux), &ebml);
4516             if (ret == GST_FLOW_OK)
4517               gst_matroska_demux_send_tags (demux);
4518           } else {
4519             GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
4520           }
4521           break;
4522         case GST_MATROSKA_ID_TAGS:
4523           GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4524           ret = gst_matroska_read_common_parse_metadata (&demux->common,
4525               GST_ELEMENT_CAST (demux), &ebml);
4526           if (ret == GST_FLOW_OK)
4527             gst_matroska_demux_send_tags (demux);
4528           break;
4529         case GST_MATROSKA_ID_CHAPTERS:
4530           if (!demux->common.chapters_parsed) {
4531             GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4532             ret =
4533                 gst_matroska_read_common_parse_chapters (&demux->common, &ebml);
4534
4535             if (demux->common.toc) {
4536               gst_matroska_demux_send_event (demux,
4537                   gst_event_new_toc (demux->common.toc, FALSE));
4538             }
4539           } else
4540             GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
4541           break;
4542         case GST_MATROSKA_ID_SEEKHEAD:
4543           GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4544           ret = gst_matroska_demux_parse_contents (demux, &ebml);
4545           break;
4546         case GST_MATROSKA_ID_CUES:
4547           if (demux->common.index_parsed) {
4548             GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
4549             break;
4550           }
4551           GST_READ_CHECK (gst_matroska_demux_take (demux, read, &ebml));
4552           ret = gst_matroska_read_common_parse_index (&demux->common, &ebml);
4553           /* only push based; delayed index building */
4554           if (ret == GST_FLOW_OK
4555               && demux->common.state == GST_MATROSKA_READ_STATE_SEEK) {
4556             GstEvent *event;
4557
4558             GST_OBJECT_LOCK (demux);
4559             event = demux->seek_event;
4560             demux->seek_event = NULL;
4561             GST_OBJECT_UNLOCK (demux);
4562
4563             g_assert (event);
4564             /* unlikely to fail, since we managed to seek to this point */
4565             if (!gst_matroska_demux_handle_seek_event (demux, NULL, event)) {
4566               gst_event_unref (event);
4567               goto seek_failed;
4568             }
4569             gst_event_unref (event);
4570             /* resume data handling, main thread clear to seek again */
4571             GST_OBJECT_LOCK (demux);
4572             demux->common.state = GST_MATROSKA_READ_STATE_DATA;
4573             GST_OBJECT_UNLOCK (demux);
4574           }
4575           break;
4576         case GST_MATROSKA_ID_POSITION:
4577         case GST_MATROSKA_ID_PREVSIZE:
4578         case GST_MATROSKA_ID_ENCRYPTEDBLOCK:
4579         case GST_MATROSKA_ID_SILENTTRACKS:
4580           GST_DEBUG_OBJECT (demux,
4581               "Skipping Cluster subelement 0x%x - ignoring", id);
4582           /* fall-through */
4583         default:
4584         skip:
4585           GST_DEBUG_OBJECT (demux, "skipping Element 0x%x", id);
4586           GST_READ_CHECK (gst_matroska_demux_flush (demux, read));
4587           break;
4588       }
4589       break;
4590   }
4591
4592   if (ret == GST_FLOW_PARSE)
4593     goto parse_failed;
4594
4595 exit:
4596   gst_ebml_read_clear (&ebml);
4597   return ret;
4598
4599   /* ERRORS */
4600 read_error:
4601   {
4602     /* simply exit, maybe not enough data yet */
4603     /* no ebml to clear if read error */
4604     return ret;
4605   }
4606 parse_failed:
4607   {
4608     GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
4609         ("Failed to parse Element 0x%x", id));
4610     ret = GST_FLOW_ERROR;
4611     goto exit;
4612   }
4613 not_streamable:
4614   {
4615     GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
4616         ("File layout does not permit streaming"));
4617     ret = GST_FLOW_ERROR;
4618     goto exit;
4619   }
4620 no_tracks:
4621   {
4622     GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL),
4623         ("No Tracks element found"));
4624     ret = GST_FLOW_ERROR;
4625     goto exit;
4626   }
4627 invalid_header:
4628   {
4629     GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Invalid header"));
4630     ret = GST_FLOW_ERROR;
4631     goto exit;
4632   }
4633 seek_failed:
4634   {
4635     GST_ELEMENT_ERROR (demux, STREAM, DEMUX, (NULL), ("Failed to seek"));
4636     ret = GST_FLOW_ERROR;
4637     goto exit;
4638   }
4639 }
4640
4641 static void
4642 gst_matroska_demux_loop (GstPad * pad)
4643 {
4644   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (GST_PAD_PARENT (pad));
4645   GstFlowReturn ret;
4646   guint32 id;
4647   guint64 length;
4648   guint needed;
4649
4650   /* If we have to close a segment, send a new segment to do this now */
4651   if (G_LIKELY (demux->common.state == GST_MATROSKA_READ_STATE_DATA)) {
4652     if (G_UNLIKELY (demux->new_segment)) {
4653       gst_matroska_demux_send_event (demux, demux->new_segment);
4654       demux->new_segment = NULL;
4655     }
4656   }
4657
4658   ret = gst_matroska_read_common_peek_id_length_pull (&demux->common,
4659       GST_ELEMENT_CAST (demux), &id, &length, &needed);
4660   if (ret == GST_FLOW_EOS) {
4661     goto eos;
4662   } else if (ret == GST_FLOW_FLUSHING) {
4663     goto pause;
4664   } else if (ret != GST_FLOW_OK) {
4665     ret = gst_matroska_demux_check_parse_error (demux);
4666
4667     /* Only handle EOS as no error if we're outside the segment already */
4668     if (ret == GST_FLOW_EOS && (demux->common.ebml_segment_length != G_MAXUINT64
4669             && demux->common.offset >=
4670             demux->common.ebml_segment_start +
4671             demux->common.ebml_segment_length))
4672       goto eos;
4673     else if (ret != GST_FLOW_OK)
4674       goto pause;
4675     else
4676       return;
4677   }
4678
4679   GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
4680       "size %" G_GUINT64_FORMAT ", needed %d", demux->common.offset, id,
4681       length, needed);
4682
4683   ret = gst_matroska_demux_parse_id (demux, id, length, needed);
4684   if (ret == GST_FLOW_EOS)
4685     goto eos;
4686   if (ret != GST_FLOW_OK)
4687     goto pause;
4688
4689   /* check if we're at the end of a configured segment */
4690   if (G_LIKELY (demux->common.src->len)) {
4691     guint i;
4692
4693     g_assert (demux->common.num_streams == demux->common.src->len);
4694     for (i = 0; i < demux->common.src->len; i++) {
4695       GstMatroskaTrackContext *context = g_ptr_array_index (demux->common.src,
4696           i);
4697       GST_DEBUG_OBJECT (context->pad, "pos %" GST_TIME_FORMAT,
4698           GST_TIME_ARGS (context->pos));
4699       if (context->eos == FALSE)
4700         goto next;
4701     }
4702
4703     GST_INFO_OBJECT (demux, "All streams are EOS");
4704     ret = GST_FLOW_EOS;
4705     goto eos;
4706   }
4707
4708 next:
4709   if (G_UNLIKELY (demux->cached_length == G_MAXUINT64 ||
4710           demux->common.offset >= demux->cached_length)) {
4711     demux->cached_length = gst_matroska_read_common_get_length (&demux->common);
4712     if (demux->common.offset == demux->cached_length) {
4713       GST_LOG_OBJECT (demux, "Reached end of stream");
4714       ret = GST_FLOW_EOS;
4715       goto eos;
4716     }
4717   }
4718
4719   return;
4720
4721   /* ERRORS */
4722 eos:
4723   {
4724     if (demux->common.segment.rate < 0.0) {
4725       ret = gst_matroska_demux_seek_to_previous_keyframe (demux);
4726       if (ret == GST_FLOW_OK)
4727         return;
4728     }
4729     /* fall-through */
4730   }
4731 pause:
4732   {
4733     const gchar *reason = gst_flow_get_name (ret);
4734     gboolean push_eos = FALSE;
4735
4736     GST_LOG_OBJECT (demux, "pausing task, reason %s", reason);
4737     gst_pad_pause_task (demux->common.sinkpad);
4738
4739     if (ret == GST_FLOW_EOS) {
4740       /* perform EOS logic */
4741
4742       /* If we were in the headers, make sure we send no-more-pads.
4743          This will ensure decodebin does not get stuck thinking
4744          the chain is not complete yet, and waiting indefinitely. */
4745       if (G_UNLIKELY (demux->common.state == GST_MATROSKA_READ_STATE_HEADER)) {
4746         if (demux->common.src->len == 0) {
4747           GST_ELEMENT_ERROR (demux, STREAM, FAILED, (NULL),
4748               ("No pads created"));
4749         } else {
4750           GST_ELEMENT_WARNING (demux, STREAM, DEMUX, (NULL),
4751               ("Failed to finish reading headers"));
4752         }
4753         gst_element_no_more_pads (GST_ELEMENT (demux));
4754       }
4755
4756       if (demux->common.segment.flags & GST_SEEK_FLAG_SEGMENT) {
4757         GstEvent *event;
4758         GstMessage *msg;
4759         gint64 stop;
4760
4761         /* for segment playback we need to post when (in stream time)
4762          * we stopped, this is either stop (when set) or the duration. */
4763         if ((stop = demux->common.segment.stop) == -1)
4764           stop = demux->last_stop_end;
4765
4766         GST_LOG_OBJECT (demux, "Sending segment done, at end of segment");
4767         msg = gst_message_new_segment_done (GST_OBJECT (demux), GST_FORMAT_TIME,
4768             stop);
4769         if (demux->segment_seqnum)
4770           gst_message_set_seqnum (msg, demux->segment_seqnum);
4771         gst_element_post_message (GST_ELEMENT (demux), msg);
4772
4773         event = gst_event_new_segment_done (GST_FORMAT_TIME, stop);
4774         if (demux->segment_seqnum)
4775           gst_event_set_seqnum (event, demux->segment_seqnum);
4776         gst_matroska_demux_send_event (demux, event);
4777       } else {
4778         push_eos = TRUE;
4779       }
4780     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
4781       /* for fatal errors we post an error message */
4782       GST_ELEMENT_FLOW_ERROR (demux, ret);
4783       push_eos = TRUE;
4784     }
4785     if (push_eos) {
4786       GstEvent *event;
4787
4788       /* send EOS, and prevent hanging if no streams yet */
4789       GST_LOG_OBJECT (demux, "Sending EOS, at end of stream");
4790       event = gst_event_new_eos ();
4791       if (demux->segment_seqnum)
4792         gst_event_set_seqnum (event, demux->segment_seqnum);
4793       if (!gst_matroska_demux_send_event (demux, event) &&
4794           (ret == GST_FLOW_EOS)) {
4795         GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
4796             (NULL), ("got eos but no streams (yet)"));
4797       }
4798     }
4799     return;
4800   }
4801 }
4802
4803 /*
4804  * Create and push a flushing seek event upstream
4805  */
4806 static gboolean
4807 perform_seek_to_offset (GstMatroskaDemux * demux, gdouble rate, guint64 offset,
4808     guint32 seqnum, GstSeekFlags flags)
4809 {
4810   GstEvent *event;
4811   gboolean res = 0;
4812
4813   GST_DEBUG_OBJECT (demux, "Seeking to %" G_GUINT64_FORMAT, offset);
4814
4815   event =
4816       gst_event_new_seek (rate, GST_FORMAT_BYTES,
4817       flags | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
4818       GST_SEEK_TYPE_SET, offset, GST_SEEK_TYPE_NONE, -1);
4819   gst_event_set_seqnum (event, seqnum);
4820
4821   res = gst_pad_push_event (demux->common.sinkpad, event);
4822
4823   /* segment event will update offset */
4824   return res;
4825 }
4826
4827 static GstFlowReturn
4828 gst_matroska_demux_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
4829 {
4830   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
4831   guint available;
4832   GstFlowReturn ret = GST_FLOW_OK;
4833   guint needed = 0;
4834   guint32 id;
4835   guint64 length;
4836
4837   if (G_UNLIKELY (GST_BUFFER_IS_DISCONT (buffer))) {
4838     GST_DEBUG_OBJECT (demux, "got DISCONT");
4839     gst_adapter_clear (demux->common.adapter);
4840     GST_OBJECT_LOCK (demux);
4841     gst_matroska_read_common_reset_streams (&demux->common,
4842         GST_CLOCK_TIME_NONE, FALSE);
4843     GST_OBJECT_UNLOCK (demux);
4844   }
4845
4846   gst_adapter_push (demux->common.adapter, buffer);
4847   buffer = NULL;
4848
4849 next:
4850   available = gst_adapter_available (demux->common.adapter);
4851
4852   ret = gst_matroska_read_common_peek_id_length_push (&demux->common,
4853       GST_ELEMENT_CAST (demux), &id, &length, &needed);
4854   if (G_UNLIKELY (ret != GST_FLOW_OK && ret != GST_FLOW_EOS)) {
4855     if (demux->common.ebml_segment_length != G_MAXUINT64
4856         && demux->common.offset >=
4857         demux->common.ebml_segment_start + demux->common.ebml_segment_length) {
4858       return GST_FLOW_OK;
4859     } else {
4860       gint64 bytes_scanned;
4861       if (demux->common.start_resync_offset == -1) {
4862         demux->common.start_resync_offset = demux->common.offset;
4863         demux->common.state_to_restore = demux->common.state;
4864       }
4865       bytes_scanned = demux->common.offset - demux->common.start_resync_offset;
4866       if (bytes_scanned <= INVALID_DATA_THRESHOLD) {
4867         GST_WARNING_OBJECT (demux,
4868             "parse error, looking for next cluster, actual offset %"
4869             G_GUINT64_FORMAT ", start resync offset %" G_GUINT64_FORMAT,
4870             demux->common.offset, demux->common.start_resync_offset);
4871         demux->common.state = GST_MATROSKA_READ_STATE_SCANNING;
4872         ret = GST_FLOW_OK;
4873       } else {
4874         GST_WARNING_OBJECT (demux,
4875             "unrecoverable parse error, next cluster not found and threshold "
4876             "exceeded, bytes scanned %" G_GINT64_FORMAT, bytes_scanned);
4877         return ret;
4878       }
4879     }
4880   }
4881
4882   GST_LOG_OBJECT (demux, "Offset %" G_GUINT64_FORMAT ", Element id 0x%x, "
4883       "size %" G_GUINT64_FORMAT ", needed %d, available %d",
4884       demux->common.offset, id, length, needed, available);
4885
4886   if (needed > available)
4887     return GST_FLOW_OK;
4888
4889   ret = gst_matroska_demux_parse_id (demux, id, length, needed);
4890   if (ret == GST_FLOW_EOS) {
4891     /* need more data */
4892     return GST_FLOW_OK;
4893   } else if (ret != GST_FLOW_OK) {
4894     return ret;
4895   } else
4896     goto next;
4897 }
4898
4899 static gboolean
4900 gst_matroska_demux_handle_sink_event (GstPad * pad, GstObject * parent,
4901     GstEvent * event)
4902 {
4903   gboolean res = TRUE;
4904   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
4905
4906   GST_DEBUG_OBJECT (demux,
4907       "have event type %s: %p on sink pad", GST_EVENT_TYPE_NAME (event), event);
4908
4909   switch (GST_EVENT_TYPE (event)) {
4910     case GST_EVENT_SEGMENT:
4911     {
4912       const GstSegment *segment;
4913
4914       /* some debug output */
4915       gst_event_parse_segment (event, &segment);
4916       /* FIXME: do we need to update segment base here (like accum in 0.10)? */
4917       GST_DEBUG_OBJECT (demux,
4918           "received format %d segment %" GST_SEGMENT_FORMAT, segment->format,
4919           segment);
4920
4921       if (demux->common.state < GST_MATROSKA_READ_STATE_DATA) {
4922         GST_DEBUG_OBJECT (demux, "still starting");
4923         goto exit;
4924       }
4925
4926       /* we only expect a BYTE segment, e.g. following a seek */
4927       if (segment->format != GST_FORMAT_BYTES) {
4928         GST_DEBUG_OBJECT (demux, "unsupported segment format, ignoring");
4929         goto exit;
4930       }
4931
4932       GST_DEBUG_OBJECT (demux, "clearing segment state");
4933       GST_OBJECT_LOCK (demux);
4934       /* clear current segment leftover */
4935       gst_adapter_clear (demux->common.adapter);
4936       /* and some streaming setup */
4937       demux->common.offset = segment->start;
4938       /* accumulate base based on current position */
4939       if (GST_CLOCK_TIME_IS_VALID (demux->common.segment.position))
4940         demux->common.segment.base +=
4941             (MAX (demux->common.segment.position, demux->stream_start_time)
4942             - demux->stream_start_time) / fabs (demux->common.segment.rate);
4943       /* do not know where we are;
4944        * need to come across a cluster and generate segment */
4945       demux->common.segment.position = GST_CLOCK_TIME_NONE;
4946       demux->cluster_time = GST_CLOCK_TIME_NONE;
4947       demux->cluster_offset = 0;
4948       demux->need_segment = TRUE;
4949       demux->segment_seqnum = gst_event_get_seqnum (event);
4950       /* but keep some of the upstream segment */
4951       demux->common.segment.rate = segment->rate;
4952       demux->common.segment.flags = segment->flags;
4953       /* also check if need to keep some of the requested seek position */
4954       if (demux->seek_offset == segment->start) {
4955         GST_DEBUG_OBJECT (demux, "position matches requested seek");
4956         demux->common.segment.position = demux->requested_seek_time;
4957       } else {
4958         GST_DEBUG_OBJECT (demux, "unexpected segment position");
4959       }
4960       demux->requested_seek_time = GST_CLOCK_TIME_NONE;
4961       demux->seek_offset = -1;
4962       GST_OBJECT_UNLOCK (demux);
4963     exit:
4964       /* chain will send initial segment after pads have been added,
4965        * or otherwise come up with one */
4966       GST_DEBUG_OBJECT (demux, "eating event");
4967       gst_event_unref (event);
4968       res = TRUE;
4969       break;
4970     }
4971     case GST_EVENT_EOS:
4972     {
4973       if (demux->common.state != GST_MATROSKA_READ_STATE_DATA
4974           && demux->common.state != GST_MATROSKA_READ_STATE_SCANNING) {
4975         gst_event_unref (event);
4976         GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
4977             (NULL), ("got eos and didn't receive a complete header object"));
4978       } else if (demux->common.num_streams == 0) {
4979         GST_ELEMENT_ERROR (demux, STREAM, DEMUX,
4980             (NULL), ("got eos but no streams (yet)"));
4981       } else {
4982         gst_matroska_demux_send_event (demux, event);
4983       }
4984       break;
4985     }
4986     case GST_EVENT_FLUSH_STOP:
4987     {
4988       guint64 dur;
4989
4990       gst_adapter_clear (demux->common.adapter);
4991       GST_OBJECT_LOCK (demux);
4992       gst_matroska_read_common_reset_streams (&demux->common,
4993           GST_CLOCK_TIME_NONE, TRUE);
4994       gst_flow_combiner_reset (demux->flowcombiner);
4995       dur = demux->common.segment.duration;
4996       gst_segment_init (&demux->common.segment, GST_FORMAT_TIME);
4997       demux->common.segment.duration = dur;
4998       demux->cluster_time = GST_CLOCK_TIME_NONE;
4999       demux->cluster_offset = 0;
5000       GST_OBJECT_UNLOCK (demux);
5001       /* fall-through */
5002     }
5003     default:
5004       res = gst_pad_event_default (pad, parent, event);
5005       break;
5006   }
5007
5008   return res;
5009 }
5010
5011 static gboolean
5012 gst_matroska_demux_sink_activate (GstPad * sinkpad, GstObject * parent)
5013 {
5014   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (parent);
5015   GstQuery *query;
5016   gboolean pull_mode = FALSE;
5017
5018   query = gst_query_new_scheduling ();
5019
5020   if (gst_pad_peer_query (sinkpad, query))
5021     pull_mode = gst_query_has_scheduling_mode_with_flags (query,
5022         GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
5023
5024   gst_query_unref (query);
5025
5026   if (pull_mode) {
5027     GST_DEBUG ("going to pull mode");
5028     demux->streaming = FALSE;
5029     return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
5030   } else {
5031     GST_DEBUG ("going to push (streaming) mode");
5032     demux->streaming = TRUE;
5033     return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
5034   }
5035 }
5036
5037 static gboolean
5038 gst_matroska_demux_sink_activate_mode (GstPad * sinkpad, GstObject * parent,
5039     GstPadMode mode, gboolean active)
5040 {
5041   switch (mode) {
5042     case GST_PAD_MODE_PULL:
5043       if (active) {
5044         /* if we have a scheduler we can start the task */
5045         gst_pad_start_task (sinkpad, (GstTaskFunction) gst_matroska_demux_loop,
5046             sinkpad, NULL);
5047       } else {
5048         gst_pad_stop_task (sinkpad);
5049       }
5050       return TRUE;
5051     case GST_PAD_MODE_PUSH:
5052       return TRUE;
5053     default:
5054       return FALSE;
5055   }
5056 }
5057
5058 static GstCaps *
5059 gst_matroska_demux_video_caps (GstMatroskaTrackVideoContext *
5060     videocontext, const gchar * codec_id, guint8 * data, guint size,
5061     gchar ** codec_name, guint32 * riff_fourcc)
5062 {
5063   GstMatroskaTrackContext *context = (GstMatroskaTrackContext *) videocontext;
5064   GstCaps *caps = NULL;
5065
5066   g_assert (videocontext != NULL);
5067   g_assert (codec_name != NULL);
5068
5069   if (riff_fourcc)
5070     *riff_fourcc = 0;
5071
5072   /* TODO: check if we have all codec types from matroska-ids.h
5073    *       check if we have to do more special things with codec_private
5074    *
5075    * Add support for
5076    *  GST_MATROSKA_CODEC_ID_VIDEO_QUICKTIME
5077    *  GST_MATROSKA_CODEC_ID_VIDEO_SNOW
5078    */
5079
5080   if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC)) {
5081     gst_riff_strf_vids *vids = NULL;
5082
5083     if (data) {
5084       GstBuffer *buf = NULL;
5085
5086       vids = (gst_riff_strf_vids *) data;
5087
5088       /* assure size is big enough */
5089       if (size < 24) {
5090         GST_WARNING ("Too small BITMAPINFOHEADER (%d bytes)", size);
5091         return NULL;
5092       }
5093       if (size < sizeof (gst_riff_strf_vids)) {
5094         vids = g_new (gst_riff_strf_vids, 1);
5095         memcpy (vids, data, size);
5096       }
5097
5098       context->dts_only = TRUE; /* VFW files only store DTS */
5099
5100       /* little-endian -> byte-order */
5101       vids->size = GUINT32_FROM_LE (vids->size);
5102       vids->width = GUINT32_FROM_LE (vids->width);
5103       vids->height = GUINT32_FROM_LE (vids->height);
5104       vids->planes = GUINT16_FROM_LE (vids->planes);
5105       vids->bit_cnt = GUINT16_FROM_LE (vids->bit_cnt);
5106       vids->compression = GUINT32_FROM_LE (vids->compression);
5107       vids->image_size = GUINT32_FROM_LE (vids->image_size);
5108       vids->xpels_meter = GUINT32_FROM_LE (vids->xpels_meter);
5109       vids->ypels_meter = GUINT32_FROM_LE (vids->ypels_meter);
5110       vids->num_colors = GUINT32_FROM_LE (vids->num_colors);
5111       vids->imp_colors = GUINT32_FROM_LE (vids->imp_colors);
5112
5113       if (size > sizeof (gst_riff_strf_vids)) { /* some extra_data */
5114         gsize offset = sizeof (gst_riff_strf_vids);
5115
5116         buf =
5117             gst_buffer_new_wrapped (g_memdup ((guint8 *) vids + offset,
5118                 size - offset), size - offset);
5119       }
5120
5121       if (riff_fourcc)
5122         *riff_fourcc = vids->compression;
5123
5124       caps = gst_riff_create_video_caps (vids->compression, NULL, vids,
5125           buf, NULL, codec_name);
5126
5127       if (caps == NULL) {
5128         GST_WARNING ("Unhandled RIFF fourcc %" GST_FOURCC_FORMAT,
5129             GST_FOURCC_ARGS (vids->compression));
5130       } else {
5131         static GstStaticCaps intra_caps = GST_STATIC_CAPS ("image/jpeg; "
5132             "video/x-raw; image/png; video/x-dv; video/x-huffyuv; video/x-ffv; "
5133             "video/x-compressed-yuv");
5134         context->intra_only =
5135             gst_caps_can_intersect (gst_static_caps_get (&intra_caps), caps);
5136       }
5137
5138       if (buf)
5139         gst_buffer_unref (buf);
5140
5141       if (vids != (gst_riff_strf_vids *) data)
5142         g_free (vids);
5143     }
5144   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_UNCOMPRESSED)) {
5145     GstVideoInfo info;
5146     GstVideoFormat format;
5147
5148     gst_video_info_init (&info);
5149     switch (videocontext->fourcc) {
5150       case GST_MAKE_FOURCC ('I', '4', '2', '0'):
5151         format = GST_VIDEO_FORMAT_I420;
5152         break;
5153       case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
5154         format = GST_VIDEO_FORMAT_YUY2;
5155         break;
5156       case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
5157         format = GST_VIDEO_FORMAT_YV12;
5158         break;
5159       case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
5160         format = GST_VIDEO_FORMAT_UYVY;
5161         break;
5162       case GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'):
5163         format = GST_VIDEO_FORMAT_AYUV;
5164         break;
5165       case GST_MAKE_FOURCC ('Y', '8', '0', '0'):
5166       case GST_MAKE_FOURCC ('Y', '8', ' ', ' '):
5167         format = GST_VIDEO_FORMAT_GRAY8;
5168         break;
5169       case GST_MAKE_FOURCC ('R', 'G', 'B', 24):
5170         format = GST_VIDEO_FORMAT_RGB;
5171         break;
5172       case GST_MAKE_FOURCC ('B', 'G', 'R', 24):
5173         format = GST_VIDEO_FORMAT_BGR;
5174         break;
5175       default:
5176         GST_DEBUG ("Unknown fourcc %" GST_FOURCC_FORMAT,
5177             GST_FOURCC_ARGS (videocontext->fourcc));
5178         return NULL;
5179     }
5180
5181     context->intra_only = TRUE;
5182
5183     gst_video_info_set_format (&info, format, videocontext->pixel_width,
5184         videocontext->pixel_height);
5185     caps = gst_video_info_to_caps (&info);
5186     *codec_name = gst_pb_utils_get_codec_description (caps);
5187     context->alignment = 32;
5188   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_SP)) {
5189     caps = gst_caps_new_simple ("video/x-divx",
5190         "divxversion", G_TYPE_INT, 4, NULL);
5191     *codec_name = g_strdup ("MPEG-4 simple profile");
5192   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP) ||
5193       !strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_AP)) {
5194     caps = gst_caps_new_simple ("video/mpeg",
5195         "mpegversion", G_TYPE_INT, 4,
5196         "systemstream", G_TYPE_BOOLEAN, FALSE, NULL);
5197     if (data) {
5198       GstBuffer *priv;
5199
5200       priv = gst_buffer_new_wrapped (g_memdup (data, size), size);
5201       gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
5202       gst_buffer_unref (priv);
5203
5204       gst_codec_utils_mpeg4video_caps_set_level_and_profile (caps, data, size);
5205     }
5206     if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP))
5207       *codec_name = g_strdup ("MPEG-4 advanced simple profile");
5208     else
5209       *codec_name = g_strdup ("MPEG-4 advanced profile");
5210   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MSMPEG4V3)) {
5211 #if 0
5212     caps = gst_caps_new_full (gst_structure_new ("video/x-divx",
5213             "divxversion", G_TYPE_INT, 3, NULL),
5214         gst_structure_new ("video/x-msmpeg",
5215             "msmpegversion", G_TYPE_INT, 43, NULL), NULL);
5216 #endif
5217     caps = gst_caps_new_simple ("video/x-msmpeg",
5218         "msmpegversion", G_TYPE_INT, 43, NULL);
5219     *codec_name = g_strdup ("Microsoft MPEG-4 v.3");
5220   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG1) ||
5221       !strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG2)) {
5222     gint mpegversion;
5223
5224     if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG1))
5225       mpegversion = 1;
5226     else
5227       mpegversion = 2;
5228
5229     caps = gst_caps_new_simple ("video/mpeg",
5230         "systemstream", G_TYPE_BOOLEAN, FALSE,
5231         "mpegversion", G_TYPE_INT, mpegversion, NULL);
5232     *codec_name = g_strdup_printf ("MPEG-%d video", mpegversion);
5233     context->postprocess_frame = gst_matroska_demux_add_mpeg_seq_header;
5234   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MJPEG)) {
5235     caps = gst_caps_new_empty_simple ("image/jpeg");
5236     *codec_name = g_strdup ("Motion-JPEG");
5237     context->intra_only = TRUE;
5238   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_AVC)) {
5239     caps = gst_caps_new_empty_simple ("video/x-h264");
5240     if (data) {
5241       GstBuffer *priv;
5242
5243       /* First byte is the version, second is the profile indication, and third
5244        * is the 5 contraint_set_flags and 3 reserved bits. Fourth byte is the
5245        * level indication. */
5246       gst_codec_utils_h264_caps_set_level_and_profile (caps, data + 1,
5247           size - 1);
5248
5249       priv = gst_buffer_new_wrapped (g_memdup (data, size), size);
5250       gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
5251       gst_buffer_unref (priv);
5252
5253       gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "avc",
5254           "alignment", G_TYPE_STRING, "au", NULL);
5255     } else {
5256       GST_WARNING ("No codec data found, assuming output is byte-stream");
5257       gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "byte-stream",
5258           NULL);
5259     }
5260     *codec_name = g_strdup ("H264");
5261   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_MPEGH_HEVC)) {
5262     caps = gst_caps_new_empty_simple ("video/x-h265");
5263     if (data) {
5264       GstBuffer *priv;
5265
5266       gst_codec_utils_h265_caps_set_level_tier_and_profile (caps, data + 1,
5267           size - 1);
5268
5269       priv = gst_buffer_new_wrapped (g_memdup (data, size), size);
5270       gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
5271       gst_buffer_unref (priv);
5272
5273       gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "hvc1",
5274           "alignment", G_TYPE_STRING, "au", NULL);
5275     } else {
5276       GST_WARNING ("No codec data found, assuming output is byte-stream");
5277       gst_caps_set_simple (caps, "stream-format", G_TYPE_STRING, "byte-stream",
5278           NULL);
5279     }
5280     *codec_name = g_strdup ("HEVC");
5281   } else if ((!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO1)) ||
5282       (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO2)) ||
5283       (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO3)) ||
5284       (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO4))) {
5285     gint rmversion = -1;
5286
5287     if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO1))
5288       rmversion = 1;
5289     else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO2))
5290       rmversion = 2;
5291     else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO3))
5292       rmversion = 3;
5293     else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO4))
5294       rmversion = 4;
5295
5296     caps = gst_caps_new_simple ("video/x-pn-realvideo",
5297         "rmversion", G_TYPE_INT, rmversion, NULL);
5298     GST_DEBUG ("data:%p, size:0x%x", data, size);
5299     /* We need to extract the extradata ! */
5300     if (data && (size >= 0x22)) {
5301       GstBuffer *priv;
5302       guint rformat;
5303       guint subformat;
5304
5305       subformat = GST_READ_UINT32_BE (data + 0x1a);
5306       rformat = GST_READ_UINT32_BE (data + 0x1e);
5307
5308       priv =
5309           gst_buffer_new_wrapped (g_memdup (data + 0x1a, size - 0x1a),
5310           size - 0x1a);
5311       gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, "format",
5312           G_TYPE_INT, rformat, "subformat", G_TYPE_INT, subformat, NULL);
5313       gst_buffer_unref (priv);
5314
5315     }
5316     *codec_name = g_strdup_printf ("RealVideo %d.0", rmversion);
5317   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_THEORA)) {
5318     caps = gst_caps_new_empty_simple ("video/x-theora");
5319     context->stream_headers =
5320         gst_matroska_parse_xiph_stream_headers (context->codec_priv,
5321         context->codec_priv_size);
5322     /* FIXME: mark stream as broken and skip if there are no stream headers */
5323     context->send_stream_headers = TRUE;
5324   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_DIRAC)) {
5325     caps = gst_caps_new_empty_simple ("video/x-dirac");
5326     *codec_name = g_strdup_printf ("Dirac");
5327   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP8)) {
5328     caps = gst_caps_new_empty_simple ("video/x-vp8");
5329     *codec_name = g_strdup_printf ("On2 VP8");
5330   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_VP9)) {
5331     caps = gst_caps_new_empty_simple ("video/x-vp9");
5332     *codec_name = g_strdup_printf ("On2 VP9");
5333   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_VIDEO_PRORES)) {
5334     guint32 fourcc;
5335     const gchar *variant, *variant_descr = "";
5336
5337     /* Expect a fourcc in the codec private data */
5338     if (!data || size < 4) {
5339       GST_WARNING ("No or too small PRORESS fourcc (%d bytes)", size);
5340       return NULL;
5341     }
5342
5343     fourcc = GST_STR_FOURCC (data);
5344     switch (fourcc) {
5345       case GST_MAKE_FOURCC ('a', 'p', 'c', 's'):
5346         variant_descr = " 4:2:2 LT";
5347         variant = "lt";
5348         break;
5349       case GST_MAKE_FOURCC ('a', 'p', 'c', 'h'):
5350         variant = "hq";
5351         variant_descr = " 4:2:2 HQ";
5352         break;
5353       case GST_MAKE_FOURCC ('a', 'p', '4', 'h'):
5354         variant = "4444";
5355         variant_descr = " 4:4:4:4";
5356         break;
5357       case GST_MAKE_FOURCC ('a', 'p', 'c', 'o'):
5358         variant = "proxy";
5359         variant_descr = " 4:2:2 Proxy";
5360         break;
5361       case GST_MAKE_FOURCC ('a', 'p', 'c', 'n'):
5362       default:
5363         variant = "standard";
5364         variant_descr = " 4:2:2 SD";
5365         break;
5366     }
5367
5368     GST_LOG ("Prores video, codec fourcc %" GST_FOURCC_FORMAT,
5369         GST_FOURCC_ARGS (fourcc));
5370
5371     caps = gst_caps_new_simple ("video/x-prores",
5372         "format", G_TYPE_STRING, variant, NULL);
5373     *codec_name = g_strdup_printf ("Apple ProRes%s", variant_descr);
5374     context->postprocess_frame = gst_matroska_demux_add_prores_header;
5375   } else {
5376     GST_WARNING ("Unknown codec '%s', cannot build Caps", codec_id);
5377     return NULL;
5378   }
5379
5380   if (caps != NULL) {
5381     int i;
5382     GstStructure *structure;
5383
5384     for (i = 0; i < gst_caps_get_size (caps); i++) {
5385       structure = gst_caps_get_structure (caps, i);
5386
5387       /* FIXME: use the real unit here! */
5388       GST_DEBUG ("video size %dx%d, target display size %dx%d (any unit)",
5389           videocontext->pixel_width,
5390           videocontext->pixel_height,
5391           videocontext->display_width, videocontext->display_height);
5392
5393       /* pixel width and height are the w and h of the video in pixels */
5394       if (videocontext->pixel_width > 0 && videocontext->pixel_height > 0) {
5395         gint w = videocontext->pixel_width;
5396         gint h = videocontext->pixel_height;
5397
5398         gst_structure_set (structure,
5399             "width", G_TYPE_INT, w, "height", G_TYPE_INT, h, NULL);
5400       }
5401
5402       if (videocontext->display_width > 0 || videocontext->display_height > 0) {
5403         int n, d;
5404
5405         if (videocontext->display_width <= 0)
5406           videocontext->display_width = videocontext->pixel_width;
5407         if (videocontext->display_height <= 0)
5408           videocontext->display_height = videocontext->pixel_height;
5409
5410         /* calculate the pixel aspect ratio using the display and pixel w/h */
5411         n = videocontext->display_width * videocontext->pixel_height;
5412         d = videocontext->display_height * videocontext->pixel_width;
5413         GST_DEBUG ("setting PAR to %d/%d", n, d);
5414         gst_structure_set (structure, "pixel-aspect-ratio",
5415             GST_TYPE_FRACTION,
5416             videocontext->display_width * videocontext->pixel_height,
5417             videocontext->display_height * videocontext->pixel_width, NULL);
5418       }
5419
5420       if (videocontext->default_fps > 0.0) {
5421         gint fps_n, fps_d;
5422
5423         gst_util_double_to_fraction (videocontext->default_fps, &fps_n, &fps_d);
5424
5425         GST_DEBUG ("using default fps %d/%d", fps_n, fps_d);
5426
5427         gst_structure_set (structure, "framerate", GST_TYPE_FRACTION, fps_n,
5428             fps_d, NULL);
5429       } else if (context->default_duration > 0) {
5430         int fps_n, fps_d;
5431
5432         gst_video_guess_framerate (context->default_duration, &fps_n, &fps_d);
5433
5434         GST_INFO ("using default duration %" G_GUINT64_FORMAT
5435             " framerate %d/%d", context->default_duration, fps_n, fps_d);
5436
5437         gst_structure_set (structure, "framerate", GST_TYPE_FRACTION,
5438             fps_n, fps_d, NULL);
5439       } else {
5440         gst_structure_set (structure, "framerate", GST_TYPE_FRACTION,
5441             0, 1, NULL);
5442       }
5443
5444       if (videocontext->parent.flags & GST_MATROSKA_VIDEOTRACK_INTERLACED)
5445         gst_structure_set (structure, "interlace-mode", G_TYPE_STRING,
5446             "mixed", NULL);
5447     }
5448     if (videocontext->multiview_mode != GST_VIDEO_MULTIVIEW_MODE_NONE) {
5449       if (gst_video_multiview_guess_half_aspect (videocontext->multiview_mode,
5450               videocontext->pixel_width, videocontext->pixel_height,
5451               videocontext->display_width * videocontext->pixel_height,
5452               videocontext->display_height * videocontext->pixel_width)) {
5453         videocontext->multiview_flags |= GST_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT;
5454       }
5455       gst_caps_set_simple (caps,
5456           "multiview-mode", G_TYPE_STRING,
5457           gst_video_multiview_mode_to_caps_string
5458           (videocontext->multiview_mode), "multiview-flags",
5459           GST_TYPE_VIDEO_MULTIVIEW_FLAGSET, videocontext->multiview_flags,
5460           GST_FLAG_SET_MASK_EXACT, NULL);
5461     }
5462
5463     caps = gst_caps_simplify (caps);
5464   }
5465
5466   return caps;
5467 }
5468
5469 /*
5470  * Some AAC specific code... *sigh*
5471  * FIXME: maybe we should use '15' and code the sample rate explicitly
5472  * if the sample rate doesn't match the predefined rates exactly? (tpm)
5473  */
5474
5475 static gint
5476 aac_rate_idx (gint rate)
5477 {
5478   if (92017 <= rate)
5479     return 0;
5480   else if (75132 <= rate)
5481     return 1;
5482   else if (55426 <= rate)
5483     return 2;
5484   else if (46009 <= rate)
5485     return 3;
5486   else if (37566 <= rate)
5487     return 4;
5488   else if (27713 <= rate)
5489     return 5;
5490   else if (23004 <= rate)
5491     return 6;
5492   else if (18783 <= rate)
5493     return 7;
5494   else if (13856 <= rate)
5495     return 8;
5496   else if (11502 <= rate)
5497     return 9;
5498   else if (9391 <= rate)
5499     return 10;
5500   else
5501     return 11;
5502 }
5503
5504 static gint
5505 aac_profile_idx (const gchar * codec_id)
5506 {
5507   gint profile;
5508
5509   if (strlen (codec_id) <= 12)
5510     profile = 3;
5511   else if (!strncmp (&codec_id[12], "MAIN", 4))
5512     profile = 0;
5513   else if (!strncmp (&codec_id[12], "LC", 2))
5514     profile = 1;
5515   else if (!strncmp (&codec_id[12], "SSR", 3))
5516     profile = 2;
5517   else
5518     profile = 3;
5519
5520   return profile;
5521 }
5522
5523 static guint
5524 round_up_pow2 (guint n)
5525 {
5526   n = n - 1;
5527   n = n | (n >> 1);
5528   n = n | (n >> 2);
5529   n = n | (n >> 4);
5530   n = n | (n >> 8);
5531   n = n | (n >> 16);
5532   return n + 1;
5533 }
5534
5535 #define AAC_SYNC_EXTENSION_TYPE 0x02b7
5536
5537 static GstCaps *
5538 gst_matroska_demux_audio_caps (GstMatroskaTrackAudioContext *
5539     audiocontext, const gchar * codec_id, guint8 * data, guint size,
5540     gchar ** codec_name, guint16 * riff_audio_fmt)
5541 {
5542   GstMatroskaTrackContext *context = (GstMatroskaTrackContext *) audiocontext;
5543   GstCaps *caps = NULL;
5544
5545   g_assert (audiocontext != NULL);
5546   g_assert (codec_name != NULL);
5547
5548   if (riff_audio_fmt)
5549     *riff_audio_fmt = 0;
5550
5551   /* TODO: check if we have all codec types from matroska-ids.h
5552    *       check if we have to do more special things with codec_private
5553    *       check if we need bitdepth in different places too
5554    *       implement channel position magic
5555    * Add support for:
5556    *  GST_MATROSKA_CODEC_ID_AUDIO_AC3_BSID9
5557    *  GST_MATROSKA_CODEC_ID_AUDIO_AC3_BSID10
5558    *  GST_MATROSKA_CODEC_ID_AUDIO_QUICKTIME_QDMC
5559    *  GST_MATROSKA_CODEC_ID_AUDIO_QUICKTIME_QDM2
5560    */
5561
5562   if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L1) ||
5563       !strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L2) ||
5564       !strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L3)) {
5565     gint layer;
5566
5567     if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L1))
5568       layer = 1;
5569     else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L2))
5570       layer = 2;
5571     else
5572       layer = 3;
5573
5574     caps = gst_caps_new_simple ("audio/mpeg",
5575         "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, layer, NULL);
5576     *codec_name = g_strdup_printf ("MPEG-1 layer %d", layer);
5577   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE) ||
5578       !strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_LE)) {
5579     gboolean sign;
5580     gint endianness;
5581     GstAudioFormat format;
5582
5583     sign = (audiocontext->bitdepth != 8);
5584     if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE))
5585       endianness = G_BIG_ENDIAN;
5586     else
5587       endianness = G_LITTLE_ENDIAN;
5588
5589     format = gst_audio_format_build_integer (sign, endianness,
5590         audiocontext->bitdepth, audiocontext->bitdepth);
5591
5592     /* FIXME: Channel mask and reordering */
5593     caps = gst_caps_new_simple ("audio/x-raw",
5594         "format", G_TYPE_STRING, gst_audio_format_to_string (format),
5595         "layout", G_TYPE_STRING, "interleaved",
5596         "channel-mask", GST_TYPE_BITMASK,
5597         gst_audio_channel_get_fallback_mask (audiocontext->channels), NULL);
5598
5599     *codec_name = g_strdup_printf ("Raw %d-bit PCM audio",
5600         audiocontext->bitdepth);
5601     context->alignment = GST_ROUND_UP_8 (audiocontext->bitdepth) / 8;
5602     context->alignment = round_up_pow2 (context->alignment);
5603   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_PCM_FLOAT)) {
5604     const gchar *format;
5605     if (audiocontext->bitdepth == 32)
5606       format = "F32LE";
5607     else
5608       format = "F64LE";
5609     /* FIXME: Channel mask and reordering */
5610     caps = gst_caps_new_simple ("audio/x-raw",
5611         "format", G_TYPE_STRING, format,
5612         "layout", G_TYPE_STRING, "interleaved",
5613         "channel-mask", GST_TYPE_BITMASK,
5614         gst_audio_channel_get_fallback_mask (audiocontext->channels), NULL);
5615     *codec_name = g_strdup_printf ("Raw %d-bit floating-point audio",
5616         audiocontext->bitdepth);
5617     context->alignment = audiocontext->bitdepth / 8;
5618     context->alignment = round_up_pow2 (context->alignment);
5619   } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AC3,
5620           strlen (GST_MATROSKA_CODEC_ID_AUDIO_AC3))) {
5621     caps = gst_caps_new_simple ("audio/x-ac3",
5622         "framed", G_TYPE_BOOLEAN, TRUE, NULL);
5623     *codec_name = g_strdup ("AC-3 audio");
5624   } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_EAC3,
5625           strlen (GST_MATROSKA_CODEC_ID_AUDIO_EAC3))) {
5626     caps = gst_caps_new_simple ("audio/x-eac3",
5627         "framed", G_TYPE_BOOLEAN, TRUE, NULL);
5628     *codec_name = g_strdup ("E-AC-3 audio");
5629   } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_TRUEHD,
5630           strlen (GST_MATROSKA_CODEC_ID_AUDIO_TRUEHD))) {
5631     caps = gst_caps_new_empty_simple ("audio/x-true-hd");
5632     *codec_name = g_strdup ("Dolby TrueHD");
5633   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_DTS)) {
5634     caps = gst_caps_new_empty_simple ("audio/x-dts");
5635     *codec_name = g_strdup ("DTS audio");
5636   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_VORBIS)) {
5637     caps = gst_caps_new_empty_simple ("audio/x-vorbis");
5638     context->stream_headers =
5639         gst_matroska_parse_xiph_stream_headers (context->codec_priv,
5640         context->codec_priv_size);
5641     /* FIXME: mark stream as broken and skip if there are no stream headers */
5642     context->send_stream_headers = TRUE;
5643   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_FLAC)) {
5644     caps = gst_caps_new_empty_simple ("audio/x-flac");
5645     context->stream_headers =
5646         gst_matroska_parse_flac_stream_headers (context->codec_priv,
5647         context->codec_priv_size);
5648     /* FIXME: mark stream as broken and skip if there are no stream headers */
5649     context->send_stream_headers = TRUE;
5650   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_SPEEX)) {
5651     caps = gst_caps_new_empty_simple ("audio/x-speex");
5652     context->stream_headers =
5653         gst_matroska_parse_speex_stream_headers (context->codec_priv,
5654         context->codec_priv_size);
5655     /* FIXME: mark stream as broken and skip if there are no stream headers */
5656     context->send_stream_headers = TRUE;
5657   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_OPUS)) {
5658     GstBuffer *tmp;
5659
5660     if (context->codec_priv_size >= 19) {
5661       if (audiocontext->samplerate)
5662         GST_WRITE_UINT32_LE ((guint8 *) context->codec_priv + 12,
5663             audiocontext->samplerate);
5664       if (context->codec_delay) {
5665         guint64 delay =
5666             gst_util_uint64_scale_round (context->codec_delay, 48000,
5667             GST_SECOND);
5668         GST_WRITE_UINT16_LE ((guint8 *) context->codec_priv + 10, delay);
5669       }
5670
5671       tmp =
5672           gst_buffer_new_wrapped (g_memdup (context->codec_priv,
5673               context->codec_priv_size), context->codec_priv_size);
5674       caps = gst_codec_utils_opus_create_caps_from_header (tmp, NULL);
5675       gst_buffer_unref (tmp);
5676       *codec_name = g_strdup ("Opus");
5677     } else if (context->codec_priv_size == 0) {
5678       GST_WARNING ("No Opus codec data found, trying to create one");
5679       if (audiocontext->channels <= 2) {
5680         guint8 streams, coupled, channels;
5681         guint32 samplerate;
5682
5683         samplerate =
5684             audiocontext->samplerate == 0 ? 48000 : audiocontext->samplerate;
5685         channels = audiocontext->channels == 0 ? 2 : audiocontext->channels;
5686         if (channels == 1) {
5687           streams = 1;
5688           coupled = 0;
5689         } else {
5690           streams = 1;
5691           coupled = 1;
5692         }
5693
5694         caps =
5695             gst_codec_utils_opus_create_caps (samplerate, channels, 0, streams,
5696             coupled, NULL);
5697         if (caps) {
5698           *codec_name = g_strdup ("Opus");
5699         } else {
5700           GST_WARNING ("Failed to create Opus caps from audio context");
5701         }
5702       } else {
5703         GST_WARNING ("No Opus codec data, and not enough info to create one");
5704       }
5705     } else {
5706       GST_WARNING ("Invalid Opus codec data size (got %" G_GSIZE_FORMAT
5707           ", expected 19)", context->codec_priv_size);
5708     }
5709   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_ACM)) {
5710     gst_riff_strf_auds auds;
5711
5712     if (data && size >= 18) {
5713       GstBuffer *codec_data = NULL;
5714
5715       /* little-endian -> byte-order */
5716       auds.format = GST_READ_UINT16_LE (data);
5717       auds.channels = GST_READ_UINT16_LE (data + 2);
5718       auds.rate = GST_READ_UINT32_LE (data + 4);
5719       auds.av_bps = GST_READ_UINT32_LE (data + 8);
5720       auds.blockalign = GST_READ_UINT16_LE (data + 12);
5721       auds.bits_per_sample = GST_READ_UINT16_LE (data + 16);
5722
5723       /* 18 is the waveformatex size */
5724       if (size > 18) {
5725         codec_data = gst_buffer_new_wrapped_full (GST_MEMORY_FLAG_READONLY,
5726             data + 18, size - 18, 0, size - 18, NULL, NULL);
5727       }
5728
5729       if (riff_audio_fmt)
5730         *riff_audio_fmt = auds.format;
5731
5732       /* FIXME: Handle reorder map */
5733       caps = gst_riff_create_audio_caps (auds.format, NULL, &auds, NULL,
5734           codec_data, codec_name, NULL);
5735       if (codec_data)
5736         gst_buffer_unref (codec_data);
5737
5738       if (caps == NULL) {
5739         GST_WARNING ("Unhandled RIFF audio format 0x%02x", auds.format);
5740       }
5741     } else {
5742       GST_WARNING ("Invalid codec data size (%d expected, got %d)", 18, size);
5743     }
5744   } else if (g_str_has_prefix (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC)) {
5745     GstBuffer *priv = NULL;
5746     gint mpegversion;
5747     gint rate_idx, profile;
5748     guint8 *data = NULL;
5749
5750     /* unspecified AAC profile with opaque private codec data */
5751     if (strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC) == 0) {
5752       if (context->codec_priv_size >= 2) {
5753         guint obj_type, freq_index, explicit_freq_bytes = 0;
5754
5755         codec_id = GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4;
5756         mpegversion = 4;
5757         freq_index = (GST_READ_UINT16_BE (context->codec_priv) & 0x780) >> 7;
5758         obj_type = (GST_READ_UINT16_BE (context->codec_priv) & 0xF800) >> 11;
5759         if (freq_index == 15)
5760           explicit_freq_bytes = 3;
5761         GST_DEBUG ("obj_type = %u, freq_index = %u", obj_type, freq_index);
5762         priv = gst_buffer_new_wrapped (g_memdup (context->codec_priv,
5763                 context->codec_priv_size), context->codec_priv_size);
5764         /* assume SBR if samplerate <= 24kHz */
5765         if (obj_type == 5 || (freq_index >= 6 && freq_index != 15) ||
5766             (context->codec_priv_size == (5 + explicit_freq_bytes))) {
5767           audiocontext->samplerate *= 2;
5768         }
5769       } else {
5770         GST_WARNING ("Opaque A_AAC codec ID, but no codec private data");
5771         /* this is pretty broken;
5772          * maybe we need to make up some default private,
5773          * or maybe ADTS data got dumped in.
5774          * Let's set up some private data now, and check actual data later */
5775         /* just try this and see what happens ... */
5776         codec_id = GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4;
5777         context->postprocess_frame = gst_matroska_demux_check_aac;
5778       }
5779     }
5780
5781     /* make up decoder-specific data if it is not supplied */
5782     if (priv == NULL) {
5783       GstMapInfo map;
5784
5785       priv = gst_buffer_new_allocate (NULL, 5, NULL);
5786       gst_buffer_map (priv, &map, GST_MAP_WRITE);
5787       data = map.data;
5788       rate_idx = aac_rate_idx (audiocontext->samplerate);
5789       profile = aac_profile_idx (codec_id);
5790
5791       data[0] = ((profile + 1) << 3) | ((rate_idx & 0xE) >> 1);
5792       data[1] = ((rate_idx & 0x1) << 7) | (audiocontext->channels << 3);
5793
5794       if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG2,
5795               strlen (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG2))) {
5796         mpegversion = 2;
5797         gst_buffer_unmap (priv, &map);
5798         gst_buffer_set_size (priv, 2);
5799       } else if (!strncmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4,
5800               strlen (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4))) {
5801         mpegversion = 4;
5802
5803         if (g_strrstr (codec_id, "SBR")) {
5804           /* HE-AAC (aka SBR AAC) */
5805           audiocontext->samplerate *= 2;
5806           rate_idx = aac_rate_idx (audiocontext->samplerate);
5807           data[2] = AAC_SYNC_EXTENSION_TYPE >> 3;
5808           data[3] = ((AAC_SYNC_EXTENSION_TYPE & 0x07) << 5) | 5;
5809           data[4] = (1 << 7) | (rate_idx << 3);
5810           gst_buffer_unmap (priv, &map);
5811         } else {
5812           gst_buffer_unmap (priv, &map);
5813           gst_buffer_set_size (priv, 2);
5814         }
5815       } else {
5816         gst_buffer_unmap (priv, &map);
5817         gst_buffer_unref (priv);
5818         priv = NULL;
5819         GST_ERROR ("Unknown AAC profile and no codec private data");
5820       }
5821     }
5822
5823     if (priv) {
5824       caps = gst_caps_new_simple ("audio/mpeg",
5825           "mpegversion", G_TYPE_INT, mpegversion,
5826           "framed", G_TYPE_BOOLEAN, TRUE,
5827           "stream-format", G_TYPE_STRING, "raw", NULL);
5828       gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
5829       if (context->codec_priv && context->codec_priv_size > 0)
5830         gst_codec_utils_aac_caps_set_level_and_profile (caps,
5831             context->codec_priv, context->codec_priv_size);
5832       *codec_name = g_strdup_printf ("MPEG-%d AAC audio", mpegversion);
5833       gst_buffer_unref (priv);
5834     }
5835   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_TTA)) {
5836     caps = gst_caps_new_simple ("audio/x-tta",
5837         "width", G_TYPE_INT, audiocontext->bitdepth, NULL);
5838     *codec_name = g_strdup ("TTA audio");
5839   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_WAVPACK4)) {
5840     caps = gst_caps_new_simple ("audio/x-wavpack",
5841         "width", G_TYPE_INT, audiocontext->bitdepth,
5842         "framed", G_TYPE_BOOLEAN, TRUE, NULL);
5843     *codec_name = g_strdup ("Wavpack audio");
5844     context->postprocess_frame = gst_matroska_demux_add_wvpk_header;
5845     audiocontext->wvpk_block_index = 0;
5846   } else if ((!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_14_4)) ||
5847       (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_28_8)) ||
5848       (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_COOK))) {
5849     gint raversion = -1;
5850
5851     if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_14_4))
5852       raversion = 1;
5853     else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_COOK))
5854       raversion = 8;
5855     else
5856       raversion = 2;
5857
5858     caps = gst_caps_new_simple ("audio/x-pn-realaudio",
5859         "raversion", G_TYPE_INT, raversion, NULL);
5860     /* Extract extra information from caps, mapping varies based on codec */
5861     if (data && (size >= 0x50)) {
5862       GstBuffer *priv;
5863       guint flavor;
5864       guint packet_size;
5865       guint height;
5866       guint leaf_size;
5867       guint sample_width;
5868       guint extra_data_size;
5869
5870       GST_ERROR ("real audio raversion:%d", raversion);
5871       if (raversion == 8) {
5872         /* COOK */
5873         flavor = GST_READ_UINT16_BE (data + 22);
5874         packet_size = GST_READ_UINT32_BE (data + 24);
5875         height = GST_READ_UINT16_BE (data + 40);
5876         leaf_size = GST_READ_UINT16_BE (data + 44);
5877         sample_width = GST_READ_UINT16_BE (data + 58);
5878         extra_data_size = GST_READ_UINT32_BE (data + 74);
5879
5880         GST_ERROR
5881             ("flavor:%d, packet_size:%d, height:%d, leaf_size:%d, sample_width:%d, extra_data_size:%d",
5882             flavor, packet_size, height, leaf_size, sample_width,
5883             extra_data_size);
5884         gst_caps_set_simple (caps, "flavor", G_TYPE_INT, flavor, "packet_size",
5885             G_TYPE_INT, packet_size, "height", G_TYPE_INT, height, "leaf_size",
5886             G_TYPE_INT, leaf_size, "width", G_TYPE_INT, sample_width, NULL);
5887
5888         if ((size - 78) >= extra_data_size) {
5889           priv = gst_buffer_new_wrapped (g_memdup (data + 78, extra_data_size),
5890               extra_data_size);
5891           gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, priv, NULL);
5892           gst_buffer_unref (priv);
5893         }
5894       }
5895     }
5896
5897     *codec_name = g_strdup_printf ("RealAudio %d.0", raversion);
5898   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_SIPR)) {
5899     caps = gst_caps_new_empty_simple ("audio/x-sipro");
5900     *codec_name = g_strdup ("Sipro/ACELP.NET Voice Codec");
5901   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_RALF)) {
5902     caps = gst_caps_new_empty_simple ("audio/x-ralf-mpeg4-generic");
5903     *codec_name = g_strdup ("Real Audio Lossless");
5904   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_AUDIO_REAL_ATRC)) {
5905     caps = gst_caps_new_empty_simple ("audio/x-vnd.sony.atrac3");
5906     *codec_name = g_strdup ("Sony ATRAC3");
5907   } else {
5908     GST_WARNING ("Unknown codec '%s', cannot build Caps", codec_id);
5909     return NULL;
5910   }
5911
5912   if (caps != NULL) {
5913     if (audiocontext->samplerate > 0 && audiocontext->channels > 0) {
5914       gint i;
5915
5916       for (i = 0; i < gst_caps_get_size (caps); i++) {
5917         gst_structure_set (gst_caps_get_structure (caps, i),
5918             "channels", G_TYPE_INT, audiocontext->channels,
5919             "rate", G_TYPE_INT, audiocontext->samplerate, NULL);
5920       }
5921     }
5922
5923     caps = gst_caps_simplify (caps);
5924   }
5925
5926   return caps;
5927 }
5928
5929 static GstCaps *
5930 gst_matroska_demux_subtitle_caps (GstMatroskaTrackSubtitleContext *
5931     subtitlecontext, const gchar * codec_id, gpointer data, guint size)
5932 {
5933   GstCaps *caps = NULL;
5934   GstMatroskaTrackContext *context =
5935       (GstMatroskaTrackContext *) subtitlecontext;
5936
5937   /* for backwards compatibility */
5938   if (!g_ascii_strcasecmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_ASCII))
5939     codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_UTF8;
5940   else if (!g_ascii_strcasecmp (codec_id, "S_SSA"))
5941     codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_SSA;
5942   else if (!g_ascii_strcasecmp (codec_id, "S_ASS"))
5943     codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_ASS;
5944   else if (!g_ascii_strcasecmp (codec_id, "S_USF"))
5945     codec_id = GST_MATROSKA_CODEC_ID_SUBTITLE_USF;
5946
5947   /* TODO: Add GST_MATROSKA_CODEC_ID_SUBTITLE_BMP support
5948    * Check if we have to do something with codec_private */
5949   if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_UTF8)) {
5950     /* well, plain text simply does not have a lot of markup ... */
5951     caps = gst_caps_new_simple ("text/x-raw", "format", G_TYPE_STRING,
5952         "pango-markup", NULL);
5953     context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
5954     subtitlecontext->check_markup = TRUE;
5955   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_SSA)) {
5956     caps = gst_caps_new_empty_simple ("application/x-ssa");
5957     context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
5958     subtitlecontext->check_markup = FALSE;
5959   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_ASS)) {
5960     caps = gst_caps_new_empty_simple ("application/x-ass");
5961     context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
5962     subtitlecontext->check_markup = FALSE;
5963   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_USF)) {
5964     caps = gst_caps_new_empty_simple ("application/x-usf");
5965     context->postprocess_frame = gst_matroska_demux_check_subtitle_buffer;
5966     subtitlecontext->check_markup = FALSE;
5967   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_VOBSUB)) {
5968     caps = gst_caps_new_empty_simple ("subpicture/x-dvd");
5969     ((GstMatroskaTrackContext *) subtitlecontext)->send_dvd_event = TRUE;
5970   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_HDMVPGS)) {
5971     caps = gst_caps_new_empty_simple ("subpicture/x-pgs");
5972   } else if (!strcmp (codec_id, GST_MATROSKA_CODEC_ID_SUBTITLE_KATE)) {
5973     caps = gst_caps_new_empty_simple ("subtitle/x-kate");
5974     context->stream_headers =
5975         gst_matroska_parse_xiph_stream_headers (context->codec_priv,
5976         context->codec_priv_size);
5977     /* FIXME: mark stream as broken and skip if there are no stream headers */
5978     context->send_stream_headers = TRUE;
5979   } else {
5980     GST_DEBUG ("Unknown subtitle stream: codec_id='%s'", codec_id);
5981     caps = gst_caps_new_empty_simple ("application/x-subtitle-unknown");
5982   }
5983
5984   if (data != NULL && size > 0) {
5985     GstBuffer *buf;
5986
5987     buf = gst_buffer_new_wrapped (g_memdup (data, size), size);
5988     gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
5989     gst_buffer_unref (buf);
5990   }
5991
5992   return caps;
5993 }
5994
5995 #if 0
5996 static void
5997 gst_matroska_demux_set_index (GstElement * element, GstIndex * index)
5998 {
5999   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
6000
6001   GST_OBJECT_LOCK (demux);
6002   if (demux->common.element_index)
6003     gst_object_unref (demux->common.element_index);
6004   demux->common.element_index = index ? gst_object_ref (index) : NULL;
6005   GST_OBJECT_UNLOCK (demux);
6006   GST_DEBUG_OBJECT (demux, "Set index %" GST_PTR_FORMAT,
6007       demux->common.element_index);
6008 }
6009
6010 static GstIndex *
6011 gst_matroska_demux_get_index (GstElement * element)
6012 {
6013   GstIndex *result = NULL;
6014   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
6015
6016   GST_OBJECT_LOCK (demux);
6017   if (demux->common.element_index)
6018     result = gst_object_ref (demux->common.element_index);
6019   GST_OBJECT_UNLOCK (demux);
6020
6021   GST_DEBUG_OBJECT (demux, "Returning index %" GST_PTR_FORMAT, result);
6022
6023   return result;
6024 }
6025 #endif
6026
6027 static GstStateChangeReturn
6028 gst_matroska_demux_change_state (GstElement * element,
6029     GstStateChange transition)
6030 {
6031   GstMatroskaDemux *demux = GST_MATROSKA_DEMUX (element);
6032   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
6033
6034   /* handle upwards state changes here */
6035   switch (transition) {
6036     default:
6037       break;
6038   }
6039
6040   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
6041
6042   /* handle downwards state changes */
6043   switch (transition) {
6044     case GST_STATE_CHANGE_PAUSED_TO_READY:
6045       gst_matroska_demux_reset (GST_ELEMENT (demux));
6046       break;
6047     default:
6048       break;
6049   }
6050
6051   return ret;
6052 }
6053
6054 static void
6055 gst_matroska_demux_set_property (GObject * object,
6056     guint prop_id, const GValue * value, GParamSpec * pspec)
6057 {
6058   GstMatroskaDemux *demux;
6059
6060   g_return_if_fail (GST_IS_MATROSKA_DEMUX (object));
6061   demux = GST_MATROSKA_DEMUX (object);
6062
6063   switch (prop_id) {
6064     case PROP_MAX_GAP_TIME:
6065       GST_OBJECT_LOCK (demux);
6066       demux->max_gap_time = g_value_get_uint64 (value);
6067       GST_OBJECT_UNLOCK (demux);
6068       break;
6069     default:
6070       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
6071       break;
6072   }
6073 }
6074
6075 static void
6076 gst_matroska_demux_get_property (GObject * object,
6077     guint prop_id, GValue * value, GParamSpec * pspec)
6078 {
6079   GstMatroskaDemux *demux;
6080
6081   g_return_if_fail (GST_IS_MATROSKA_DEMUX (object));
6082   demux = GST_MATROSKA_DEMUX (object);
6083
6084   switch (prop_id) {
6085     case PROP_MAX_GAP_TIME:
6086       GST_OBJECT_LOCK (demux);
6087       g_value_set_uint64 (value, demux->max_gap_time);
6088       GST_OBJECT_UNLOCK (demux);
6089       break;
6090     default:
6091       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
6092       break;
6093   }
6094 }
6095
6096 gboolean
6097 gst_matroska_demux_plugin_init (GstPlugin * plugin)
6098 {
6099   gst_riff_init ();
6100
6101   /* parser helper separate debug */
6102   GST_DEBUG_CATEGORY_INIT (ebmlread_debug, "ebmlread",
6103       0, "EBML stream helper class");
6104
6105   /* create an elementfactory for the matroska_demux element */
6106   if (!gst_element_register (plugin, "matroskademux",
6107           GST_RANK_PRIMARY, GST_TYPE_MATROSKA_DEMUX))
6108     return FALSE;
6109
6110   return TRUE;
6111 }