gst/matroska/matroska-demux.c

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