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