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