git.sesse.net Git - ffmpeg/blob - libavformat/matroskadec.c

   1 /*
   2  * Matroska file demuxer (no muxer yet)
   3  * Copyright (c) 2003-2004 The ffmpeg Project
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file matroskadec.c
  24  * Matroska file demuxer
  25  * by Ronald Bultje <rbultje@ronald.bitfreak.net>
  26  * with a little help from Moritz Bunkus <moritz@bunkus.org>
  27  * Specs available on the matroska project page:
  28  * http://www.matroska.org/.
  29  */
  30
  31 #include "avformat.h"
  32 /* For codec_get_id(). */
  33 #include "riff.h"
  34 #include "matroska.h"
  35 #include "libavcodec/mpeg4audio.h"
  36 #include "libavutil/intfloat_readwrite.h"
  37 #include "libavutil/lzo.h"
  38 #ifdef CONFIG_ZLIB
  39 #include <zlib.h>
  40 #endif
  41 #ifdef CONFIG_BZLIB
  42 #include <bzlib.h>
  43 #endif
  44
  45 typedef struct Track {
  46     MatroskaTrackType type;
  47
  48     /* Unique track number and track ID. stream_index is the index that
  49      * the calling app uses for this track. */
  50     uint32_t num;
  51     uint32_t uid;
  52     int stream_index;
  53
  54     char *name;
  55     char language[4];
  56
  57     char *codec_id;
  58     char *codec_name;
  59
  60     unsigned char *codec_priv;
  61     int codec_priv_size;
  62
  63     double time_scale;
  64     uint64_t default_duration;
  65     MatroskaTrackFlags flags;
  66
  67     int encoding_scope;
  68     MatroskaTrackEncodingCompAlgo encoding_algo;
  69     uint8_t *encoding_settings;
  70     int encoding_settings_len;
  71 } MatroskaTrack;
  72
  73 typedef struct MatroskaVideoTrack {
  74     MatroskaTrack track;
  75
  76     int pixel_width;
  77     int pixel_height;
  78     int display_width;
  79     int display_height;
  80
  81     uint32_t fourcc;
  82
  83     MatroskaAspectRatioMode ar_mode;
  84     MatroskaEyeMode eye_mode;
  85
  86     //..
  87 } MatroskaVideoTrack;
  88
  89 typedef struct MatroskaAudioTrack {
  90     MatroskaTrack track;
  91
  92     int channels;
  93     int bitdepth;
  94     int internal_samplerate;
  95     int samplerate;
  96     int block_align;
  97
  98     /* real audio header */
  99     int coded_framesize;
 100     int sub_packet_h;
 101     int frame_size;
 102     int sub_packet_size;
 103     int sub_packet_cnt;
 104     int pkt_cnt;
 105     uint8_t *buf;
 106     //..
 107 } MatroskaAudioTrack;
 108
 109 typedef struct MatroskaSubtitleTrack {
 110     MatroskaTrack track;
 111     //..
 112 } MatroskaSubtitleTrack;
 113
 114 #define MAX_TRACK_SIZE (FFMAX3(sizeof(MatroskaVideoTrack), \
 115                                     sizeof(MatroskaAudioTrack), \
 116                                     sizeof(MatroskaSubtitleTrack)))
 117
 118 typedef struct MatroskaLevel {
 119     uint64_t start;
 120     uint64_t length;
 121 } MatroskaLevel;
 122
 123 typedef struct MatroskaDemuxIndex {
 124   uint64_t        pos;   /* of the corresponding *cluster*! */
 125   uint16_t        track; /* reference to 'num' */
 126   uint64_t        time;  /* in nanoseconds */
 127 } MatroskaDemuxIndex;
 128
 129 typedef struct MatroskaDemuxContext {
 130     AVFormatContext *ctx;
 131
 132     /* ebml stuff */
 133     int num_levels;
 134     MatroskaLevel levels[EBML_MAX_DEPTH];
 135     int level_up;
 136
 137     /* matroska stuff */
 138     char *writing_app;
 139     char *muxing_app;
 140     int64_t created;
 141
 142     /* timescale in the file */
 143     int64_t time_scale;
 144
 145     /* num_streams is the number of streams that av_new_stream() was called
 146      * for ( = that are available to the calling program). */
 147     int num_tracks;
 148     int num_streams;
 149     MatroskaTrack *tracks[MAX_STREAMS];
 150
 151     /* cache for ID peeking */
 152     uint32_t peek_id;
 153
 154     /* byte position of the segment inside the stream */
 155     offset_t segment_start;
 156
 157     /* The packet queue. */
 158     AVPacket **packets;
 159     int num_packets;
 160
 161     /* have we already parse metadata/cues/clusters? */
 162     int metadata_parsed;
 163     int index_parsed;
 164     int done;
 165
 166     /* The index for seeking. */
 167     int num_indexes;
 168     MatroskaDemuxIndex *index;
 169
 170     /* What to skip before effectively reading a packet. */
 171     int skip_to_keyframe;
 172     AVStream *skip_to_stream;
 173 } MatroskaDemuxContext;
 174
 175 #define ARRAY_SIZE(x)  (sizeof(x)/sizeof(*x))
 176
 177 /*
 178  * The first few functions handle EBML file parsing. The rest
 179  * is the document interpretation. Matroska really just is a
 180  * EBML file.
 181  */
 182
 183 /*
 184  * Return: the amount of levels in the hierarchy that the
 185  * current element lies higher than the previous one.
 186  * The opposite isn't done - that's auto-done using master
 187  * element reading.
 188  */
 189
 190 static int
 191 ebml_read_element_level_up (MatroskaDemuxContext *matroska)
 192 {
 193     ByteIOContext *pb = matroska->ctx->pb;
 194     offset_t pos = url_ftell(pb);
 195     int num = 0;
 196
 197     while (matroska->num_levels > 0) {
 198         MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
 199
 200         if (pos >= level->start + level->length) {
 201             matroska->num_levels--;
 202             num++;
 203         } else {
 204             break;
 205         }
 206     }
 207
 208     return num;
 209 }
 210
 211 /*
 212  * Read: an "EBML number", which is defined as a variable-length
 213  * array of bytes. The first byte indicates the length by giving a
 214  * number of 0-bits followed by a one. The position of the first
 215  * "one" bit inside the first byte indicates the length of this
 216  * number.
 217  * Returns: num. of bytes read. < 0 on error.
 218  */
 219
 220 static int
 221 ebml_read_num (MatroskaDemuxContext *matroska,
 222                int                   max_size,
 223                uint64_t             *number)
 224 {
 225     ByteIOContext *pb = matroska->ctx->pb;
 226     int len_mask = 0x80, read = 1, n = 1;
 227     int64_t total = 0;
 228
 229     /* the first byte tells us the length in bytes - get_byte() can normally
 230      * return 0, but since that's not a valid first ebmlID byte, we can
 231      * use it safely here to catch EOS. */
 232     if (!(total = get_byte(pb))) {
 233         /* we might encounter EOS here */
 234         if (!url_feof(pb)) {
 235             offset_t pos = url_ftell(pb);
 236             av_log(matroska->ctx, AV_LOG_ERROR,
 237                    "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
 238                    pos, pos);
 239         }
 240         return AVERROR(EIO); /* EOS or actual I/O error */
 241     }
 242
 243     /* get the length of the EBML number */
 244     while (read <= max_size && !(total & len_mask)) {
 245         read++;
 246         len_mask >>= 1;
 247     }
 248     if (read > max_size) {
 249         offset_t pos = url_ftell(pb) - 1;
 250         av_log(matroska->ctx, AV_LOG_ERROR,
 251                "Invalid EBML number size tag 0x%02x at pos %"PRIu64" (0x%"PRIx64")\n",
 252                (uint8_t) total, pos, pos);
 253         return AVERROR_INVALIDDATA;
 254     }
 255
 256     /* read out length */
 257     total &= ~len_mask;
 258     while (n++ < read)
 259         total = (total << 8) | get_byte(pb);
 260
 261     *number = total;
 262
 263     return read;
 264 }
 265
 266 /*
 267  * Read: the element content data ID.
 268  * Return: the number of bytes read or < 0 on error.
 269  */
 270
 271 static int
 272 ebml_read_element_id (MatroskaDemuxContext *matroska,
 273                       uint32_t             *id,
 274                       int                  *level_up)
 275 {
 276     int read;
 277     uint64_t total;
 278
 279     /* if we re-call this, use our cached ID */
 280     if (matroska->peek_id != 0) {
 281         if (level_up)
 282             *level_up = 0;
 283         *id = matroska->peek_id;
 284         return 0;
 285     }
 286
 287     /* read out the "EBML number", include tag in ID */
 288     if ((read = ebml_read_num(matroska, 4, &total)) < 0)
 289         return read;
 290     *id = matroska->peek_id  = total | (1 << (read * 7));
 291
 292     /* level tracking */
 293     if (level_up)
 294         *level_up = ebml_read_element_level_up(matroska);
 295
 296     return read;
 297 }
 298
 299 /*
 300  * Read: element content length.
 301  * Return: the number of bytes read or < 0 on error.
 302  */
 303
 304 static int
 305 ebml_read_element_length (MatroskaDemuxContext *matroska,
 306                           uint64_t             *length)
 307 {
 308     /* clear cache since we're now beyond that data point */
 309     matroska->peek_id = 0;
 310
 311     /* read out the "EBML number", include tag in ID */
 312     return ebml_read_num(matroska, 8, length);
 313 }
 314
 315 /*
 316  * Return: the ID of the next element, or 0 on error.
 317  * Level_up contains the amount of levels that this
 318  * next element lies higher than the previous one.
 319  */
 320
 321 static uint32_t
 322 ebml_peek_id (MatroskaDemuxContext *matroska,
 323               int                  *level_up)
 324 {
 325     uint32_t id;
 326
 327     if (ebml_read_element_id(matroska, &id, level_up) < 0)
 328         return 0;
 329
 330     return id;
 331 }
 332
 333 /*
 334  * Seek to a given offset.
 335  * 0 is success, -1 is failure.
 336  */
 337
 338 static int
 339 ebml_read_seek (MatroskaDemuxContext *matroska,
 340                 offset_t              offset)
 341 {
 342     ByteIOContext *pb = matroska->ctx->pb;
 343
 344     /* clear ID cache, if any */
 345     matroska->peek_id = 0;
 346
 347     return (url_fseek(pb, offset, SEEK_SET) == offset) ? 0 : -1;
 348 }
 349
 350 /*
 351  * Skip the next element.
 352  * 0 is success, -1 is failure.
 353  */
 354
 355 static int
 356 ebml_read_skip (MatroskaDemuxContext *matroska)
 357 {
 358     ByteIOContext *pb = matroska->ctx->pb;
 359     uint32_t id;
 360     uint64_t length;
 361     int res;
 362
 363     if ((res = ebml_read_element_id(matroska, &id, NULL)) < 0 ||
 364         (res = ebml_read_element_length(matroska, &length)) < 0)
 365         return res;
 366
 367     url_fskip(pb, length);
 368
 369     return 0;
 370 }
 371
 372 /*
 373  * Read the next element as an unsigned int.
 374  * 0 is success, < 0 is failure.
 375  */
 376
 377 static int
 378 ebml_read_uint (MatroskaDemuxContext *matroska,
 379                 uint32_t             *id,
 380                 uint64_t             *num)
 381 {
 382     ByteIOContext *pb = matroska->ctx->pb;
 383     int n = 0, size, res;
 384     uint64_t rlength;
 385
 386     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
 387         (res = ebml_read_element_length(matroska, &rlength)) < 0)
 388         return res;
 389     size = rlength;
 390     if (size < 1 || size > 8) {
 391         offset_t pos = url_ftell(pb);
 392         av_log(matroska->ctx, AV_LOG_ERROR,
 393                "Invalid uint element size %d at position %"PRId64" (0x%"PRIx64")\n",
 394                 size, pos, pos);
 395         return AVERROR_INVALIDDATA;
 396     }
 397
 398     /* big-endian ordening; build up number */
 399     *num = 0;
 400     while (n++ < size)
 401         *num = (*num << 8) | get_byte(pb);
 402
 403     return 0;
 404 }
 405
 406 /*
 407  * Read the next element as a signed int.
 408  * 0 is success, < 0 is failure.
 409  */
 410
 411 static int
 412 ebml_read_sint (MatroskaDemuxContext *matroska,
 413                 uint32_t             *id,
 414                 int64_t              *num)
 415 {
 416     ByteIOContext *pb = matroska->ctx->pb;
 417     int size, n = 1, negative = 0, res;
 418     uint64_t rlength;
 419
 420     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
 421         (res = ebml_read_element_length(matroska, &rlength)) < 0)
 422         return res;
 423     size = rlength;
 424     if (size < 1 || size > 8) {
 425         offset_t pos = url_ftell(pb);
 426         av_log(matroska->ctx, AV_LOG_ERROR,
 427                "Invalid sint element size %d at position %"PRId64" (0x%"PRIx64")\n",
 428                 size, pos, pos);
 429         return AVERROR_INVALIDDATA;
 430     }
 431     if ((*num = get_byte(pb)) & 0x80) {
 432         negative = 1;
 433         *num &= ~0x80;
 434     }
 435     while (n++ < size)
 436         *num = (*num << 8) | get_byte(pb);
 437
 438     /* make signed */
 439     if (negative)
 440         *num = *num - (1LL << ((8 * size) - 1));
 441
 442     return 0;
 443 }
 444
 445 /*
 446  * Read the next element as a float.
 447  * 0 is success, < 0 is failure.
 448  */
 449
 450 static int
 451 ebml_read_float (MatroskaDemuxContext *matroska,
 452                  uint32_t             *id,
 453                  double               *num)
 454 {
 455     ByteIOContext *pb = matroska->ctx->pb;
 456     int size, res;
 457     uint64_t rlength;
 458
 459     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
 460         (res = ebml_read_element_length(matroska, &rlength)) < 0)
 461         return res;
 462     size = rlength;
 463
 464     if (size == 4) {
 465         *num= av_int2flt(get_be32(pb));
 466     } else if(size==8){
 467         *num= av_int2dbl(get_be64(pb));
 468     } else{
 469         offset_t pos = url_ftell(pb);
 470         av_log(matroska->ctx, AV_LOG_ERROR,
 471                "Invalid float element size %d at position %"PRIu64" (0x%"PRIx64")\n",
 472                size, pos, pos);
 473         return AVERROR_INVALIDDATA;
 474     }
 475
 476     return 0;
 477 }
 478
 479 /*
 480  * Read the next element as an ASCII string.
 481  * 0 is success, < 0 is failure.
 482  */
 483
 484 static int
 485 ebml_read_ascii (MatroskaDemuxContext *matroska,
 486                  uint32_t             *id,
 487                  char                **str)
 488 {
 489     ByteIOContext *pb = matroska->ctx->pb;
 490     int size, res;
 491     uint64_t rlength;
 492
 493     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
 494         (res = ebml_read_element_length(matroska, &rlength)) < 0)
 495         return res;
 496     size = rlength;
 497
 498     /* ebml strings are usually not 0-terminated, so we allocate one
 499      * byte more, read the string and NULL-terminate it ourselves. */
 500     if (size < 0 || !(*str = av_malloc(size + 1))) {
 501         av_log(matroska->ctx, AV_LOG_ERROR, "Memory allocation failed\n");
 502         return AVERROR(ENOMEM);
 503     }
 504     if (get_buffer(pb, (uint8_t *) *str, size) != size) {
 505         offset_t pos = url_ftell(pb);
 506         av_log(matroska->ctx, AV_LOG_ERROR,
 507                "Read error at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
 508         av_free(*str);
 509         return AVERROR(EIO);
 510     }
 511     (*str)[size] = '\0';
 512
 513     return 0;
 514 }
 515
 516 /*
 517  * Read the next element as a UTF-8 string.
 518  * 0 is success, < 0 is failure.
 519  */
 520
 521 static int
 522 ebml_read_utf8 (MatroskaDemuxContext *matroska,
 523                 uint32_t             *id,
 524                 char                **str)
 525 {
 526   return ebml_read_ascii(matroska, id, str);
 527 }
 528
 529 /*
 530  * Read the next element as a date (nanoseconds since 1/1/2000).
 531  * 0 is success, < 0 is failure.
 532  */
 533
 534 static int
 535 ebml_read_date (MatroskaDemuxContext *matroska,
 536                 uint32_t             *id,
 537                 int64_t              *date)
 538 {
 539   return ebml_read_sint(matroska, id, date);
 540 }
 541
 542 /*
 543  * Read the next element, but only the header. The contents
 544  * are supposed to be sub-elements which can be read separately.
 545  * 0 is success, < 0 is failure.
 546  */
 547
 548 static int
 549 ebml_read_master (MatroskaDemuxContext *matroska,
 550                   uint32_t             *id)
 551 {
 552     ByteIOContext *pb = matroska->ctx->pb;
 553     uint64_t length;
 554     MatroskaLevel *level;
 555     int res;
 556
 557     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
 558         (res = ebml_read_element_length(matroska, &length)) < 0)
 559         return res;
 560
 561     /* protect... (Heaven forbids that the '>' is true) */
 562     if (matroska->num_levels >= EBML_MAX_DEPTH) {
 563         av_log(matroska->ctx, AV_LOG_ERROR,
 564                "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
 565         return AVERROR(ENOSYS);
 566     }
 567
 568     /* remember level */
 569     level = &matroska->levels[matroska->num_levels++];
 570     level->start = url_ftell(pb);
 571     level->length = length;
 572
 573     return 0;
 574 }
 575
 576 /*
 577  * Read the next element as binary data.
 578  * 0 is success, < 0 is failure.
 579  */
 580
 581 static int
 582 ebml_read_binary (MatroskaDemuxContext *matroska,
 583                   uint32_t             *id,
 584                   uint8_t             **binary,
 585                   int                  *size)
 586 {
 587     ByteIOContext *pb = matroska->ctx->pb;
 588     uint64_t rlength;
 589     int res;
 590
 591     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
 592         (res = ebml_read_element_length(matroska, &rlength)) < 0)
 593         return res;
 594     *size = rlength;
 595
 596     if (!(*binary = av_malloc(*size))) {
 597         av_log(matroska->ctx, AV_LOG_ERROR,
 598                "Memory allocation error\n");
 599         return AVERROR(ENOMEM);
 600     }
 601
 602     if (get_buffer(pb, *binary, *size) != *size) {
 603         offset_t pos = url_ftell(pb);
 604         av_log(matroska->ctx, AV_LOG_ERROR,
 605                "Read error at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
 606         return AVERROR(EIO);
 607     }
 608
 609     return 0;
 610 }
 611
 612 /*
 613  * Read signed/unsigned "EBML" numbers.
 614  * Return: number of bytes processed, < 0 on error.
 615  * XXX: use ebml_read_num().
 616  */
 617
 618 static int
 619 matroska_ebmlnum_uint (uint8_t  *data,
 620                        uint32_t  size,
 621                        uint64_t *num)
 622 {
 623     int len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
 624     uint64_t total;
 625
 626     if (size <= 0)
 627         return AVERROR_INVALIDDATA;
 628
 629     total = data[0];
 630     while (read <= 8 && !(total & len_mask)) {
 631         read++;
 632         len_mask >>= 1;
 633     }
 634     if (read > 8)
 635         return AVERROR_INVALIDDATA;
 636
 637     if ((total &= (len_mask - 1)) == len_mask - 1)
 638         num_ffs++;
 639     if (size < read)
 640         return AVERROR_INVALIDDATA;
 641     while (n < read) {
 642         if (data[n] == 0xff)
 643             num_ffs++;
 644         total = (total << 8) | data[n];
 645         n++;
 646     }
 647
 648     if (read == num_ffs)
 649         *num = (uint64_t)-1;
 650     else
 651         *num = total;
 652
 653     return read;
 654 }
 655
 656 /*
 657  * Same as above, but signed.
 658  */
 659
 660 static int
 661 matroska_ebmlnum_sint (uint8_t  *data,
 662                        uint32_t  size,
 663                        int64_t  *num)
 664 {
 665     uint64_t unum;
 666     int res;
 667
 668     /* read as unsigned number first */
 669     if ((res = matroska_ebmlnum_uint(data, size, &unum)) < 0)
 670         return res;
 671
 672     /* make signed (weird way) */
 673     if (unum == (uint64_t)-1)
 674         *num = INT64_MAX;
 675     else
 676         *num = unum - ((1LL << ((7 * res) - 1)) - 1);
 677
 678     return res;
 679 }
 680
 681 /*
 682  * Read an EBML header.
 683  * 0 is success, < 0 is failure.
 684  */
 685
 686 static int
 687 ebml_read_header (MatroskaDemuxContext *matroska,
 688                   char                **doctype,
 689                   int                  *version)
 690 {
 691     uint32_t id;
 692     int level_up, res = 0;
 693
 694     /* default init */
 695     if (doctype)
 696         *doctype = NULL;
 697     if (version)
 698         *version = 1;
 699
 700     if (!(id = ebml_peek_id(matroska, &level_up)) ||
 701         level_up != 0 || id != EBML_ID_HEADER) {
 702         av_log(matroska->ctx, AV_LOG_ERROR,
 703                "This is not an EBML file (id=0x%x/0x%x)\n", id, EBML_ID_HEADER);
 704         return AVERROR_INVALIDDATA;
 705     }
 706     if ((res = ebml_read_master(matroska, &id)) < 0)
 707         return res;
 708
 709     while (res == 0) {
 710         if (!(id = ebml_peek_id(matroska, &level_up)))
 711             return AVERROR(EIO);
 712
 713         /* end-of-header */
 714         if (level_up)
 715             break;
 716
 717         switch (id) {
 718             /* is our read version uptodate? */
 719             case EBML_ID_EBMLREADVERSION: {
 720                 uint64_t num;
 721
 722                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
 723                     return res;
 724                 if (num > EBML_VERSION) {
 725                     av_log(matroska->ctx, AV_LOG_ERROR,
 726                            "EBML version %"PRIu64" (> %d) is not supported\n",
 727                            num, EBML_VERSION);
 728                     return AVERROR_INVALIDDATA;
 729                 }
 730                 break;
 731             }
 732
 733             /* we only handle 8 byte lengths at max */
 734             case EBML_ID_EBMLMAXSIZELENGTH: {
 735                 uint64_t num;
 736
 737                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
 738                     return res;
 739                 if (num > sizeof(uint64_t)) {
 740                     av_log(matroska->ctx, AV_LOG_ERROR,
 741                            "Integers of size %"PRIu64" (> %zd) not supported\n",
 742                            num, sizeof(uint64_t));
 743                     return AVERROR_INVALIDDATA;
 744                 }
 745                 break;
 746             }
 747
 748             /* we handle 4 byte IDs at max */
 749             case EBML_ID_EBMLMAXIDLENGTH: {
 750                 uint64_t num;
 751
 752                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
 753                     return res;
 754                 if (num > sizeof(uint32_t)) {
 755                     av_log(matroska->ctx, AV_LOG_ERROR,
 756                            "IDs of size %"PRIu64" (> %zu) not supported\n",
 757                             num, sizeof(uint32_t));
 758                     return AVERROR_INVALIDDATA;
 759                 }
 760                 break;
 761             }
 762
 763             case EBML_ID_DOCTYPE: {
 764                 char *text;
 765
 766                 if ((res = ebml_read_ascii(matroska, &id, &text)) < 0)
 767                     return res;
 768                 if (doctype) {
 769                     if (*doctype)
 770                         av_free(*doctype);
 771                     *doctype = text;
 772                 } else
 773                     av_free(text);
 774                 break;
 775             }
 776
 777             case EBML_ID_DOCTYPEREADVERSION: {
 778                 uint64_t num;
 779
 780                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
 781                     return res;
 782                 if (version)
 783                     *version = num;
 784                 break;
 785             }
 786
 787             default:
 788                 av_log(matroska->ctx, AV_LOG_INFO,
 789                        "Unknown data type 0x%x in EBML header", id);
 790                 /* pass-through */
 791
 792             case EBML_ID_VOID:
 793             /* we ignore these two, as they don't tell us anything we
 794              * care about */
 795             case EBML_ID_EBMLVERSION:
 796             case EBML_ID_DOCTYPEVERSION:
 797                 res = ebml_read_skip (matroska);
 798                 break;
 799         }
 800     }
 801
 802     return 0;
 803 }
 804
 805
 806 static int
 807 matroska_find_track_by_num (MatroskaDemuxContext *matroska,
 808                             int                   num)
 809 {
 810     int i;
 811
 812     for (i = 0; i < matroska->num_tracks; i++)
 813         if (matroska->tracks[i]->num == num)
 814             return i;
 815
 816     return -1;
 817 }
 818
 819
 820 /*
 821  * Put one packet in an application-supplied AVPacket struct.
 822  * Returns 0 on success or -1 on failure.
 823  */
 824
 825 static int
 826 matroska_deliver_packet (MatroskaDemuxContext *matroska,
 827                          AVPacket             *pkt)
 828 {
 829     if (matroska->num_packets > 0) {
 830         memcpy(pkt, matroska->packets[0], sizeof(AVPacket));
 831         av_free(matroska->packets[0]);
 832         if (matroska->num_packets > 1) {
 833             memmove(&matroska->packets[0], &matroska->packets[1],
 834                     (matroska->num_packets - 1) * sizeof(AVPacket *));
 835             matroska->packets =
 836                 av_realloc(matroska->packets, (matroska->num_packets - 1) *
 837                            sizeof(AVPacket *));
 838         } else {
 839             av_freep(&matroska->packets);
 840         }
 841         matroska->num_packets--;
 842         return 0;
 843     }
 844
 845     return -1;
 846 }
 847
 848 /*
 849  * Put a packet into our internal queue. Will be delivered to the
 850  * user/application during the next get_packet() call.
 851  */
 852
 853 static void
 854 matroska_queue_packet (MatroskaDemuxContext *matroska,
 855                        AVPacket             *pkt)
 856 {
 857     matroska->packets =
 858         av_realloc(matroska->packets, (matroska->num_packets + 1) *
 859                    sizeof(AVPacket *));
 860     matroska->packets[matroska->num_packets] = pkt;
 861     matroska->num_packets++;
 862 }
 863
 864 /*
 865  * Free all packets in our internal queue.
 866  */
 867 static void
 868 matroska_clear_queue (MatroskaDemuxContext *matroska)
 869 {
 870     if (matroska->packets) {
 871         int n;
 872         for (n = 0; n < matroska->num_packets; n++) {
 873             av_free_packet(matroska->packets[n]);
 874             av_free(matroska->packets[n]);
 875         }
 876         av_free(matroska->packets);
 877         matroska->packets = NULL;
 878         matroska->num_packets = 0;
 879     }
 880 }
 881
 882
 883 /*
 884  * Autodetecting...
 885  */
 886
 887 static int
 888 matroska_probe (AVProbeData *p)
 889 {
 890     uint64_t total = 0;
 891     int len_mask = 0x80, size = 1, n = 1;
 892     uint8_t probe_data[] = { 'm', 'a', 't', 'r', 'o', 's', 'k', 'a' };
 893
 894     /* ebml header? */
 895     if (AV_RB32(p->buf) != EBML_ID_HEADER)
 896         return 0;
 897
 898     /* length of header */
 899     total = p->buf[4];
 900     while (size <= 8 && !(total & len_mask)) {
 901         size++;
 902         len_mask >>= 1;
 903     }
 904     if (size > 8)
 905       return 0;
 906     total &= (len_mask - 1);
 907     while (n < size)
 908         total = (total << 8) | p->buf[4 + n++];
 909
 910     /* does the probe data contain the whole header? */
 911     if (p->buf_size < 4 + size + total)
 912       return 0;
 913
 914     /* the header must contain the document type 'matroska'. For now,
 915      * we don't parse the whole header but simply check for the
 916      * availability of that array of characters inside the header.
 917      * Not fully fool-proof, but good enough. */
 918     for (n = 4 + size; n <= 4 + size + total - sizeof(probe_data); n++)
 919         if (!memcmp (&p->buf[n], probe_data, sizeof(probe_data)))
 920             return AVPROBE_SCORE_MAX;
 921
 922     return 0;
 923 }
 924
 925 /*
 926  * From here on, it's all XML-style DTD stuff... Needs no comments.
 927  */
 928
 929 static int
 930 matroska_parse_info (MatroskaDemuxContext *matroska)
 931 {
 932     int res = 0;
 933     uint32_t id;
 934
 935     av_log(matroska->ctx, AV_LOG_DEBUG, "Parsing info...\n");
 936
 937     while (res == 0) {
 938         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
 939             res = AVERROR(EIO);
 940             break;
 941         } else if (matroska->level_up) {
 942             matroska->level_up--;
 943             break;
 944         }
 945
 946         switch (id) {
 947             /* cluster timecode */
 948             case MATROSKA_ID_TIMECODESCALE: {
 949                 uint64_t num;
 950                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
 951                     break;
 952                 matroska->time_scale = num;
 953                 break;
 954             }
 955
 956             case MATROSKA_ID_DURATION: {
 957                 double num;
 958                 if ((res = ebml_read_float(matroska, &id, &num)) < 0)
 959                     break;
 960                 matroska->ctx->duration = num * matroska->time_scale * 1000 / AV_TIME_BASE;
 961                 break;
 962             }
 963
 964             case MATROSKA_ID_TITLE: {
 965                 char *text;
 966                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
 967                     break;
 968                 strncpy(matroska->ctx->title, text,
 969                         sizeof(matroska->ctx->title)-1);
 970                 av_free(text);
 971                 break;
 972             }
 973
 974             case MATROSKA_ID_WRITINGAPP: {
 975                 char *text;
 976                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
 977                     break;
 978                 matroska->writing_app = text;
 979                 break;
 980             }
 981
 982             case MATROSKA_ID_MUXINGAPP: {
 983                 char *text;
 984                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
 985                     break;
 986                 matroska->muxing_app = text;
 987                 break;
 988             }
 989
 990             case MATROSKA_ID_DATEUTC: {
 991                 int64_t time;
 992                 if ((res = ebml_read_date(matroska, &id, &time)) < 0)
 993                     break;
 994                 matroska->created = time;
 995                 break;
 996             }
 997
 998             default:
 999                 av_log(matroska->ctx, AV_LOG_INFO,
1000                        "Unknown entry 0x%x in info header\n", id);
1001                 /* fall-through */
1002
1003             case MATROSKA_ID_SEGMENTUID:
1004             case EBML_ID_VOID:
1005                 res = ebml_read_skip(matroska);
1006                 break;
1007         }
1008
1009         if (matroska->level_up) {
1010             matroska->level_up--;
1011             break;
1012         }
1013     }
1014
1015     return res;
1016 }
1017
1018 static int
1019 matroska_add_stream (MatroskaDemuxContext *matroska)
1020 {
1021     int res = 0;
1022     uint32_t id;
1023     MatroskaTrack *track;
1024
1025     /* start with the master */
1026     if ((res = ebml_read_master(matroska, &id)) < 0)
1027         return res;
1028
1029     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing track, adding stream..,\n");
1030
1031     /* Allocate a generic track. As soon as we know its type we'll realloc. */
1032     track = av_mallocz(MAX_TRACK_SIZE);
1033     strcpy(track->language, "eng");
1034
1035     /* try reading the trackentry headers */
1036     while (res == 0) {
1037         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1038             res = AVERROR(EIO);
1039             break;
1040         } else if (matroska->level_up > 0) {
1041             matroska->level_up--;
1042             break;
1043         }
1044
1045         switch (id) {
1046             /* track number (unique stream ID) */
1047             case MATROSKA_ID_TRACKNUMBER: {
1048                 uint64_t num;
1049                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1050                     break;
1051                 track->num = num;
1052                 break;
1053             }
1054
1055             /* track UID (unique identifier) */
1056             case MATROSKA_ID_TRACKUID: {
1057                 uint64_t num;
1058                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1059                     break;
1060                 track->uid = num;
1061                 break;
1062             }
1063
1064             /* track type (video, audio, combined, subtitle, etc.) */
1065             case MATROSKA_ID_TRACKTYPE: {
1066                 uint64_t num;
1067                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1068                     break;
1069                 if (track->type && track->type != num) {
1070                     av_log(matroska->ctx, AV_LOG_INFO,
1071                            "More than one tracktype in an entry - skip\n");
1072                     break;
1073                 }
1074                 track->type = num;
1075
1076                 switch (track->type) {
1077                     case MATROSKA_TRACK_TYPE_VIDEO:
1078                     case MATROSKA_TRACK_TYPE_AUDIO:
1079                     case MATROSKA_TRACK_TYPE_SUBTITLE:
1080                         break;
1081                     case MATROSKA_TRACK_TYPE_COMPLEX:
1082                     case MATROSKA_TRACK_TYPE_LOGO:
1083                     case MATROSKA_TRACK_TYPE_CONTROL:
1084                     default:
1085                         av_log(matroska->ctx, AV_LOG_INFO,
1086                                "Unknown or unsupported track type 0x%x\n",
1087                                track->type);
1088                         track->type = MATROSKA_TRACK_TYPE_NONE;
1089                         break;
1090                 }
1091                 break;
1092             }
1093
1094             /* tracktype specific stuff for video */
1095             case MATROSKA_ID_TRACKVIDEO: {
1096                 MatroskaVideoTrack *videotrack;
1097                 if (!track->type)
1098                     track->type = MATROSKA_TRACK_TYPE_VIDEO;
1099                 if (track->type != MATROSKA_TRACK_TYPE_VIDEO) {
1100                     av_log(matroska->ctx, AV_LOG_INFO,
1101                            "video data in non-video track - ignoring\n");
1102                     res = AVERROR_INVALIDDATA;
1103                     break;
1104                 } else if ((res = ebml_read_master(matroska, &id)) < 0)
1105                     break;
1106                 videotrack = (MatroskaVideoTrack *)track;
1107
1108                 while (res == 0) {
1109                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1110                         res = AVERROR(EIO);
1111                         break;
1112                     } else if (matroska->level_up > 0) {
1113                         matroska->level_up--;
1114                         break;
1115                     }
1116
1117                     switch (id) {
1118                         /* fixme, this should be one-up, but I get it here */
1119                         case MATROSKA_ID_TRACKDEFAULTDURATION: {
1120                             uint64_t num;
1121                             if ((res = ebml_read_uint (matroska, &id,
1122                                                        &num)) < 0)
1123                                 break;
1124                             track->default_duration = num;
1125                             break;
1126                         }
1127
1128                         /* video framerate */
1129                         case MATROSKA_ID_VIDEOFRAMERATE: {
1130                             double num;
1131                             if ((res = ebml_read_float(matroska, &id,
1132                                                        &num)) < 0)
1133                                 break;
1134                             if (!track->default_duration)
1135                                 track->default_duration = 1000000000/num;
1136                             break;
1137                         }
1138
1139                         /* width of the size to display the video at */
1140                         case MATROSKA_ID_VIDEODISPLAYWIDTH: {
1141                             uint64_t num;
1142                             if ((res = ebml_read_uint(matroska, &id,
1143                                                       &num)) < 0)
1144                                 break;
1145                             videotrack->display_width = num;
1146                             break;
1147                         }
1148
1149                         /* height of the size to display the video at */
1150                         case MATROSKA_ID_VIDEODISPLAYHEIGHT: {
1151                             uint64_t num;
1152                             if ((res = ebml_read_uint(matroska, &id,
1153                                                       &num)) < 0)
1154                                 break;
1155                             videotrack->display_height = num;
1156                             break;
1157                         }
1158
1159                         /* width of the video in the file */
1160                         case MATROSKA_ID_VIDEOPIXELWIDTH: {
1161                             uint64_t num;
1162                             if ((res = ebml_read_uint(matroska, &id,
1163                                                       &num)) < 0)
1164                                 break;
1165                             videotrack->pixel_width = num;
1166                             break;
1167                         }
1168
1169                         /* height of the video in the file */
1170                         case MATROSKA_ID_VIDEOPIXELHEIGHT: {
1171                             uint64_t num;
1172                             if ((res = ebml_read_uint(matroska, &id,
1173                                                       &num)) < 0)
1174                                 break;
1175                             videotrack->pixel_height = num;
1176                             break;
1177                         }
1178
1179                         /* whether the video is interlaced */
1180                         case MATROSKA_ID_VIDEOFLAGINTERLACED: {
1181                             uint64_t num;
1182                             if ((res = ebml_read_uint(matroska, &id,
1183                                                       &num)) < 0)
1184                                 break;
1185                             if (num)
1186                                 track->flags |=
1187                                     MATROSKA_VIDEOTRACK_INTERLACED;
1188                             else
1189                                 track->flags &=
1190                                     ~MATROSKA_VIDEOTRACK_INTERLACED;
1191                             break;
1192                         }
1193
1194                         /* stereo mode (whether the video has two streams,
1195                          * where one is for the left eye and the other for
1196                          * the right eye, which creates a 3D-like
1197                          * effect) */
1198                         case MATROSKA_ID_VIDEOSTEREOMODE: {
1199                             uint64_t num;
1200                             if ((res = ebml_read_uint(matroska, &id,
1201                                                       &num)) < 0)
1202                                 break;
1203                             if (num != MATROSKA_EYE_MODE_MONO &&
1204                                 num != MATROSKA_EYE_MODE_LEFT &&
1205                                 num != MATROSKA_EYE_MODE_RIGHT &&
1206                                 num != MATROSKA_EYE_MODE_BOTH) {
1207                                 av_log(matroska->ctx, AV_LOG_INFO,
1208                                        "Ignoring unknown eye mode 0x%x\n",
1209                                        (uint32_t) num);
1210                                 break;
1211                             }
1212                             videotrack->eye_mode = num;
1213                             break;
1214                         }
1215
1216                         /* aspect ratio behaviour */
1217                         case MATROSKA_ID_VIDEOASPECTRATIO: {
1218                             uint64_t num;
1219                             if ((res = ebml_read_uint(matroska, &id,
1220                                                       &num)) < 0)
1221                                 break;
1222                             if (num != MATROSKA_ASPECT_RATIO_MODE_FREE &&
1223                                 num != MATROSKA_ASPECT_RATIO_MODE_KEEP &&
1224                                 num != MATROSKA_ASPECT_RATIO_MODE_FIXED) {
1225                                 av_log(matroska->ctx, AV_LOG_INFO,
1226                                        "Ignoring unknown aspect ratio 0x%x\n",
1227                                        (uint32_t) num);
1228                                 break;
1229                             }
1230                             videotrack->ar_mode = num;
1231                             break;
1232                         }
1233
1234                         /* colorspace (only matters for raw video)
1235                          * fourcc */
1236                         case MATROSKA_ID_VIDEOCOLORSPACE: {
1237                             uint64_t num;
1238                             if ((res = ebml_read_uint(matroska, &id,
1239                                                       &num)) < 0)
1240                                 break;
1241                             videotrack->fourcc = num;
1242                             break;
1243                         }
1244
1245                         default:
1246                             av_log(matroska->ctx, AV_LOG_INFO,
1247                                    "Unknown video track header entry "
1248                                    "0x%x - ignoring\n", id);
1249                             /* pass-through */
1250
1251                         case EBML_ID_VOID:
1252                             res = ebml_read_skip(matroska);
1253                             break;
1254                     }
1255
1256                     if (matroska->level_up) {
1257                         matroska->level_up--;
1258                         break;
1259                     }
1260                 }
1261                 break;
1262             }
1263
1264             /* tracktype specific stuff for audio */
1265             case MATROSKA_ID_TRACKAUDIO: {
1266                 MatroskaAudioTrack *audiotrack;
1267                 if (!track->type)
1268                     track->type = MATROSKA_TRACK_TYPE_AUDIO;
1269                 if (track->type != MATROSKA_TRACK_TYPE_AUDIO) {
1270                     av_log(matroska->ctx, AV_LOG_INFO,
1271                            "audio data in non-audio track - ignoring\n");
1272                     res = AVERROR_INVALIDDATA;
1273                     break;
1274                 } else if ((res = ebml_read_master(matroska, &id)) < 0)
1275                     break;
1276                 audiotrack = (MatroskaAudioTrack *)track;
1277                 audiotrack->channels = 1;
1278                 audiotrack->samplerate = 8000;
1279
1280                 while (res == 0) {
1281                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1282                         res = AVERROR(EIO);
1283                         break;
1284                     } else if (matroska->level_up > 0) {
1285                         matroska->level_up--;
1286                         break;
1287                     }
1288
1289                     switch (id) {
1290                         /* samplerate */
1291                         case MATROSKA_ID_AUDIOSAMPLINGFREQ: {
1292                             double num;
1293                             if ((res = ebml_read_float(matroska, &id,
1294                                                        &num)) < 0)
1295                                 break;
1296                             audiotrack->internal_samplerate =
1297                             audiotrack->samplerate = num;
1298                             break;
1299                         }
1300
1301                         case MATROSKA_ID_AUDIOOUTSAMPLINGFREQ: {
1302                             double num;
1303                             if ((res = ebml_read_float(matroska, &id,
1304                                                        &num)) < 0)
1305                                 break;
1306                             audiotrack->samplerate = num;
1307                             break;
1308                         }
1309
1310                             /* bitdepth */
1311                         case MATROSKA_ID_AUDIOBITDEPTH: {
1312                             uint64_t num;
1313                             if ((res = ebml_read_uint(matroska, &id,
1314                                                       &num)) < 0)
1315                                 break;
1316                             audiotrack->bitdepth = num;
1317                             break;
1318                         }
1319
1320                             /* channels */
1321                         case MATROSKA_ID_AUDIOCHANNELS: {
1322                             uint64_t num;
1323                             if ((res = ebml_read_uint(matroska, &id,
1324                                                       &num)) < 0)
1325                                 break;
1326                             audiotrack->channels = num;
1327                             break;
1328                         }
1329
1330                         default:
1331                             av_log(matroska->ctx, AV_LOG_INFO,
1332                                    "Unknown audio track header entry "
1333                                    "0x%x - ignoring\n", id);
1334                             /* pass-through */
1335
1336                         case EBML_ID_VOID:
1337                             res = ebml_read_skip(matroska);
1338                             break;
1339                     }
1340
1341                     if (matroska->level_up) {
1342                         matroska->level_up--;
1343                         break;
1344                     }
1345                 }
1346                 break;
1347             }
1348
1349                 /* codec identifier */
1350             case MATROSKA_ID_CODECID: {
1351                 char *text;
1352                 if ((res = ebml_read_ascii(matroska, &id, &text)) < 0)
1353                     break;
1354                 track->codec_id = text;
1355                 break;
1356             }
1357
1358                 /* codec private data */
1359             case MATROSKA_ID_CODECPRIVATE: {
1360                 uint8_t *data;
1361                 int size;
1362                 if ((res = ebml_read_binary(matroska, &id, &data, &size) < 0))
1363                     break;
1364                 track->codec_priv = data;
1365                 track->codec_priv_size = size;
1366                 break;
1367             }
1368
1369                 /* name of the codec */
1370             case MATROSKA_ID_CODECNAME: {
1371                 char *text;
1372                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1373                     break;
1374                 track->codec_name = text;
1375                 break;
1376             }
1377
1378                 /* name of this track */
1379             case MATROSKA_ID_TRACKNAME: {
1380                 char *text;
1381                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1382                     break;
1383                 track->name = text;
1384                 break;
1385             }
1386
1387                 /* language (matters for audio/subtitles, mostly) */
1388             case MATROSKA_ID_TRACKLANGUAGE: {
1389                 char *text, *end;
1390                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1391                     break;
1392                 if ((end = strchr(text, '-')))
1393                     *end = '\0';
1394                 if (strlen(text) == 3)
1395                     strcpy(track->language, text);
1396                 av_free(text);
1397                 break;
1398             }
1399
1400                 /* whether this is actually used */
1401             case MATROSKA_ID_TRACKFLAGENABLED: {
1402                 uint64_t num;
1403                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1404                     break;
1405                 if (num)
1406                     track->flags |= MATROSKA_TRACK_ENABLED;
1407                 else
1408                     track->flags &= ~MATROSKA_TRACK_ENABLED;
1409                 break;
1410             }
1411
1412                 /* whether it's the default for this track type */
1413             case MATROSKA_ID_TRACKFLAGDEFAULT: {
1414                 uint64_t num;
1415                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1416                     break;
1417                 if (num)
1418                     track->flags |= MATROSKA_TRACK_DEFAULT;
1419                 else
1420                     track->flags &= ~MATROSKA_TRACK_DEFAULT;
1421                 break;
1422             }
1423
1424                 /* lacing (like MPEG, where blocks don't end/start on frame
1425                  * boundaries) */
1426             case MATROSKA_ID_TRACKFLAGLACING: {
1427                 uint64_t num;
1428                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1429                     break;
1430                 if (num)
1431                     track->flags |= MATROSKA_TRACK_LACING;
1432                 else
1433                     track->flags &= ~MATROSKA_TRACK_LACING;
1434                 break;
1435             }
1436
1437                 /* default length (in time) of one data block in this track */
1438             case MATROSKA_ID_TRACKDEFAULTDURATION: {
1439                 uint64_t num;
1440                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1441                     break;
1442                 track->default_duration = num;
1443                 break;
1444             }
1445
1446             case MATROSKA_ID_TRACKCONTENTENCODINGS: {
1447                 if ((res = ebml_read_master(matroska, &id)) < 0)
1448                     break;
1449
1450                 while (res == 0) {
1451                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1452                         res = AVERROR(EIO);
1453                         break;
1454                     } else if (matroska->level_up > 0) {
1455                         matroska->level_up--;
1456                         break;
1457                     }
1458
1459                     switch (id) {
1460                         case MATROSKA_ID_TRACKCONTENTENCODING: {
1461                             int encoding_scope = 1;
1462                             if ((res = ebml_read_master(matroska, &id)) < 0)
1463                                 break;
1464
1465                             while (res == 0) {
1466                                 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1467                                     res = AVERROR(EIO);
1468                                     break;
1469                                 } else if (matroska->level_up > 0) {
1470                                     matroska->level_up--;
1471                                     break;
1472                                 }
1473
1474                                 switch (id) {
1475                                     case MATROSKA_ID_ENCODINGSCOPE: {
1476                                         uint64_t num;
1477                                         if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1478                                             break;
1479                                         encoding_scope = num;
1480                                         break;
1481                                     }
1482
1483                                     case MATROSKA_ID_ENCODINGTYPE: {
1484                                         uint64_t num;
1485                                         if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1486                                             break;
1487                                         if (num)
1488                                             av_log(matroska->ctx, AV_LOG_ERROR,
1489                                                    "Unsupported encoding type");
1490                                         break;
1491                                     }
1492
1493                                     case MATROSKA_ID_ENCODINGCOMPRESSION: {
1494                                         if ((res = ebml_read_master(matroska, &id)) < 0)
1495                                             break;
1496
1497                                         while (res == 0) {
1498                                             if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1499                                                 res = AVERROR(EIO);
1500                                                 break;
1501                                             } else if (matroska->level_up > 0) {
1502                                                 matroska->level_up--;
1503                                                 break;
1504                                             }
1505
1506                                             switch (id) {
1507                                                 case MATROSKA_ID_ENCODINGCOMPALGO: {
1508                                                     uint64_t num;
1509                                                     if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1510                                                         break;
1511                                                     if (num != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP &&
1512 #ifdef CONFIG_ZLIB
1513                                                         num != MATROSKA_TRACK_ENCODING_COMP_ZLIB &&
1514 #endif
1515 #ifdef CONFIG_BZLIB
1516                                                         num != MATROSKA_TRACK_ENCODING_COMP_BZLIB &&
1517 #endif
1518                                                         num != MATROSKA_TRACK_ENCODING_COMP_LZO)
1519                                                         av_log(matroska->ctx, AV_LOG_ERROR,
1520                                                                "Unsupported compression algo\n");
1521                                                     track->encoding_algo = num;
1522                                                     break;
1523                                                 }
1524
1525                                                 case MATROSKA_ID_ENCODINGCOMPSETTINGS: {
1526                                                     uint8_t *data;
1527                                                     int size;
1528                                                     if ((res = ebml_read_binary(matroska, &id, &data, &size) < 0))
1529                                                         break;
1530                                                     track->encoding_settings = data;
1531                                                     track->encoding_settings_len = size;
1532                                                     break;
1533                                                 }
1534
1535                                                 default:
1536                                                     av_log(matroska->ctx, AV_LOG_INFO,
1537                                                            "Unknown compression header entry "
1538                                                            "0x%x - ignoring\n", id);
1539                                                     /* pass-through */
1540
1541                                                 case EBML_ID_VOID:
1542                                                     res = ebml_read_skip(matroska);
1543                                                     break;
1544                                             }
1545
1546                                             if (matroska->level_up) {
1547                                                 matroska->level_up--;
1548                                                 break;
1549                                             }
1550                                         }
1551                                         break;
1552                                     }
1553
1554                                     default:
1555                                         av_log(matroska->ctx, AV_LOG_INFO,
1556                                                "Unknown content encoding header entry "
1557                                                "0x%x - ignoring\n", id);
1558                                         /* pass-through */
1559
1560                                     case EBML_ID_VOID:
1561                                         res = ebml_read_skip(matroska);
1562                                         break;
1563                                 }
1564
1565                                 if (matroska->level_up) {
1566                                     matroska->level_up--;
1567                                     break;
1568                                 }
1569                             }
1570
1571                             track->encoding_scope = encoding_scope;
1572                             break;
1573                         }
1574
1575                         default:
1576                             av_log(matroska->ctx, AV_LOG_INFO,
1577                                    "Unknown content encodings header entry "
1578                                    "0x%x - ignoring\n", id);
1579                             /* pass-through */
1580
1581                         case EBML_ID_VOID:
1582                             res = ebml_read_skip(matroska);
1583                             break;
1584                     }
1585
1586                     if (matroska->level_up) {
1587                         matroska->level_up--;
1588                         break;
1589                     }
1590                 }
1591                 break;
1592             }
1593
1594             case MATROSKA_ID_TRACKTIMECODESCALE: {
1595                 double num;
1596                 if ((res = ebml_read_float(matroska, &id, &num)) < 0)
1597                     break;
1598                 track->time_scale = num;
1599                 break;
1600             }
1601
1602             default:
1603                 av_log(matroska->ctx, AV_LOG_INFO,
1604                        "Unknown track header entry 0x%x - ignoring\n", id);
1605                 /* pass-through */
1606
1607             case EBML_ID_VOID:
1608             /* we ignore these because they're nothing useful. */
1609             case MATROSKA_ID_TRACKFLAGFORCED:
1610             case MATROSKA_ID_CODECDECODEALL:
1611             case MATROSKA_ID_CODECINFOURL:
1612             case MATROSKA_ID_CODECDOWNLOADURL:
1613             case MATROSKA_ID_TRACKMINCACHE:
1614             case MATROSKA_ID_TRACKMAXCACHE:
1615                 res = ebml_read_skip(matroska);
1616                 break;
1617         }
1618
1619         if (matroska->level_up) {
1620             matroska->level_up--;
1621             break;
1622         }
1623     }
1624
1625     if (track->type && matroska->num_tracks < ARRAY_SIZE(matroska->tracks)) {
1626         matroska->tracks[matroska->num_tracks++] = track;
1627     } else {
1628         av_free(track);
1629     }
1630     return res;
1631 }
1632
1633 static int
1634 matroska_parse_tracks (MatroskaDemuxContext *matroska)
1635 {
1636     int res = 0;
1637     uint32_t id;
1638
1639     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing tracks...\n");
1640
1641     while (res == 0) {
1642         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1643             res = AVERROR(EIO);
1644             break;
1645         } else if (matroska->level_up) {
1646             matroska->level_up--;
1647             break;
1648         }
1649
1650         switch (id) {
1651             /* one track within the "all-tracks" header */
1652             case MATROSKA_ID_TRACKENTRY:
1653                 res = matroska_add_stream(matroska);
1654                 break;
1655
1656             default:
1657                 av_log(matroska->ctx, AV_LOG_INFO,
1658                        "Unknown entry 0x%x in track header\n", id);
1659                 /* fall-through */
1660
1661             case EBML_ID_VOID:
1662                 res = ebml_read_skip(matroska);
1663                 break;
1664         }
1665
1666         if (matroska->level_up) {
1667             matroska->level_up--;
1668             break;
1669         }
1670     }
1671
1672     return res;
1673 }
1674
1675 static int
1676 matroska_parse_index (MatroskaDemuxContext *matroska)
1677 {
1678     int res = 0;
1679     uint32_t id;
1680     MatroskaDemuxIndex idx;
1681
1682     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing index...\n");
1683
1684     while (res == 0) {
1685         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1686             res = AVERROR(EIO);
1687             break;
1688         } else if (matroska->level_up) {
1689             matroska->level_up--;
1690             break;
1691         }
1692
1693         switch (id) {
1694             /* one single index entry ('point') */
1695             case MATROSKA_ID_POINTENTRY:
1696                 if ((res = ebml_read_master(matroska, &id)) < 0)
1697                     break;
1698
1699                 /* in the end, we hope to fill one entry with a
1700                  * timestamp, a file position and a tracknum */
1701                 idx.pos   = (uint64_t) -1;
1702                 idx.time  = (uint64_t) -1;
1703                 idx.track = (uint16_t) -1;
1704
1705                 while (res == 0) {
1706                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1707                         res = AVERROR(EIO);
1708                         break;
1709                     } else if (matroska->level_up) {
1710                         matroska->level_up--;
1711                         break;
1712                     }
1713
1714                     switch (id) {
1715                         /* one single index entry ('point') */
1716                         case MATROSKA_ID_CUETIME: {
1717                             uint64_t time;
1718                             if ((res = ebml_read_uint(matroska, &id,
1719                                                       &time)) < 0)
1720                                 break;
1721                             idx.time = time * matroska->time_scale;
1722                             break;
1723                         }
1724
1725                         /* position in the file + track to which it
1726                          * belongs */
1727                         case MATROSKA_ID_CUETRACKPOSITION:
1728                             if ((res = ebml_read_master(matroska, &id)) < 0)
1729                                 break;
1730
1731                             while (res == 0) {
1732                                 if (!(id = ebml_peek_id (matroska,
1733                                                     &matroska->level_up))) {
1734                                     res = AVERROR(EIO);
1735                                     break;
1736                                 } else if (matroska->level_up) {
1737                                     matroska->level_up--;
1738                                     break;
1739                                 }
1740
1741                                 switch (id) {
1742                                     /* track number */
1743                                     case MATROSKA_ID_CUETRACK: {
1744                                         uint64_t num;
1745                                         if ((res = ebml_read_uint(matroska,
1746                                                           &id, &num)) < 0)
1747                                             break;
1748                                         idx.track = num;
1749                                         break;
1750                                     }
1751
1752                                         /* position in file */
1753                                     case MATROSKA_ID_CUECLUSTERPOSITION: {
1754                                         uint64_t num;
1755                                         if ((res = ebml_read_uint(matroska,
1756                                                           &id, &num)) < 0)
1757                                             break;
1758                                         idx.pos = num+matroska->segment_start;
1759                                         break;
1760                                     }
1761
1762                                     default:
1763                                         av_log(matroska->ctx, AV_LOG_INFO,
1764                                                "Unknown entry 0x%x in "
1765                                                "CuesTrackPositions\n", id);
1766                                         /* fall-through */
1767
1768                                     case EBML_ID_VOID:
1769                                         res = ebml_read_skip(matroska);
1770                                         break;
1771                                 }
1772
1773                                 if (matroska->level_up) {
1774                                     matroska->level_up--;
1775                                     break;
1776                                 }
1777                             }
1778
1779                             break;
1780
1781                         default:
1782                             av_log(matroska->ctx, AV_LOG_INFO,
1783                                    "Unknown entry 0x%x in cuespoint "
1784                                    "index\n", id);
1785                             /* fall-through */
1786
1787                         case EBML_ID_VOID:
1788                             res = ebml_read_skip(matroska);
1789                             break;
1790                     }
1791
1792                     if (matroska->level_up) {
1793                         matroska->level_up--;
1794                         break;
1795                     }
1796                 }
1797
1798                 /* so let's see if we got what we wanted */
1799                 if (idx.pos   != (uint64_t) -1 &&
1800                     idx.time  != (uint64_t) -1 &&
1801                     idx.track != (uint16_t) -1) {
1802                     if (matroska->num_indexes % 32 == 0) {
1803                         /* re-allocate bigger index */
1804                         matroska->index =
1805                             av_realloc(matroska->index,
1806                                        (matroska->num_indexes + 32) *
1807                                        sizeof(MatroskaDemuxIndex));
1808                     }
1809                     matroska->index[matroska->num_indexes] = idx;
1810                     matroska->num_indexes++;
1811                 }
1812                 break;
1813
1814             default:
1815                 av_log(matroska->ctx, AV_LOG_INFO,
1816                        "Unknown entry 0x%x in cues header\n", id);
1817                 /* fall-through */
1818
1819             case EBML_ID_VOID:
1820                 res = ebml_read_skip(matroska);
1821                 break;
1822         }
1823
1824         if (matroska->level_up) {
1825             matroska->level_up--;
1826             break;
1827         }
1828     }
1829
1830     return res;
1831 }
1832
1833 static int
1834 matroska_parse_metadata (MatroskaDemuxContext *matroska)
1835 {
1836     int res = 0;
1837     uint32_t id;
1838
1839     while (res == 0) {
1840         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1841             res = AVERROR(EIO);
1842             break;
1843         } else if (matroska->level_up) {
1844             matroska->level_up--;
1845             break;
1846         }
1847
1848         switch (id) {
1849             /* Hm, this is unsupported... */
1850             default:
1851                 av_log(matroska->ctx, AV_LOG_INFO,
1852                        "Unknown entry 0x%x in metadata header\n", id);
1853                 /* fall-through */
1854
1855             case EBML_ID_VOID:
1856                 res = ebml_read_skip(matroska);
1857                 break;
1858         }
1859
1860         if (matroska->level_up) {
1861             matroska->level_up--;
1862             break;
1863         }
1864     }
1865
1866     return res;
1867 }
1868
1869 static int
1870 matroska_parse_seekhead (MatroskaDemuxContext *matroska)
1871 {
1872     int res = 0;
1873     uint32_t id;
1874
1875     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing seekhead...\n");
1876
1877     while (res == 0) {
1878         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1879             res = AVERROR(EIO);
1880             break;
1881         } else if (matroska->level_up) {
1882             matroska->level_up--;
1883             break;
1884         }
1885
1886         switch (id) {
1887             case MATROSKA_ID_SEEKENTRY: {
1888                 uint32_t seek_id = 0, peek_id_cache = 0;
1889                 uint64_t seek_pos = (uint64_t) -1, t;
1890
1891                 if ((res = ebml_read_master(matroska, &id)) < 0)
1892                     break;
1893
1894                 while (res == 0) {
1895                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1896                         res = AVERROR(EIO);
1897                         break;
1898                     } else if (matroska->level_up) {
1899                         matroska->level_up--;
1900                         break;
1901                     }
1902
1903                     switch (id) {
1904                         case MATROSKA_ID_SEEKID:
1905                             res = ebml_read_uint(matroska, &id, &t);
1906                             seek_id = t;
1907                             break;
1908
1909                         case MATROSKA_ID_SEEKPOSITION:
1910                             res = ebml_read_uint(matroska, &id, &seek_pos);
1911                             break;
1912
1913                         default:
1914                             av_log(matroska->ctx, AV_LOG_INFO,
1915                                    "Unknown seekhead ID 0x%x\n", id);
1916                             /* fall-through */
1917
1918                         case EBML_ID_VOID:
1919                             res = ebml_read_skip(matroska);
1920                             break;
1921                     }
1922
1923                     if (matroska->level_up) {
1924                         matroska->level_up--;
1925                         break;
1926                     }
1927                 }
1928
1929                 if (!seek_id || seek_pos == (uint64_t) -1) {
1930                     av_log(matroska->ctx, AV_LOG_INFO,
1931                            "Incomplete seekhead entry (0x%x/%"PRIu64")\n",
1932                            seek_id, seek_pos);
1933                     break;
1934                 }
1935
1936                 switch (seek_id) {
1937                     case MATROSKA_ID_CUES:
1938                     case MATROSKA_ID_TAGS: {
1939                         uint32_t level_up = matroska->level_up;
1940                         offset_t before_pos;
1941                         uint64_t length;
1942                         MatroskaLevel level;
1943
1944                         /* remember the peeked ID and the current position */
1945                         peek_id_cache = matroska->peek_id;
1946                         before_pos = url_ftell(matroska->ctx->pb);
1947
1948                         /* seek */
1949                         if ((res = ebml_read_seek(matroska, seek_pos +
1950                                                matroska->segment_start)) < 0)
1951                             goto finish;
1952
1953                         /* we don't want to lose our seekhead level, so we add
1954                          * a dummy. This is a crude hack. */
1955                         if (matroska->num_levels == EBML_MAX_DEPTH) {
1956                             av_log(matroska->ctx, AV_LOG_INFO,
1957                                    "Max EBML element depth (%d) reached, "
1958                                    "cannot parse further.\n", EBML_MAX_DEPTH);
1959                             return AVERROR_UNKNOWN;
1960                         }
1961
1962                         level.start = 0;
1963                         level.length = (uint64_t)-1;
1964                         matroska->levels[matroska->num_levels] = level;
1965                         matroska->num_levels++;
1966
1967                         /* check ID */
1968                         if (!(id = ebml_peek_id (matroska,
1969                                                  &matroska->level_up)))
1970                             goto finish;
1971                         if (id != seek_id) {
1972                             av_log(matroska->ctx, AV_LOG_INFO,
1973                                    "We looked for ID=0x%x but got "
1974                                    "ID=0x%x (pos=%"PRIu64")",
1975                                    seek_id, id, seek_pos +
1976                                    matroska->segment_start);
1977                             goto finish;
1978                         }
1979
1980                         /* read master + parse */
1981                         if ((res = ebml_read_master(matroska, &id)) < 0)
1982                             goto finish;
1983                         switch (id) {
1984                             case MATROSKA_ID_CUES:
1985                                 if (!(res = matroska_parse_index(matroska)) ||
1986                                     url_feof(matroska->ctx->pb)) {
1987                                     matroska->index_parsed = 1;
1988                                     res = 0;
1989                                 }
1990                                 break;
1991                             case MATROSKA_ID_TAGS:
1992                                 if (!(res = matroska_parse_metadata(matroska)) ||
1993                                    url_feof(matroska->ctx->pb)) {
1994                                     matroska->metadata_parsed = 1;
1995                                     res = 0;
1996                                 }
1997                                 break;
1998                         }
1999
2000                     finish:
2001                         /* remove dummy level */
2002                         while (matroska->num_levels) {
2003                             matroska->num_levels--;
2004                             length =
2005                                 matroska->levels[matroska->num_levels].length;
2006                             if (length == (uint64_t)-1)
2007                                 break;
2008                         }
2009
2010                         /* seek back */
2011                         if ((res = ebml_read_seek(matroska, before_pos)) < 0)
2012                             return res;
2013                         matroska->peek_id = peek_id_cache;
2014                         matroska->level_up = level_up;
2015                         break;
2016                     }
2017
2018                     default:
2019                         av_log(matroska->ctx, AV_LOG_INFO,
2020                                "Ignoring seekhead entry for ID=0x%x\n",
2021                                seek_id);
2022                         break;
2023                 }
2024
2025                 break;
2026             }
2027
2028             default:
2029                 av_log(matroska->ctx, AV_LOG_INFO,
2030                        "Unknown seekhead ID 0x%x\n", id);
2031                 /* fall-through */
2032
2033             case EBML_ID_VOID:
2034                 res = ebml_read_skip(matroska);
2035                 break;
2036         }
2037
2038         if (matroska->level_up) {
2039             matroska->level_up--;
2040             break;
2041         }
2042     }
2043
2044     return res;
2045 }
2046
2047 static int
2048 matroska_parse_attachments(AVFormatContext *s)
2049 {
2050     MatroskaDemuxContext *matroska = s->priv_data;
2051     int res = 0;
2052     uint32_t id;
2053
2054     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing attachments...\n");
2055
2056     while (res == 0) {
2057         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2058             res = AVERROR(EIO);
2059             break;
2060         } else if (matroska->level_up) {
2061             matroska->level_up--;
2062             break;
2063         }
2064
2065         switch (id) {
2066         case MATROSKA_ID_ATTACHEDFILE: {
2067             char* name = NULL;
2068             char* mime = NULL;
2069             uint8_t* data = NULL;
2070             int i, data_size = 0;
2071             AVStream *st;
2072
2073             if ((res = ebml_read_master(matroska, &id)) < 0)
2074                 break;
2075
2076             while (res == 0) {
2077                 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2078                     res = AVERROR(EIO);
2079                     break;
2080                 } else if (matroska->level_up) {
2081                     matroska->level_up--;
2082                     break;
2083                 }
2084
2085                 switch (id) {
2086                 case MATROSKA_ID_FILENAME:
2087                     res = ebml_read_utf8 (matroska, &id, &name);
2088                     break;
2089
2090                 case MATROSKA_ID_FILEMIMETYPE:
2091                     res = ebml_read_ascii (matroska, &id, &mime);
2092                     break;
2093
2094                 case MATROSKA_ID_FILEDATA:
2095                     res = ebml_read_binary(matroska, &id, &data, &data_size);
2096                     break;
2097
2098                 default:
2099                     av_log(matroska->ctx, AV_LOG_INFO,
2100                            "Unknown attachedfile ID 0x%x\n", id);
2101                 case MATROSKA_ID_FILEUID:
2102                 case EBML_ID_VOID:
2103                     res = ebml_read_skip(matroska);
2104                     break;
2105                 }
2106
2107                 if (matroska->level_up) {
2108                     matroska->level_up--;
2109                     break;
2110                 }
2111             }
2112
2113             if (!(name && mime && data && data_size > 0)) {
2114                 av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
2115                 break;
2116             }
2117
2118             st = av_new_stream(s, matroska->num_streams++);
2119             if (st == NULL)
2120                 return AVERROR(ENOMEM);
2121             st->filename = av_strdup(name);
2122             st->codec->codec_id = CODEC_ID_NONE;
2123             st->codec->codec_type = CODEC_TYPE_ATTACHMENT;
2124             st->codec->extradata = av_malloc(data_size);
2125             if(st->codec->extradata == NULL)
2126                 return AVERROR(ENOMEM);
2127             st->codec->extradata_size = data_size;
2128             memcpy(st->codec->extradata, data, data_size);
2129
2130             for (i=0; ff_mkv_mime_tags[i].id != CODEC_ID_NONE; i++) {
2131                 if (!strncmp(ff_mkv_mime_tags[i].str, mime,
2132                              strlen(ff_mkv_mime_tags[i].str))) {
2133                     st->codec->codec_id = ff_mkv_mime_tags[i].id;
2134                     break;
2135                 }
2136             }
2137
2138             av_log(matroska->ctx, AV_LOG_DEBUG, "new attachment: %s, %s, size %d \n", name, mime, data_size);
2139             break;
2140         }
2141
2142         default:
2143             av_log(matroska->ctx, AV_LOG_INFO,
2144                    "Unknown attachments ID 0x%x\n", id);
2145             /* fall-through */
2146
2147         case EBML_ID_VOID:
2148             res = ebml_read_skip(matroska);
2149             break;
2150         }
2151
2152         if (matroska->level_up) {
2153             matroska->level_up--;
2154             break;
2155         }
2156     }
2157
2158     return res;
2159 }
2160
2161 static int
2162 matroska_parse_chapters(AVFormatContext *s)
2163 {
2164     MatroskaDemuxContext *matroska = s->priv_data;
2165     int res = 0;
2166     uint32_t id;
2167
2168     av_log(s, AV_LOG_DEBUG, "parsing chapters...\n");
2169
2170     while (res == 0) {
2171         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2172             res = AVERROR(EIO);
2173             break;
2174         } else if (matroska->level_up) {
2175             matroska->level_up--;
2176             break;
2177         }
2178
2179         switch (id) {
2180         case MATROSKA_ID_EDITIONENTRY: {
2181             uint64_t end = AV_NOPTS_VALUE, start = AV_NOPTS_VALUE;
2182             int64_t uid= -1;
2183             char* title = NULL;
2184             /* if there is more than one chapter edition
2185                we take only the first one */
2186             if(s->chapters) {
2187                     ebml_read_skip(matroska);
2188                     break;
2189             }
2190
2191             if ((res = ebml_read_master(matroska, &id)) < 0)
2192                 break;
2193
2194             while (res == 0) {
2195                 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2196                     res = AVERROR(EIO);
2197                     break;
2198                 } else if (matroska->level_up) {
2199                     matroska->level_up--;
2200                     break;
2201                 }
2202
2203                 switch (id) {
2204                 case MATROSKA_ID_CHAPTERATOM:
2205                     if ((res = ebml_read_master(matroska, &id)) < 0)
2206                         break;
2207
2208                     while (res == 0) {
2209                         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2210                             res = AVERROR(EIO);
2211                             break;
2212                         } else if (matroska->level_up) {
2213                             matroska->level_up--;
2214                             break;
2215                         }
2216
2217                         switch (id) {
2218                         case MATROSKA_ID_CHAPTERTIMEEND:
2219                             res = ebml_read_uint(matroska, &id, &end);
2220                             break;
2221
2222                         case MATROSKA_ID_CHAPTERTIMESTART:
2223                             res = ebml_read_uint(matroska, &id, &start);
2224                             break;
2225
2226                         case MATROSKA_ID_CHAPTERDISPLAY:
2227                             if ((res = ebml_read_master(matroska, &id)) < 0)
2228                                 break;
2229
2230                             while (res == 0) {
2231                                 if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2232                                     res = AVERROR(EIO);
2233                                     break;
2234                                 } else if (matroska->level_up) {
2235                                     matroska->level_up--;
2236                                     break;
2237                                 }
2238
2239                                 switch (id) {
2240                                 case MATROSKA_ID_CHAPSTRING:
2241                                     res = ebml_read_utf8(matroska, &id, &title);
2242                                     break;
2243
2244                                 default:
2245                                     av_log(s, AV_LOG_INFO, "Ignoring unknown Chapter display ID 0x%x\n", id);
2246                                 case EBML_ID_VOID:
2247                                     res = ebml_read_skip(matroska);
2248                                     break;
2249                                 }
2250
2251                                 if (matroska->level_up) {
2252                                     matroska->level_up--;
2253                                     break;
2254                                 }
2255                             }
2256                             break;
2257
2258                         case MATROSKA_ID_CHAPTERUID:
2259                             res = ebml_read_uint(matroska, &id, &uid);
2260                             break;
2261                         default:
2262                             av_log(s, AV_LOG_INFO, "Ignoring unknown Chapter atom ID 0x%x\n", id);
2263                         case MATROSKA_ID_CHAPTERFLAGHIDDEN:
2264                         case EBML_ID_VOID:
2265                             res = ebml_read_skip(matroska);
2266                             break;
2267                         }
2268
2269                         if (matroska->level_up) {
2270                             matroska->level_up--;
2271                             break;
2272                         }
2273                     }
2274
2275                     if (start != AV_NOPTS_VALUE && uid != -1) {
2276                         if(!ff_new_chapter(s, uid, (AVRational){1, 1000000000}, start, end, title))
2277                             res= AVERROR(ENOMEM);
2278                     }
2279                     av_free(title);
2280                     break;
2281
2282                 default:
2283                     av_log(s, AV_LOG_INFO, "Ignoring unknown Edition entry ID 0x%x\n", id);
2284                 case MATROSKA_ID_EDITIONUID:
2285                 case MATROSKA_ID_EDITIONFLAGHIDDEN:
2286                 case MATROSKA_ID_EDITIONFLAGDEFAULT:
2287                 case EBML_ID_VOID:
2288                     res = ebml_read_skip(matroska);
2289                     break;
2290                 }
2291
2292
2293                 if (matroska->level_up) {
2294                     matroska->level_up--;
2295                     break;
2296                 }
2297             }
2298         break;
2299         }
2300
2301         default:
2302             av_log(s, AV_LOG_INFO, "Expected an Edition entry (0x%x), but found 0x%x\n", MATROSKA_ID_EDITIONENTRY, id);
2303         case EBML_ID_VOID:
2304             res = ebml_read_skip(matroska);
2305             break;
2306         }
2307
2308         if (matroska->level_up) {
2309             matroska->level_up--;
2310             break;
2311         }
2312     }
2313
2314     return res;
2315 }
2316
2317 static int
2318 matroska_aac_profile (char *codec_id)
2319 {
2320     static const char *aac_profiles[] = {
2321         "MAIN", "LC", "SSR"
2322     };
2323     int profile;
2324
2325     for (profile=0; profile<ARRAY_SIZE(aac_profiles); profile++)
2326         if (strstr(codec_id, aac_profiles[profile]))
2327             break;
2328     return profile + 1;
2329 }
2330
2331 static int
2332 matroska_aac_sri (int samplerate)
2333 {
2334     int sri;
2335
2336     for (sri=0; sri<ARRAY_SIZE(ff_mpeg4audio_sample_rates); sri++)
2337         if (ff_mpeg4audio_sample_rates[sri] == samplerate)
2338             break;
2339     return sri;
2340 }
2341
2342 static int
2343 matroska_read_header (AVFormatContext    *s,
2344                       AVFormatParameters *ap)
2345 {
2346     MatroskaDemuxContext *matroska = s->priv_data;
2347     char *doctype;
2348     int version, last_level, res = 0;
2349     uint32_t id;
2350
2351     matroska->ctx = s;
2352
2353     /* First read the EBML header. */
2354     doctype = NULL;
2355     if ((res = ebml_read_header(matroska, &doctype, &version)) < 0)
2356         return res;
2357     if ((doctype == NULL) || strcmp(doctype, "matroska")) {
2358         av_log(matroska->ctx, AV_LOG_ERROR,
2359                "Wrong EBML doctype ('%s' != 'matroska').\n",
2360                doctype ? doctype : "(none)");
2361         if (doctype)
2362             av_free(doctype);
2363         return AVERROR_NOFMT;
2364     }
2365     av_free(doctype);
2366     if (version > 2) {
2367         av_log(matroska->ctx, AV_LOG_ERROR,
2368                "Matroska demuxer version 2 too old for file version %d\n",
2369                version);
2370         return AVERROR_NOFMT;
2371     }
2372
2373     /* The next thing is a segment. */
2374     while (1) {
2375         if (!(id = ebml_peek_id(matroska, &last_level)))
2376             return AVERROR(EIO);
2377         if (id == MATROSKA_ID_SEGMENT)
2378             break;
2379
2380         /* oi! */
2381         av_log(matroska->ctx, AV_LOG_INFO,
2382                "Expected a Segment ID (0x%x), but received 0x%x!\n",
2383                MATROSKA_ID_SEGMENT, id);
2384         if ((res = ebml_read_skip(matroska)) < 0)
2385             return res;
2386     }
2387
2388     /* We now have a Matroska segment.
2389      * Seeks are from the beginning of the segment,
2390      * after the segment ID/length. */
2391     if ((res = ebml_read_master(matroska, &id)) < 0)
2392         return res;
2393     matroska->segment_start = url_ftell(s->pb);
2394
2395     matroska->time_scale = 1000000;
2396     /* we've found our segment, start reading the different contents in here */
2397     while (res == 0) {
2398         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2399             res = AVERROR(EIO);
2400             break;
2401         } else if (matroska->level_up) {
2402             matroska->level_up--;
2403             break;
2404         }
2405
2406         switch (id) {
2407             /* stream info */
2408             case MATROSKA_ID_INFO: {
2409                 if ((res = ebml_read_master(matroska, &id)) < 0)
2410                     break;
2411                 res = matroska_parse_info(matroska);
2412                 break;
2413             }
2414
2415             /* track info headers */
2416             case MATROSKA_ID_TRACKS: {
2417                 if ((res = ebml_read_master(matroska, &id)) < 0)
2418                     break;
2419                 res = matroska_parse_tracks(matroska);
2420                 break;
2421             }
2422
2423             /* stream index */
2424             case MATROSKA_ID_CUES: {
2425                 if (!matroska->index_parsed) {
2426                     if ((res = ebml_read_master(matroska, &id)) < 0)
2427                         break;
2428                     res = matroska_parse_index(matroska);
2429                 } else
2430                     res = ebml_read_skip(matroska);
2431                 break;
2432             }
2433
2434             /* metadata */
2435             case MATROSKA_ID_TAGS: {
2436                 if (!matroska->metadata_parsed) {
2437                     if ((res = ebml_read_master(matroska, &id)) < 0)
2438                         break;
2439                     res = matroska_parse_metadata(matroska);
2440                 } else
2441                     res = ebml_read_skip(matroska);
2442                 break;
2443             }
2444
2445             /* file index (if seekable, seek to Cues/Tags to parse it) */
2446             case MATROSKA_ID_SEEKHEAD: {
2447                 if ((res = ebml_read_master(matroska, &id)) < 0)
2448                     break;
2449                 res = matroska_parse_seekhead(matroska);
2450                 break;
2451             }
2452
2453             case MATROSKA_ID_ATTACHMENTS: {
2454                 if ((res = ebml_read_master(matroska, &id)) < 0)
2455                     break;
2456                 res = matroska_parse_attachments(s);
2457                 break;
2458             }
2459
2460             case MATROSKA_ID_CLUSTER: {
2461                 /* Do not read the master - this will be done in the next
2462                  * call to matroska_read_packet. */
2463                 res = 1;
2464                 break;
2465             }
2466
2467             case MATROSKA_ID_CHAPTERS: {
2468                 if ((res = ebml_read_master(matroska, &id)) < 0)
2469                     return res;
2470                 res = matroska_parse_chapters(s);
2471                 break;
2472             }
2473
2474             default:
2475                 av_log(matroska->ctx, AV_LOG_INFO,
2476                        "Unknown matroska file header ID 0x%x\n", id);
2477             /* fall-through */
2478
2479             case EBML_ID_VOID:
2480                 res = ebml_read_skip(matroska);
2481                 break;
2482         }
2483
2484         if (matroska->level_up) {
2485             matroska->level_up--;
2486             break;
2487         }
2488     }
2489
2490     /* Have we found a cluster? */
2491     if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) {
2492         int i, j;
2493         MatroskaTrack *track;
2494         AVStream *st;
2495
2496         for (i = 0; i < matroska->num_tracks; i++) {
2497             enum CodecID codec_id = CODEC_ID_NONE;
2498             uint8_t *extradata = NULL;
2499             int extradata_size = 0;
2500             int extradata_offset = 0;
2501             track = matroska->tracks[i];
2502             track->stream_index = -1;
2503
2504             /* Apply some sanity checks. */
2505             if (track->codec_id == NULL)
2506                 continue;
2507
2508             for(j=0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++){
2509                 if(!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
2510                             strlen(ff_mkv_codec_tags[j].str))){
2511                     codec_id= ff_mkv_codec_tags[j].id;
2512                     break;
2513                 }
2514             }
2515
2516             /* Set the FourCC from the CodecID. */
2517             /* This is the MS compatibility mode which stores a
2518              * BITMAPINFOHEADER in the CodecPrivate. */
2519             if (!strcmp(track->codec_id,
2520                         MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&
2521                 (track->codec_priv_size >= 40) &&
2522                 (track->codec_priv != NULL)) {
2523                 MatroskaVideoTrack *vtrack = (MatroskaVideoTrack *) track;
2524
2525                 /* Offset of biCompression. Stored in LE. */
2526                 vtrack->fourcc = AV_RL32(track->codec_priv + 16);
2527                 codec_id = codec_get_id(codec_bmp_tags, vtrack->fourcc);
2528
2529             }
2530
2531             /* This is the MS compatibility mode which stores a
2532              * WAVEFORMATEX in the CodecPrivate. */
2533             else if (!strcmp(track->codec_id,
2534                              MATROSKA_CODEC_ID_AUDIO_ACM) &&
2535                 (track->codec_priv_size >= 18) &&
2536                 (track->codec_priv != NULL)) {
2537                 uint16_t tag;
2538
2539                 /* Offset of wFormatTag. Stored in LE. */
2540                 tag = AV_RL16(track->codec_priv);
2541                 codec_id = codec_get_id(codec_wav_tags, tag);
2542
2543             }
2544
2545             else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {
2546                 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
2547                 int profile = matroska_aac_profile(track->codec_id);
2548                 int sri = matroska_aac_sri(audiotrack->internal_samplerate);
2549                 extradata = av_malloc(5);
2550                 if (extradata == NULL)
2551                     return AVERROR(ENOMEM);
2552                 extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
2553                 extradata[1] = ((sri&0x01) << 7) | (audiotrack->channels<<3);
2554                 if (strstr(track->codec_id, "SBR")) {
2555                     sri = matroska_aac_sri(audiotrack->samplerate);
2556                     extradata[2] = 0x56;
2557                     extradata[3] = 0xE5;
2558                     extradata[4] = 0x80 | (sri<<3);
2559                     extradata_size = 5;
2560                 } else {
2561                     extradata_size = 2;
2562                 }
2563             }
2564
2565             else if (codec_id == CODEC_ID_TTA) {
2566                 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
2567                 ByteIOContext b;
2568                 extradata_size = 30;
2569                 extradata = av_mallocz(extradata_size);
2570                 if (extradata == NULL)
2571                     return AVERROR(ENOMEM);
2572                 init_put_byte(&b, extradata, extradata_size, 1,
2573                               NULL, NULL, NULL, NULL);
2574                 put_buffer(&b, "TTA1", 4);
2575                 put_le16(&b, 1);
2576                 put_le16(&b, audiotrack->channels);
2577                 put_le16(&b, audiotrack->bitdepth);
2578                 put_le32(&b, audiotrack->samplerate);
2579                 put_le32(&b, matroska->ctx->duration * audiotrack->samplerate);
2580             }
2581
2582             else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
2583                      codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
2584                 extradata_offset = 26;
2585                 track->codec_priv_size -= extradata_offset;
2586             }
2587
2588             else if (codec_id == CODEC_ID_RA_144) {
2589                 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2590                 audiotrack->samplerate = 8000;
2591                 audiotrack->channels = 1;
2592             }
2593
2594             else if (codec_id == CODEC_ID_RA_288 ||
2595                      codec_id == CODEC_ID_COOK ||
2596                      codec_id == CODEC_ID_ATRAC3) {
2597                 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2598                 ByteIOContext b;
2599
2600                 init_put_byte(&b, track->codec_priv, track->codec_priv_size, 0,
2601                               NULL, NULL, NULL, NULL);
2602                 url_fskip(&b, 24);
2603                 audiotrack->coded_framesize = get_be32(&b);
2604                 url_fskip(&b, 12);
2605                 audiotrack->sub_packet_h    = get_be16(&b);
2606                 audiotrack->frame_size      = get_be16(&b);
2607                 audiotrack->sub_packet_size = get_be16(&b);
2608                 audiotrack->buf = av_malloc(audiotrack->frame_size * audiotrack->sub_packet_h);
2609                 if (codec_id == CODEC_ID_RA_288) {
2610                     audiotrack->block_align = audiotrack->coded_framesize;
2611                     track->codec_priv_size = 0;
2612                 } else {
2613                     audiotrack->block_align = audiotrack->sub_packet_size;
2614                     extradata_offset = 78;
2615                     track->codec_priv_size -= extradata_offset;
2616                 }
2617             }
2618
2619             if (codec_id == CODEC_ID_NONE) {
2620                 av_log(matroska->ctx, AV_LOG_INFO,
2621                        "Unknown/unsupported CodecID %s.\n",
2622                        track->codec_id);
2623             }
2624
2625             track->stream_index = matroska->num_streams;
2626
2627             matroska->num_streams++;
2628             st = av_new_stream(s, track->stream_index);
2629             if (st == NULL)
2630                 return AVERROR(ENOMEM);
2631             av_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
2632
2633             st->codec->codec_id = codec_id;
2634             st->start_time = 0;
2635             if (strcmp(track->language, "und"))
2636                 strcpy(st->language, track->language);
2637
2638             if (track->flags & MATROSKA_TRACK_DEFAULT)
2639                 st->disposition |= AV_DISPOSITION_DEFAULT;
2640
2641             if (track->default_duration)
2642                 av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
2643                           track->default_duration, 1000000000, 30000);
2644
2645             if(extradata){
2646                 st->codec->extradata = extradata;
2647                 st->codec->extradata_size = extradata_size;
2648             } else if(track->codec_priv && track->codec_priv_size > 0){
2649                 st->codec->extradata = av_malloc(track->codec_priv_size);
2650                 if(st->codec->extradata == NULL)
2651                     return AVERROR(ENOMEM);
2652                 st->codec->extradata_size = track->codec_priv_size;
2653                 memcpy(st->codec->extradata,track->codec_priv+extradata_offset,
2654                        track->codec_priv_size);
2655             }
2656
2657             if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2658                 MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
2659
2660                 st->codec->codec_type = CODEC_TYPE_VIDEO;
2661                 st->codec->codec_tag = videotrack->fourcc;
2662                 st->codec->width = videotrack->pixel_width;
2663                 st->codec->height = videotrack->pixel_height;
2664                 if (videotrack->display_width == 0)
2665                     videotrack->display_width= videotrack->pixel_width;
2666                 if (videotrack->display_height == 0)
2667                     videotrack->display_height= videotrack->pixel_height;
2668                 av_reduce(&st->codec->sample_aspect_ratio.num,
2669                           &st->codec->sample_aspect_ratio.den,
2670                           st->codec->height * videotrack->display_width,
2671                           st->codec-> width * videotrack->display_height,
2672                           255);
2673                 st->need_parsing = AVSTREAM_PARSE_HEADERS;
2674             } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2675                 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2676
2677                 st->codec->codec_type = CODEC_TYPE_AUDIO;
2678                 st->codec->sample_rate = audiotrack->samplerate;
2679                 st->codec->channels = audiotrack->channels;
2680                 st->codec->block_align = audiotrack->block_align;
2681             } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
2682                 st->codec->codec_type = CODEC_TYPE_SUBTITLE;
2683             }
2684
2685             /* What do we do with private data? E.g. for Vorbis. */
2686         }
2687         res = 0;
2688     }
2689
2690     if (matroska->index_parsed) {
2691         int i, track, stream;
2692         for (i=0; i<matroska->num_indexes; i++) {
2693             MatroskaDemuxIndex *idx = &matroska->index[i];
2694             track = matroska_find_track_by_num(matroska, idx->track);
2695             if (track < 0)  continue;
2696             stream = matroska->tracks[track]->stream_index;
2697             if (stream >= 0 && stream < matroska->ctx->nb_streams)
2698                 av_add_index_entry(matroska->ctx->streams[stream],
2699                                    idx->pos, idx->time/AV_TIME_BASE,
2700                                    0, 0, AVINDEX_KEYFRAME);
2701         }
2702     }
2703
2704     return res;
2705 }
2706
2707 static int
2708 matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size,
2709                      int64_t pos, uint64_t cluster_time, uint64_t duration,
2710                      int is_keyframe, int is_bframe)
2711 {
2712     int res = 0;
2713     int track;
2714     AVStream *st;
2715     AVPacket *pkt;
2716     uint8_t *origdata = data;
2717     int16_t block_time;
2718     uint32_t *lace_size = NULL;
2719     int n, flags, laces = 0;
2720     uint64_t num;
2721     int stream_index;
2722
2723     /* first byte(s): tracknum */
2724     if ((n = matroska_ebmlnum_uint(data, size, &num)) < 0) {
2725         av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
2726         av_free(origdata);
2727         return res;
2728     }
2729     data += n;
2730     size -= n;
2731
2732     /* fetch track from num */
2733     track = matroska_find_track_by_num(matroska, num);
2734     if (size <= 3 || track < 0 || track >= matroska->num_tracks) {
2735         av_log(matroska->ctx, AV_LOG_INFO,
2736                "Invalid stream %d or size %u\n", track, size);
2737         av_free(origdata);
2738         return res;
2739     }
2740     stream_index = matroska->tracks[track]->stream_index;
2741     if (stream_index < 0 || stream_index >= matroska->ctx->nb_streams) {
2742         av_free(origdata);
2743         return res;
2744     }
2745     st = matroska->ctx->streams[stream_index];
2746     if (st->discard >= AVDISCARD_ALL) {
2747         av_free(origdata);
2748         return res;
2749     }
2750     if (duration == AV_NOPTS_VALUE)
2751         duration = matroska->tracks[track]->default_duration / matroska->time_scale;
2752
2753     /* block_time (relative to cluster time) */
2754     block_time = AV_RB16(data);
2755     data += 2;
2756     flags = *data++;
2757     size -= 3;
2758     if (is_keyframe == -1)
2759         is_keyframe = flags & 0x80 ? PKT_FLAG_KEY : 0;
2760
2761     if (matroska->skip_to_keyframe) {
2762         if (!is_keyframe || st != matroska->skip_to_stream) {
2763             av_free(origdata);
2764             return res;
2765         }
2766         matroska->skip_to_keyframe = 0;
2767     }
2768
2769     switch ((flags & 0x06) >> 1) {
2770         case 0x0: /* no lacing */
2771             laces = 1;
2772             lace_size = av_mallocz(sizeof(int));
2773             lace_size[0] = size;
2774             break;
2775
2776         case 0x1: /* xiph lacing */
2777         case 0x2: /* fixed-size lacing */
2778         case 0x3: /* EBML lacing */
2779             assert(size>0); // size <=3 is checked before size-=3 above
2780             laces = (*data) + 1;
2781             data += 1;
2782             size -= 1;
2783             lace_size = av_mallocz(laces * sizeof(int));
2784
2785             switch ((flags & 0x06) >> 1) {
2786                 case 0x1: /* xiph lacing */ {
2787                     uint8_t temp;
2788                     uint32_t total = 0;
2789                     for (n = 0; res == 0 && n < laces - 1; n++) {
2790                         while (1) {
2791                             if (size == 0) {
2792                                 res = -1;
2793                                 break;
2794                             }
2795                             temp = *data;
2796                             lace_size[n] += temp;
2797                             data += 1;
2798                             size -= 1;
2799                             if (temp != 0xff)
2800                                 break;
2801                         }
2802                         total += lace_size[n];
2803                     }
2804                     lace_size[n] = size - total;
2805                     break;
2806                 }
2807
2808                 case 0x2: /* fixed-size lacing */
2809                     for (n = 0; n < laces; n++)
2810                         lace_size[n] = size / laces;
2811                     break;
2812
2813                 case 0x3: /* EBML lacing */ {
2814                     uint32_t total;
2815                     n = matroska_ebmlnum_uint(data, size, &num);
2816                     if (n < 0) {
2817                         av_log(matroska->ctx, AV_LOG_INFO,
2818                                "EBML block data error\n");
2819                         break;
2820                     }
2821                     data += n;
2822                     size -= n;
2823                     total = lace_size[0] = num;
2824                     for (n = 1; res == 0 && n < laces - 1; n++) {
2825                         int64_t snum;
2826                         int r;
2827                         r = matroska_ebmlnum_sint (data, size, &snum);
2828                         if (r < 0) {
2829                             av_log(matroska->ctx, AV_LOG_INFO,
2830                                    "EBML block data error\n");
2831                             break;
2832                         }
2833                         data += r;
2834                         size -= r;
2835                         lace_size[n] = lace_size[n - 1] + snum;
2836                         total += lace_size[n];
2837                     }
2838                     lace_size[n] = size - total;
2839                     break;
2840                 }
2841             }
2842             break;
2843     }
2844
2845     if (res == 0) {
2846         uint64_t timecode = AV_NOPTS_VALUE;
2847
2848         if (cluster_time != (uint64_t)-1
2849             && (block_time >= 0 || cluster_time >= -block_time))
2850             timecode = cluster_time + block_time;
2851
2852         for (n = 0; n < laces; n++) {
2853             if (st->codec->codec_id == CODEC_ID_RA_288 ||
2854                 st->codec->codec_id == CODEC_ID_COOK ||
2855                 st->codec->codec_id == CODEC_ID_ATRAC3) {
2856                 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)matroska->tracks[track];
2857                 int a = st->codec->block_align;
2858                 int sps = audiotrack->sub_packet_size;
2859                 int cfs = audiotrack->coded_framesize;
2860                 int h = audiotrack->sub_packet_h;
2861                 int y = audiotrack->sub_packet_cnt;
2862                 int w = audiotrack->frame_size;
2863                 int x;
2864
2865                 if (!audiotrack->pkt_cnt) {
2866                     if (st->codec->codec_id == CODEC_ID_RA_288)
2867                         for (x=0; x<h/2; x++)
2868                             memcpy(audiotrack->buf+x*2*w+y*cfs,
2869                                    data+x*cfs, cfs);
2870                     else
2871                         for (x=0; x<w/sps; x++)
2872                             memcpy(audiotrack->buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps);
2873
2874                     if (++audiotrack->sub_packet_cnt >= h) {
2875                         audiotrack->sub_packet_cnt = 0;
2876                         audiotrack->pkt_cnt = h*w / a;
2877                     }
2878                 }
2879                 while (audiotrack->pkt_cnt) {
2880                     pkt = av_mallocz(sizeof(AVPacket));
2881                     av_new_packet(pkt, a);
2882                     memcpy(pkt->data, audiotrack->buf
2883                            + a * (h*w / a - audiotrack->pkt_cnt--), a);
2884                     pkt->pos = pos;
2885                     pkt->stream_index = stream_index;
2886                     matroska_queue_packet(matroska, pkt);
2887                 }
2888             } else {
2889                 int result, offset = 0, ilen, olen, pkt_size = lace_size[n];
2890                 uint8_t *pkt_data = data;
2891
2892                 if (matroska->tracks[track]->encoding_scope & 1) {
2893                     switch (matroska->tracks[track]->encoding_algo) {
2894                     case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP:
2895                         offset = matroska->tracks[track]->encoding_settings_len;
2896                         break;
2897                     case MATROSKA_TRACK_ENCODING_COMP_LZO:
2898                         pkt_data = NULL;
2899                         do {
2900                             ilen = lace_size[n];
2901                             olen = pkt_size *= 3;
2902                             pkt_data = av_realloc(pkt_data,
2903                                                   pkt_size+LZO_OUTPUT_PADDING);
2904                             result = lzo1x_decode(pkt_data, &olen, data, &ilen);
2905                         } while (result==LZO_OUTPUT_FULL && pkt_size<10000000);
2906                         if (result) {
2907                             av_free(pkt_data);
2908                             continue;
2909                         }
2910                         pkt_size -= olen;
2911                         break;
2912 #ifdef CONFIG_ZLIB
2913                     case MATROSKA_TRACK_ENCODING_COMP_ZLIB: {
2914                         z_stream zstream = {0};
2915                         pkt_data = NULL;
2916                         if (inflateInit(&zstream) != Z_OK)
2917                             continue;
2918                         zstream.next_in = data;
2919                         zstream.avail_in = lace_size[n];
2920                         do {
2921                             pkt_size *= 3;
2922                             pkt_data = av_realloc(pkt_data, pkt_size);
2923                             zstream.avail_out = pkt_size - zstream.total_out;
2924                             zstream.next_out = pkt_data + zstream.total_out;
2925                             result = inflate(&zstream, Z_NO_FLUSH);
2926                         } while (result==Z_OK && pkt_size<10000000);
2927                         pkt_size = zstream.total_out;
2928                         inflateEnd(&zstream);
2929                         if (result != Z_STREAM_END) {
2930                             av_free(pkt_data);
2931                             continue;
2932                         }
2933                         break;
2934                     }
2935 #endif
2936 #ifdef CONFIG_BZLIB
2937                     case MATROSKA_TRACK_ENCODING_COMP_BZLIB: {
2938                         bz_stream bzstream = {0};
2939                         pkt_data = NULL;
2940                         if (BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
2941                             continue;
2942                         bzstream.next_in = data;
2943                         bzstream.avail_in = lace_size[n];
2944                         do {
2945                             pkt_size *= 3;
2946                             pkt_data = av_realloc(pkt_data, pkt_size);
2947                             bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
2948                             bzstream.next_out = pkt_data + bzstream.total_out_lo32;
2949                             result = BZ2_bzDecompress(&bzstream);
2950                         } while (result==BZ_OK && pkt_size<10000000);
2951                         pkt_size = bzstream.total_out_lo32;
2952                         BZ2_bzDecompressEnd(&bzstream);
2953                         if (result != BZ_STREAM_END) {
2954                             av_free(pkt_data);
2955                             continue;
2956                         }
2957                         break;
2958                     }
2959 #endif
2960                     }
2961                 }
2962
2963                 pkt = av_mallocz(sizeof(AVPacket));
2964                 /* XXX: prevent data copy... */
2965                 if (av_new_packet(pkt, pkt_size+offset) < 0) {
2966                     av_free(pkt);
2967                     res = AVERROR(ENOMEM);
2968                     n = laces-1;
2969                     break;
2970                 }
2971                 if (offset)
2972                     memcpy (pkt->data, matroska->tracks[track]->encoding_settings, offset);
2973                 memcpy (pkt->data+offset, pkt_data, pkt_size);
2974
2975                 if (n == 0)
2976                     pkt->flags = is_keyframe;
2977                 pkt->stream_index = stream_index;
2978
2979                 pkt->pts = timecode;
2980                 pkt->pos = pos;
2981                 pkt->duration = duration;
2982
2983                 matroska_queue_packet(matroska, pkt);
2984             }
2985
2986             if (timecode != AV_NOPTS_VALUE)
2987                 timecode = duration ? timecode + duration : AV_NOPTS_VALUE;
2988             data += lace_size[n];
2989         }
2990     }
2991
2992     av_free(lace_size);
2993     av_free(origdata);
2994     return res;
2995 }
2996
2997 static int
2998 matroska_parse_blockgroup (MatroskaDemuxContext *matroska,
2999                            uint64_t              cluster_time)
3000 {
3001     int res = 0;
3002     uint32_t id;
3003     int is_bframe = 0;
3004     int is_keyframe = PKT_FLAG_KEY, last_num_packets = matroska->num_packets;
3005     uint64_t duration = AV_NOPTS_VALUE;
3006     uint8_t *data;
3007     int size = 0;
3008     int64_t pos = 0;
3009
3010     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing blockgroup...\n");
3011
3012     while (res == 0) {
3013         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
3014             res = AVERROR(EIO);
3015             break;
3016         } else if (matroska->level_up) {
3017             matroska->level_up--;
3018             break;
3019         }
3020
3021         switch (id) {
3022             /* one block inside the group. Note, block parsing is one
3023              * of the harder things, so this code is a bit complicated.
3024              * See http://www.matroska.org/ for documentation. */
3025             case MATROSKA_ID_BLOCK: {
3026                 pos = url_ftell(matroska->ctx->pb);
3027                 res = ebml_read_binary(matroska, &id, &data, &size);
3028                 break;
3029             }
3030
3031             case MATROSKA_ID_BLOCKDURATION: {
3032                 if ((res = ebml_read_uint(matroska, &id, &duration)) < 0)
3033                     break;
3034                 break;
3035             }
3036
3037             case MATROSKA_ID_BLOCKREFERENCE: {
3038                 int64_t num;
3039                 /* We've found a reference, so not even the first frame in
3040                  * the lace is a key frame. */
3041                 is_keyframe = 0;
3042                 if (last_num_packets != matroska->num_packets)
3043                     matroska->packets[last_num_packets]->flags = 0;
3044                 if ((res = ebml_read_sint(matroska, &id, &num)) < 0)
3045                     break;
3046                 if (num > 0)
3047                     is_bframe = 1;
3048                 break;
3049             }
3050
3051             default:
3052                 av_log(matroska->ctx, AV_LOG_INFO,
3053                        "Unknown entry 0x%x in blockgroup data\n", id);
3054                 /* fall-through */
3055
3056             case EBML_ID_VOID:
3057                 res = ebml_read_skip(matroska);
3058                 break;
3059         }
3060
3061         if (matroska->level_up) {
3062             matroska->level_up--;
3063             break;
3064         }
3065     }
3066
3067     if (res)
3068         return res;
3069
3070     if (size > 0)
3071         res = matroska_parse_block(matroska, data, size, pos, cluster_time,
3072                                    duration, is_keyframe, is_bframe);
3073
3074     return res;
3075 }
3076
3077 static int
3078 matroska_parse_cluster (MatroskaDemuxContext *matroska)
3079 {
3080     int res = 0;
3081     uint32_t id;
3082     uint64_t cluster_time = 0;
3083     uint8_t *data;
3084     int64_t pos;
3085     int size;
3086
3087     av_log(matroska->ctx, AV_LOG_DEBUG,
3088            "parsing cluster at %"PRId64"\n", url_ftell(matroska->ctx->pb));
3089
3090     while (res == 0) {
3091         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
3092             res = AVERROR(EIO);
3093             break;
3094         } else if (matroska->level_up) {
3095             matroska->level_up--;
3096             break;
3097         }
3098
3099         switch (id) {
3100             /* cluster timecode */
3101             case MATROSKA_ID_CLUSTERTIMECODE: {
3102                 uint64_t num;
3103                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
3104                     break;
3105                 cluster_time = num;
3106                 break;
3107             }
3108
3109                 /* a group of blocks inside a cluster */
3110             case MATROSKA_ID_BLOCKGROUP:
3111                 if ((res = ebml_read_master(matroska, &id)) < 0)
3112                     break;
3113                 res = matroska_parse_blockgroup(matroska, cluster_time);
3114                 break;
3115
3116             case MATROSKA_ID_SIMPLEBLOCK:
3117                 pos = url_ftell(matroska->ctx->pb);
3118                 res = ebml_read_binary(matroska, &id, &data, &size);
3119                 if (res == 0)
3120                     res = matroska_parse_block(matroska, data, size, pos,
3121                                                cluster_time, AV_NOPTS_VALUE,
3122                                                -1, 0);
3123                 break;
3124
3125             default:
3126                 av_log(matroska->ctx, AV_LOG_INFO,
3127                        "Unknown entry 0x%x in cluster data\n", id);
3128                 /* fall-through */
3129
3130             case EBML_ID_VOID:
3131                 res = ebml_read_skip(matroska);
3132                 break;
3133         }
3134
3135         if (matroska->level_up) {
3136             matroska->level_up--;
3137             break;
3138         }
3139     }
3140
3141     return res;
3142 }
3143
3144 static int
3145 matroska_read_packet (AVFormatContext *s,
3146                       AVPacket        *pkt)
3147 {
3148     MatroskaDemuxContext *matroska = s->priv_data;
3149     int res;
3150     uint32_t id;
3151
3152     /* Read stream until we have a packet queued. */
3153     while (matroska_deliver_packet(matroska, pkt)) {
3154
3155         /* Have we already reached the end? */
3156         if (matroska->done)
3157             return AVERROR(EIO);
3158
3159         res = 0;
3160         while (res == 0) {
3161             if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
3162                 return AVERROR(EIO);
3163             } else if (matroska->level_up) {
3164                 matroska->level_up--;
3165                 break;
3166             }
3167
3168             switch (id) {
3169                 case MATROSKA_ID_CLUSTER:
3170                     if ((res = ebml_read_master(matroska, &id)) < 0)
3171                         break;
3172                     if ((res = matroska_parse_cluster(matroska)) == 0)
3173                         res = 1; /* Parsed one cluster, let's get out. */
3174                     break;
3175
3176                 default:
3177                 case EBML_ID_VOID:
3178                     res = ebml_read_skip(matroska);
3179                     break;
3180             }
3181
3182             if (matroska->level_up) {
3183                 matroska->level_up--;
3184                 break;
3185             }
3186         }
3187
3188         if (res == -1)
3189             matroska->done = 1;
3190     }
3191
3192     return 0;
3193 }
3194
3195 static int
3196 matroska_read_seek (AVFormatContext *s, int stream_index, int64_t timestamp,
3197                     int flags)
3198 {
3199     MatroskaDemuxContext *matroska = s->priv_data;
3200     AVStream *st = s->streams[stream_index];
3201     int index;
3202
3203     /* find index entry */
3204     index = av_index_search_timestamp(st, timestamp, flags);
3205     if (index < 0)
3206         return 0;
3207
3208     matroska_clear_queue(matroska);
3209
3210     /* do the seek */
3211     url_fseek(s->pb, st->index_entries[index].pos, SEEK_SET);
3212     matroska->skip_to_keyframe = !(flags & AVSEEK_FLAG_ANY);
3213     matroska->skip_to_stream = st;
3214     matroska->peek_id = 0;
3215     return 0;
3216 }
3217
3218 static int
3219 matroska_read_close (AVFormatContext *s)
3220 {
3221     MatroskaDemuxContext *matroska = s->priv_data;
3222     int n = 0;
3223
3224     av_free(matroska->writing_app);
3225     av_free(matroska->muxing_app);
3226     av_free(matroska->index);
3227
3228     matroska_clear_queue(matroska);
3229
3230     for (n = 0; n < matroska->num_tracks; n++) {
3231         MatroskaTrack *track = matroska->tracks[n];
3232         av_free(track->codec_id);
3233         av_free(track->codec_name);
3234         av_free(track->codec_priv);
3235         av_free(track->name);
3236
3237         if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
3238             MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
3239             av_free(audiotrack->buf);
3240         }
3241
3242         av_free(track);
3243     }
3244
3245     return 0;
3246 }
3247
3248 AVInputFormat matroska_demuxer = {
3249     "matroska",
3250     "Matroska file format",
3251     sizeof(MatroskaDemuxContext),
3252     matroska_probe,
3253     matroska_read_header,
3254     matroska_read_packet,
3255     matroska_read_close,
3256     matroska_read_seek,
3257 };