2c92431e71a2ff2f4f16f6eae587dbb9f4e764ff
[ffmpeg.git] / libavformat / matroska.c
1 /*
2  * Matroska file demuxer (no muxer yet)
3  * Copyright (c) 2003-2004 The ffmpeg Project
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19
20 /**
21  * @file matroska.c
22  * Matroska file demuxer
23  * by Ronald Bultje <rbultje@ronald.bitfreak.net>
24  * with a little help from Moritz Bunkus <moritz@bunkus.org>
25  * Specs available on the matroska project page:
26  * http://www.matroska.org/.
27  */
28
29 #include "avformat.h"
30 /* For codec_get_bmp_id and codec_get_wav_id. */
31 #include "avi.h"
32 #include "intfloat_readwrite.h"
33
34 /* EBML version supported */
35 #define EBML_VERSION 1
36
37 /* top-level master-IDs */
38 #define EBML_ID_HEADER             0x1A45DFA3
39
40 /* IDs in the HEADER master */
41 #define EBML_ID_EBMLVERSION        0x4286
42 #define EBML_ID_EBMLREADVERSION    0x42F7
43 #define EBML_ID_EBMLMAXIDLENGTH    0x42F2
44 #define EBML_ID_EBMLMAXSIZELENGTH  0x42F3
45 #define EBML_ID_DOCTYPE            0x4282
46 #define EBML_ID_DOCTYPEVERSION     0x4287
47 #define EBML_ID_DOCTYPEREADVERSION 0x4285
48
49 /* general EBML types */
50 #define EBML_ID_VOID               0xEC
51
52 /*
53  * Matroska element IDs. max. 32-bit.
54  */
55
56 /* toplevel segment */
57 #define MATROSKA_ID_SEGMENT    0x18538067
58
59 /* matroska top-level master IDs */
60 #define MATROSKA_ID_INFO       0x1549A966
61 #define MATROSKA_ID_TRACKS     0x1654AE6B
62 #define MATROSKA_ID_CUES       0x1C53BB6B
63 #define MATROSKA_ID_TAGS       0x1254C367
64 #define MATROSKA_ID_SEEKHEAD   0x114D9B74
65 #define MATROSKA_ID_CLUSTER    0x1F43B675
66
67 /* IDs in the info master */
68 #define MATROSKA_ID_TIMECODESCALE 0x2AD7B1
69 #define MATROSKA_ID_DURATION   0x4489
70 #define MATROSKA_ID_WRITINGAPP 0x5741
71 #define MATROSKA_ID_MUXINGAPP  0x4D80
72 #define MATROSKA_ID_DATEUTC    0x4461
73
74 /* ID in the tracks master */
75 #define MATROSKA_ID_TRACKENTRY 0xAE
76
77 /* IDs in the trackentry master */
78 #define MATROSKA_ID_TRACKNUMBER 0xD7
79 #define MATROSKA_ID_TRACKUID   0x73C5
80 #define MATROSKA_ID_TRACKTYPE  0x83
81 #define MATROSKA_ID_TRACKAUDIO 0xE1
82 #define MATROSKA_ID_TRACKVIDEO 0xE0
83 #define MATROSKA_ID_CODECID    0x86
84 #define MATROSKA_ID_CODECPRIVATE 0x63A2
85 #define MATROSKA_ID_CODECNAME  0x258688
86 #define MATROSKA_ID_CODECINFOURL 0x3B4040
87 #define MATROSKA_ID_CODECDOWNLOADURL 0x26B240
88 #define MATROSKA_ID_TRACKNAME  0x536E
89 #define MATROSKA_ID_TRACKLANGUAGE 0x22B59C
90 #define MATROSKA_ID_TRACKFLAGENABLED 0xB9
91 #define MATROSKA_ID_TRACKFLAGDEFAULT 0x88
92 #define MATROSKA_ID_TRACKFLAGLACING 0x9C
93 #define MATROSKA_ID_TRACKMINCACHE 0x6DE7
94 #define MATROSKA_ID_TRACKMAXCACHE 0x6DF8
95 #define MATROSKA_ID_TRACKDEFAULTDURATION 0x23E383
96
97 /* IDs in the trackvideo master */
98 #define MATROSKA_ID_VIDEOFRAMERATE 0x2383E3
99 #define MATROSKA_ID_VIDEODISPLAYWIDTH 0x54B0
100 #define MATROSKA_ID_VIDEODISPLAYHEIGHT 0x54BA
101 #define MATROSKA_ID_VIDEOPIXELWIDTH 0xB0
102 #define MATROSKA_ID_VIDEOPIXELHEIGHT 0xBA
103 #define MATROSKA_ID_VIDEOFLAGINTERLACED 0x9A
104 #define MATROSKA_ID_VIDEOSTEREOMODE 0x53B9
105 #define MATROSKA_ID_VIDEOASPECTRATIO 0x54B3
106 #define MATROSKA_ID_VIDEOCOLOURSPACE 0x2EB524
107
108 /* IDs in the trackaudio master */
109 #define MATROSKA_ID_AUDIOSAMPLINGFREQ 0xB5
110 #define MATROSKA_ID_AUDIOBITDEPTH 0x6264
111 #define MATROSKA_ID_AUDIOCHANNELS 0x9F
112
113 /* ID in the cues master */
114 #define MATROSKA_ID_POINTENTRY 0xBB
115
116 /* IDs in the pointentry master */
117 #define MATROSKA_ID_CUETIME    0xB3
118 #define MATROSKA_ID_CUETRACKPOSITION 0xB7
119
120 /* IDs in the cuetrackposition master */
121 #define MATROSKA_ID_CUETRACK   0xF7
122 #define MATROSKA_ID_CUECLUSTERPOSITION 0xF1
123
124 /* IDs in the tags master */
125 /* TODO */
126
127 /* IDs in the seekhead master */
128 #define MATROSKA_ID_SEEKENTRY  0x4DBB
129
130 /* IDs in the seekpoint master */
131 #define MATROSKA_ID_SEEKID     0x53AB
132 #define MATROSKA_ID_SEEKPOSITION 0x53AC
133
134 /* IDs in the cluster master */
135 #define MATROSKA_ID_CLUSTERTIMECODE 0xE7
136 #define MATROSKA_ID_BLOCKGROUP 0xA0
137
138 /* IDs in the blockgroup master */
139 #define MATROSKA_ID_BLOCK      0xA1
140 #define MATROSKA_ID_BLOCKDURATION 0x9B
141 #define MATROSKA_ID_BLOCKREFERENCE 0xFB
142
143 typedef enum {
144   MATROSKA_TRACK_TYPE_VIDEO    = 0x1,
145   MATROSKA_TRACK_TYPE_AUDIO    = 0x2,
146   MATROSKA_TRACK_TYPE_COMPLEX  = 0x3,
147   MATROSKA_TRACK_TYPE_LOGO     = 0x10,
148   MATROSKA_TRACK_TYPE_SUBTITLE = 0x11,
149   MATROSKA_TRACK_TYPE_CONTROL  = 0x20,
150 } MatroskaTrackType;
151
152 typedef enum {
153   MATROSKA_EYE_MODE_MONO  = 0x0,
154   MATROSKA_EYE_MODE_RIGHT = 0x1,
155   MATROSKA_EYE_MODE_LEFT  = 0x2,
156   MATROSKA_EYE_MODE_BOTH  = 0x3,
157 } MatroskaEyeMode;
158
159 typedef enum {
160   MATROSKA_ASPECT_RATIO_MODE_FREE  = 0x0,
161   MATROSKA_ASPECT_RATIO_MODE_KEEP  = 0x1,
162   MATROSKA_ASPECT_RATIO_MODE_FIXED = 0x2,
163 } MatroskaAspectRatioMode;
164
165 /*
166  * These aren't in any way "matroska-form" things,
167  * it's just something I use in the muxer/demuxer.
168  */
169
170 typedef enum {
171   MATROSKA_TRACK_ENABLED = (1<<0),
172   MATROSKA_TRACK_DEFAULT = (1<<1),
173   MATROSKA_TRACK_LACING  = (1<<2),
174   MATROSKA_TRACK_SHIFT   = (1<<16)
175 } MatroskaTrackFlags;
176
177 typedef enum {
178   MATROSKA_VIDEOTRACK_INTERLACED = (MATROSKA_TRACK_SHIFT<<0)
179 } MatroskaVideoTrackFlags;
180
181 /*
182  * Matroska Codec IDs. Strings.
183  */
184
185 #define MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC   "V_MS/VFW/FOURCC"
186 #define MATROSKA_CODEC_ID_VIDEO_UNCOMPRESSED "V_UNCOMPRESSED"
187 #define MATROSKA_CODEC_ID_VIDEO_MPEG4_SP     "V_MPEG4/ISO/SP"
188 #define MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP    "V_MPEG4/ISO/ASP"
189 #define MATROSKA_CODEC_ID_VIDEO_MPEG4_AP     "V_MPEG4/ISO/AP"
190 #define MATROSKA_CODEC_ID_VIDEO_MPEG4_AVC    "V_MPEG4/ISO/AVC"
191 #define MATROSKA_CODEC_ID_VIDEO_MSMPEG4V3    "V_MPEG4/MS/V3"
192 #define MATROSKA_CODEC_ID_VIDEO_MPEG1        "V_MPEG1"
193 #define MATROSKA_CODEC_ID_VIDEO_MPEG2        "V_MPEG2"
194 #define MATROSKA_CODEC_ID_VIDEO_MJPEG        "V_MJPEG"
195 /* TODO: Real/Quicktime */
196
197 #define MATROSKA_CODEC_ID_AUDIO_ACM          "A_MS/ACM"
198 #define MATROSKA_CODEC_ID_AUDIO_MPEG1_L1     "A_MPEG/L1"
199 #define MATROSKA_CODEC_ID_AUDIO_MPEG1_L2     "A_MPEG/L2"
200 #define MATROSKA_CODEC_ID_AUDIO_MPEG1_L3     "A_MPEG/L3"
201 #define MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE   "A_PCM/INT/BIG"
202 #define MATROSKA_CODEC_ID_AUDIO_PCM_INT_LE   "A_PCM/INT/LIT"
203 #define MATROSKA_CODEC_ID_AUDIO_PCM_FLOAT    "A_PCM/FLOAT/IEEE"
204 #define MATROSKA_CODEC_ID_AUDIO_AC3          "A_AC3"
205 #define MATROSKA_CODEC_ID_AUDIO_DTS          "A_DTS"
206 #define MATROSKA_CODEC_ID_AUDIO_VORBIS       "A_VORBIS"
207 #define MATROSKA_CODEC_ID_AUDIO_ACM          "A_MS/ACM"
208 #define MATROSKA_CODEC_ID_AUDIO_MPEG2        "A_AAC/MPEG2/"
209 #define MATROSKA_CODEC_ID_AUDIO_MPEG4        "A_AAC/MPEG4/"
210 /* TODO: AC3-9/10 (?), Real, Musepack, Quicktime */
211
212 /* max. depth in the EBML tree structure */
213 #define EBML_MAX_DEPTH 16
214
215 typedef struct Track {
216     MatroskaTrackType type;
217
218     /* Unique track number and track ID. stream_index is the index that
219      * the calling app uses for this track. */
220     uint32_t num,
221         uid,
222         stream_index;
223
224     char *name,
225         *language;
226
227     char *codec_id,
228         *codec_name;
229
230     unsigned char *codec_priv;
231     int codec_priv_size;
232
233     int64_t default_duration;
234     MatroskaTrackFlags flags;
235 } MatroskaTrack;
236
237 typedef struct MatroskaVideoTrack {
238     MatroskaTrack track;
239
240     int pixel_width,
241         pixel_height,
242         display_width,
243         display_height;
244
245     uint32_t fourcc;
246
247     MatroskaAspectRatioMode ar_mode;
248     MatroskaEyeMode eye_mode;
249
250     //..
251 } MatroskaVideoTrack;
252
253 typedef struct MatroskaAudioTrack {
254     MatroskaTrack track;
255
256     int channels,
257         bitdepth,
258         samplerate;
259     //..
260 } MatroskaAudioTrack;
261
262 typedef struct MatroskaSubtitleTrack {
263     MatroskaTrack track;
264
265     //..
266 } MatroskaSubtitleTrack;
267
268 typedef struct MatroskaLevel {
269     uint64_t start, length;
270 } MatroskaLevel;
271
272 typedef struct MatroskaDemuxIndex {
273   uint64_t        pos;   /* of the corresponding *cluster*! */
274   uint16_t        track; /* reference to 'num' */
275   uint64_t        time;  /* in nanoseconds */
276 } MatroskaDemuxIndex;
277
278 typedef struct MatroskaDemuxContext {
279     AVFormatContext *ctx;
280
281     /* ebml stuff */
282     int num_levels;
283     MatroskaLevel levels[EBML_MAX_DEPTH];
284     int level_up;
285
286     /* matroska stuff */
287     char *writing_app,
288         *muxing_app;
289     int64_t created;
290
291     /* timescale in the file */
292     int64_t time_scale;
293
294     /* length, position (time, ns) */
295     int64_t duration,
296         pos;
297
298     /* num_streams is the number of streams that av_new_stream() was called
299      * for ( = that are available to the calling program). */
300     int num_tracks, num_streams;
301     MatroskaTrack *tracks[MAX_STREAMS];
302
303     /* cache for ID peeking */
304     uint32_t peek_id;
305
306     /* byte position of the segment inside the stream */
307     offset_t segment_start;
308
309     /* The packet queue. */
310     AVPacket **packets;
311     int num_packets;
312
313     /* have we already parse metadata/cues/clusters? */
314     int metadata_parsed,
315         index_parsed,
316         done;
317
318     /* The index for seeking. */
319     int num_indexes;
320     MatroskaDemuxIndex *index;
321 } MatroskaDemuxContext;
322
323 /*
324  * The first few functions handle EBML file parsing. The rest
325  * is the document interpretation. Matroska really just is a
326  * EBML file.
327  */
328
329 /*
330  * Return: the amount of levels in the hierarchy that the
331  * current element lies higher than the previous one.
332  * The opposite isn't done - that's auto-done using master
333  * element reading.
334  */
335
336 static int
337 ebml_read_element_level_up (MatroskaDemuxContext *matroska)
338 {
339     ByteIOContext *pb = &matroska->ctx->pb;
340     offset_t pos = url_ftell(pb);
341     int num = 0;
342
343     while (matroska->num_levels > 0) {
344         MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
345
346         if (pos >= level->start + level->length) {
347             matroska->num_levels--;
348             num++;
349         } else {
350             break;
351         }
352     }
353
354     return num;
355 }
356
357 /*
358  * Read: an "EBML number", which is defined as a variable-length
359  * array of bytes. The first byte indicates the length by giving a
360  * number of 0-bits followed by a one. The position of the first
361  * "one" bit inside the first byte indicates the length of this
362  * number.
363  * Returns: num. of bytes read. < 0 on error.
364  */
365
366 static int
367 ebml_read_num (MatroskaDemuxContext *matroska,
368                int                   max_size,
369                uint64_t             *number)
370 {
371     ByteIOContext *pb = &matroska->ctx->pb;
372     int len_mask = 0x80, read = 1, n = 1;
373     int64_t total = 0;
374
375     /* the first byte tells us the length in bytes - get_byte() can normally
376      * return 0, but since that's not a valid first ebmlID byte, we can
377      * use it safely here to catch EOS. */
378     if (!(total = get_byte(pb))) {
379         /* we might encounter EOS here */
380         if (!url_feof(pb)) {
381             offset_t pos = url_ftell(pb);
382             av_log(matroska->ctx, AV_LOG_ERROR,
383                    "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
384                    pos, pos);
385         }
386         return AVERROR_IO; /* EOS or actual I/O error */
387     }
388
389     /* get the length of the EBML number */
390     while (read <= max_size && !(total & len_mask)) {
391         read++;
392         len_mask >>= 1;
393     }
394     if (read > max_size) {
395         offset_t pos = url_ftell(pb) - 1;
396         av_log(matroska->ctx, AV_LOG_ERROR,
397                "Invalid EBML number size tag 0x%02x at pos %"PRIu64" (0x%"PRIx64")\n",
398                (uint8_t) total, pos, pos);
399         return AVERROR_INVALIDDATA;
400     }
401
402     /* read out length */
403     total &= ~len_mask;
404     while (n++ < read)
405         total = (total << 8) | get_byte(pb);
406
407     *number = total;
408
409     return read;
410 }
411
412 /*
413  * Read: the element content data ID.
414  * Return: the number of bytes read or < 0 on error.
415  */
416
417 static int
418 ebml_read_element_id (MatroskaDemuxContext *matroska,
419                       uint32_t             *id,
420                       int                  *level_up)
421 {
422     int read;
423     uint64_t total;
424
425     /* if we re-call this, use our cached ID */
426     if (matroska->peek_id != 0) {
427         if (level_up)
428             *level_up = 0;
429         *id = matroska->peek_id;
430         return 0;
431     }
432
433     /* read out the "EBML number", include tag in ID */
434     if ((read = ebml_read_num(matroska, 4, &total)) < 0)
435         return read;
436     *id = matroska->peek_id  = total | (1 << (read * 7));
437
438     /* level tracking */
439     if (level_up)
440         *level_up = ebml_read_element_level_up(matroska);
441
442     return read;
443 }
444
445 /*
446  * Read: element content length.
447  * Return: the number of bytes read or < 0 on error.
448  */
449
450 static int
451 ebml_read_element_length (MatroskaDemuxContext *matroska,
452                           uint64_t             *length)
453 {
454     /* clear cache since we're now beyond that data point */
455     matroska->peek_id = 0;
456
457     /* read out the "EBML number", include tag in ID */
458     return ebml_read_num(matroska, 8, length);
459 }
460
461 /*
462  * Return: the ID of the next element, or 0 on error.
463  * Level_up contains the amount of levels that this
464  * next element lies higher than the previous one.
465  */
466
467 static uint32_t
468 ebml_peek_id (MatroskaDemuxContext *matroska,
469               int                  *level_up)
470 {
471     uint32_t id;
472
473     assert(level_up != NULL);
474
475     if (ebml_read_element_id(matroska, &id, level_up) < 0)
476         return 0;
477
478     return id;
479 }
480
481 /*
482  * Seek to a given offset.
483  * 0 is success, -1 is failure.
484  */
485
486 static int
487 ebml_read_seek (MatroskaDemuxContext *matroska,
488                 offset_t              offset)
489 {
490     ByteIOContext *pb = &matroska->ctx->pb;
491
492     /* clear ID cache, if any */
493     matroska->peek_id = 0;
494
495     return (url_fseek(pb, offset, SEEK_SET) == offset) ? 0 : -1;
496 }
497
498 /*
499  * Skip the next element.
500  * 0 is success, -1 is failure.
501  */
502
503 static int
504 ebml_read_skip (MatroskaDemuxContext *matroska)
505 {
506     ByteIOContext *pb = &matroska->ctx->pb;
507     uint32_t id;
508     uint64_t length;
509     int res;
510
511     if ((res = ebml_read_element_id(matroska, &id, NULL)) < 0 ||
512         (res = ebml_read_element_length(matroska, &length)) < 0)
513         return res;
514
515     url_fskip(pb, length);
516
517     return 0;
518 }
519
520 /*
521  * Read the next element as an unsigned int.
522  * 0 is success, < 0 is failure.
523  */
524
525 static int
526 ebml_read_uint (MatroskaDemuxContext *matroska,
527                 uint32_t             *id,
528                 uint64_t             *num)
529 {
530     ByteIOContext *pb = &matroska->ctx->pb;
531     int n = 0, size, res;
532     uint64_t rlength;
533
534     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
535         (res = ebml_read_element_length(matroska, &rlength)) < 0)
536         return res;
537     size = rlength;
538     if (size < 1 || size > 8) {
539         offset_t pos = url_ftell(pb);
540         av_log(matroska->ctx, AV_LOG_ERROR,
541                "Invalid uint element size %d at position %"PRId64" (0x%"PRIx64")\n",
542                 size, pos, pos);
543         return AVERROR_INVALIDDATA;
544     }
545
546     /* big-endian ordening; build up number */
547     *num = 0;
548     while (n++ < size)
549         *num = (*num << 8) | get_byte(pb);
550
551     return 0;
552 }
553
554 /*
555  * Read the next element as a signed int.
556  * 0 is success, < 0 is failure.
557  */
558
559 static int
560 ebml_read_sint (MatroskaDemuxContext *matroska,
561                 uint32_t             *id,
562                 int64_t              *num)
563 {
564     ByteIOContext *pb = &matroska->ctx->pb;
565     int size, n = 1, negative = 0, res;
566     uint64_t rlength;
567
568     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
569         (res = ebml_read_element_length(matroska, &rlength)) < 0)
570         return res;
571     size = rlength;
572     if (size < 1 || size > 8) {
573         offset_t pos = url_ftell(pb);
574         av_log(matroska->ctx, AV_LOG_ERROR,
575                "Invalid sint element size %d at position %"PRId64" (0x%"PRIx64")\n",
576                 size, pos, pos);
577         return AVERROR_INVALIDDATA;
578     }
579     if ((*num = get_byte(pb)) & 0x80) {
580         negative = 1;
581         *num &= ~0x80;
582     }
583     *num = 0;
584     while (n++ < size)
585         *num = (*num << 8) | get_byte(pb);
586
587     /* make signed */
588     if (negative)
589         *num = *num - (1LL << ((8 * size) - 1));
590
591     return 0;
592 }
593
594 /*
595  * Read the next element as a float.
596  * 0 is success, < 0 is failure.
597  */
598
599 static int
600 ebml_read_float (MatroskaDemuxContext *matroska,
601                  uint32_t             *id,
602                  double               *num)
603 {
604     ByteIOContext *pb = &matroska->ctx->pb;
605     int size, res;
606     uint64_t rlength;
607
608     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
609         (res = ebml_read_element_length(matroska, &rlength)) < 0)
610         return res;
611     size = rlength;
612
613     if (size == 4) {
614         *num= av_int2flt(get_be32(pb));
615     } else if(size==8){
616         *num= av_int2dbl(get_be64(pb));
617     } else if(size==10){
618         av_log(matroska->ctx, AV_LOG_ERROR,
619                "FIXME! 10-byte floats unimplemented\n");
620         return AVERROR_UNKNOWN;
621     } else{
622         offset_t pos = url_ftell(pb);
623         av_log(matroska->ctx, AV_LOG_ERROR,
624                "Invalid float element size %d at position %"PRIu64" (0x%"PRIx64")\n",
625                size, pos, pos);
626         return AVERROR_INVALIDDATA;
627     }
628
629     return 0;
630 }
631
632 /*
633  * Read the next element as an ASCII string.
634  * 0 is success, < 0 is failure.
635  */
636
637 static int
638 ebml_read_ascii (MatroskaDemuxContext *matroska,
639                  uint32_t             *id,
640                  char                **str)
641 {
642     ByteIOContext *pb = &matroska->ctx->pb;
643     int size, res;
644     uint64_t rlength;
645
646     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
647         (res = ebml_read_element_length(matroska, &rlength)) < 0)
648         return res;
649     size = rlength;
650
651     /* ebml strings are usually not 0-terminated, so we allocate one
652      * byte more, read the string and NULL-terminate it ourselves. */
653     if (size < 0 || !(*str = av_malloc(size + 1))) {
654         av_log(matroska->ctx, AV_LOG_ERROR, "Memory allocation failed\n");
655         return AVERROR_NOMEM;
656     }
657     if (get_buffer(pb, (uint8_t *) *str, size) != size) {
658         offset_t pos = url_ftell(pb);
659         av_log(matroska->ctx, AV_LOG_ERROR,
660                "Read error at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
661         return AVERROR_IO;
662     }
663     (*str)[size] = '\0';
664
665     return 0;
666 }
667
668 /*
669  * Read the next element as a UTF-8 string.
670  * 0 is success, < 0 is failure.
671  */
672
673 static int
674 ebml_read_utf8 (MatroskaDemuxContext *matroska,
675                 uint32_t             *id,
676                 char                **str)
677 {
678   return ebml_read_ascii(matroska, id, str);
679 }
680
681 /*
682  * Read the next element as a date (nanoseconds since 1/1/2000).
683  * 0 is success, < 0 is failure.
684  */
685
686 static int
687 ebml_read_date (MatroskaDemuxContext *matroska,
688                 uint32_t             *id,
689                 int64_t              *date)
690 {
691   return ebml_read_sint(matroska, id, date);
692 }
693
694 /*
695  * Read the next element, but only the header. The contents
696  * are supposed to be sub-elements which can be read separately.
697  * 0 is success, < 0 is failure.
698  */
699
700 static int
701 ebml_read_master (MatroskaDemuxContext *matroska,
702                   uint32_t             *id)
703 {
704     ByteIOContext *pb = &matroska->ctx->pb;
705     uint64_t length;
706     MatroskaLevel *level;
707     int res;
708
709     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
710         (res = ebml_read_element_length(matroska, &length)) < 0)
711         return res;
712
713     /* protect... (Heaven forbids that the '>' is true) */
714     if (matroska->num_levels >= EBML_MAX_DEPTH) {
715         av_log(matroska->ctx, AV_LOG_ERROR,
716                "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
717         return AVERROR_NOTSUPP;
718     }
719
720     /* remember level */
721     level = &matroska->levels[matroska->num_levels++];
722     level->start = url_ftell(pb);
723     level->length = length;
724
725     return 0;
726 }
727
728 /*
729  * Read the next element as binary data.
730  * 0 is success, < 0 is failure.
731  */
732
733 static int
734 ebml_read_binary (MatroskaDemuxContext *matroska,
735                   uint32_t             *id,
736                   uint8_t             **binary,
737                   int                  *size)
738 {
739     ByteIOContext *pb = &matroska->ctx->pb;
740     uint64_t rlength;
741     int res;
742
743     if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
744         (res = ebml_read_element_length(matroska, &rlength)) < 0)
745         return res;
746     *size = rlength;
747
748     if (!(*binary = av_malloc(*size))) {
749         av_log(matroska->ctx, AV_LOG_ERROR,
750                "Memory allocation error\n");
751         return AVERROR_NOMEM;
752     }
753
754     if (get_buffer(pb, *binary, *size) != *size) {
755         offset_t pos = url_ftell(pb);
756         av_log(matroska->ctx, AV_LOG_ERROR,
757                "Read error at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
758         return AVERROR_IO;
759     }
760
761     return 0;
762 }
763
764 /*
765  * Read signed/unsigned "EBML" numbers.
766  * Return: number of bytes processed, < 0 on error.
767  * XXX: use ebml_read_num().
768  */
769
770 static int
771 matroska_ebmlnum_uint (uint8_t  *data,
772                        uint32_t  size,
773                        uint64_t *num)
774 {
775     int len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
776     uint64_t total;
777
778     if (size <= 0)
779         return AVERROR_INVALIDDATA;
780
781     total = data[0];
782     while (read <= 8 && !(total & len_mask)) {
783         read++;
784         len_mask >>= 1;
785     }
786     if (read > 8)
787         return AVERROR_INVALIDDATA;
788
789     if ((total &= (len_mask - 1)) == len_mask - 1)
790         num_ffs++;
791     if (size < read)
792         return AVERROR_INVALIDDATA;
793     while (n < read) {
794         if (data[n] == 0xff)
795             num_ffs++;
796         total = (total << 8) | data[n];
797         n++;
798     }
799
800     if (read == num_ffs)
801         *num = (uint64_t)-1;
802     else
803         *num = total;
804
805     return read;
806 }
807
808 /*
809  * Same as above, but signed.
810  */
811
812 static int
813 matroska_ebmlnum_sint (uint8_t  *data,
814                        uint32_t  size,
815                        int64_t  *num)
816 {
817     uint64_t unum;
818     int res;
819
820     /* read as unsigned number first */
821     if ((res = matroska_ebmlnum_uint(data, size, &unum)) < 0)
822         return res;
823
824     /* make signed (weird way) */
825     if (unum == (uint64_t)-1)
826         *num = INT64_MAX;
827     else
828         *num = unum - ((1LL << ((7 * res) - 1)) - 1);
829
830     return res;
831 }
832
833 /*
834  * Read an EBML header.
835  * 0 is success, < 0 is failure.
836  */
837
838 static int
839 ebml_read_header (MatroskaDemuxContext *matroska,
840                   char                **doctype,
841                   int                  *version)
842 {
843     uint32_t id;
844     int level_up, res = 0;
845
846     /* default init */
847     if (doctype)
848         *doctype = NULL;
849     if (version)
850         *version = 1;
851
852     if (!(id = ebml_peek_id(matroska, &level_up)) ||
853         level_up != 0 || id != EBML_ID_HEADER) {
854         av_log(matroska->ctx, AV_LOG_ERROR,
855                "This is not an EBML file (id=0x%x/0x%x)\n", id, EBML_ID_HEADER);
856         return AVERROR_INVALIDDATA;
857     }
858     if ((res = ebml_read_master(matroska, &id)) < 0)
859         return res;
860
861     while (res == 0) {
862         if (!(id = ebml_peek_id(matroska, &level_up)))
863             return AVERROR_IO;
864
865         /* end-of-header */
866         if (level_up)
867             break;
868
869         switch (id) {
870             /* is our read version uptodate? */
871             case EBML_ID_EBMLREADVERSION: {
872                 uint64_t num;
873
874                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
875                     return res;
876                 if (num > EBML_VERSION) {
877                     av_log(matroska->ctx, AV_LOG_ERROR,
878                            "EBML version %"PRIu64" (> %d) is not supported\n",
879                            num, EBML_VERSION);
880                     return AVERROR_INVALIDDATA;
881                 }
882                 break;
883             }
884
885             /* we only handle 8 byte lengths at max */
886             case EBML_ID_EBMLMAXSIZELENGTH: {
887                 uint64_t num;
888
889                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
890                     return res;
891                 if (num > sizeof(uint64_t)) {
892                     av_log(matroska->ctx, AV_LOG_ERROR,
893                            "Integers of size %"PRIu64" (> %zd) not supported\n",
894                            num, sizeof(uint64_t));
895                     return AVERROR_INVALIDDATA;
896                 }
897                 break;
898             }
899
900             /* we handle 4 byte IDs at max */
901             case EBML_ID_EBMLMAXIDLENGTH: {
902                 uint64_t num;
903
904                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
905                     return res;
906                 if (num > sizeof(uint32_t)) {
907                     av_log(matroska->ctx, AV_LOG_ERROR,
908                            "IDs of size %"PRIu64" (> %zu) not supported\n",
909                             num, sizeof(uint32_t));
910                     return AVERROR_INVALIDDATA;
911                 }
912                 break;
913             }
914
915             case EBML_ID_DOCTYPE: {
916                 char *text;
917
918                 if ((res = ebml_read_ascii(matroska, &id, &text)) < 0)
919                     return res;
920                 if (doctype) {
921                     if (*doctype)
922                         av_free(*doctype);
923                     *doctype = text;
924                 } else
925                     av_free(text);
926                 break;
927             }
928
929             case EBML_ID_DOCTYPEREADVERSION: {
930                 uint64_t num;
931
932                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
933                     return res;
934                 if (version)
935                     *version = num;
936                 break;
937             }
938
939             default:
940                 av_log(matroska->ctx, AV_LOG_INFO,
941                        "Unknown data type 0x%x in EBML header", id);
942                 /* pass-through */
943
944             case EBML_ID_VOID:
945             /* we ignore these two, as they don't tell us anything we
946              * care about */
947             case EBML_ID_EBMLVERSION:
948             case EBML_ID_DOCTYPEVERSION:
949                 res = ebml_read_skip (matroska);
950                 break;
951         }
952     }
953
954     return 0;
955 }
956
957 /*
958  * Put one packet in an application-supplied AVPacket struct.
959  * Returns 0 on success or -1 on failure.
960  */
961
962 static int
963 matroska_deliver_packet (MatroskaDemuxContext *matroska,
964                          AVPacket             *pkt)
965 {
966     if (matroska->num_packets > 0) {
967         memcpy(pkt, matroska->packets[0], sizeof(AVPacket));
968         av_free(matroska->packets[0]);
969         if (matroska->num_packets > 1) {
970             memmove(&matroska->packets[0], &matroska->packets[1],
971                     (matroska->num_packets - 1) * sizeof(AVPacket *));
972             matroska->packets =
973                 av_realloc(matroska->packets, (matroska->num_packets - 1) *
974                            sizeof(AVPacket *));
975         } else {
976             av_free(matroska->packets);
977             matroska->packets = NULL;
978         }
979         matroska->num_packets--;
980         return 0;
981     }
982
983     return -1;
984 }
985
986 /*
987  * Put a packet into our internal queue. Will be delivered to the
988  * user/application during the next get_packet() call.
989  */
990
991 static void
992 matroska_queue_packet (MatroskaDemuxContext *matroska,
993                        AVPacket             *pkt)
994 {
995     matroska->packets =
996         av_realloc(matroska->packets, (matroska->num_packets + 1) *
997                    sizeof(AVPacket *));
998     matroska->packets[matroska->num_packets] = pkt;
999     matroska->num_packets++;
1000 }
1001
1002 /*
1003  * Autodetecting...
1004  */
1005
1006 static int
1007 matroska_probe (AVProbeData *p)
1008 {
1009     uint64_t total = 0;
1010     int len_mask = 0x80, size = 1, n = 1;
1011     uint8_t probe_data[] = { 'm', 'a', 't', 'r', 'o', 's', 'k', 'a' };
1012
1013     if (p->buf_size < 5)
1014         return 0;
1015
1016     /* ebml header? */
1017     if ((p->buf[0] << 24 | p->buf[1] << 16 |
1018          p->buf[2] << 8 | p->buf[3]) != EBML_ID_HEADER)
1019         return 0;
1020
1021     /* length of header */
1022     total = p->buf[4];
1023     while (size <= 8 && !(total & len_mask)) {
1024         size++;
1025         len_mask >>= 1;
1026     }
1027     if (size > 8)
1028       return 0;
1029     total &= (len_mask - 1);
1030     while (n < size)
1031         total = (total << 8) | p->buf[4 + n++];
1032
1033     /* does the probe data contain the whole header? */
1034     if (p->buf_size < 4 + size + total)
1035       return 0;
1036
1037     /* the header must contain the document type 'matroska'. For now,
1038      * we don't parse the whole header but simply check for the
1039      * availability of that array of characters inside the header.
1040      * Not fully fool-proof, but good enough. */
1041     for (n = 4 + size; n < 4 + size + total - sizeof(probe_data); n++)
1042         if (!memcmp (&p->buf[n], probe_data, sizeof(probe_data)))
1043             return AVPROBE_SCORE_MAX;
1044
1045     return 0;
1046 }
1047
1048 /*
1049  * From here on, it's all XML-style DTD stuff... Needs no comments.
1050  */
1051
1052 static int
1053 matroska_parse_info (MatroskaDemuxContext *matroska)
1054 {
1055     int res = 0;
1056     uint32_t id;
1057
1058     av_log(matroska->ctx, AV_LOG_DEBUG, "Parsing info...\n");
1059
1060     while (res == 0) {
1061         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1062             res = AVERROR_IO;
1063             break;
1064         } else if (matroska->level_up) {
1065             matroska->level_up--;
1066             break;
1067         }
1068
1069         switch (id) {
1070             /* cluster timecode */
1071             case MATROSKA_ID_TIMECODESCALE: {
1072                 uint64_t num;
1073                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1074                     break;
1075                 matroska->time_scale = num;
1076                 break;
1077             }
1078
1079             case MATROSKA_ID_DURATION: {
1080                 double num;
1081                 if ((res = ebml_read_float(matroska, &id, &num)) < 0)
1082                     break;
1083                 matroska->duration = num * matroska->time_scale;
1084                 break;
1085             }
1086
1087             case MATROSKA_ID_WRITINGAPP: {
1088                 char *text;
1089                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1090                     break;
1091                 matroska->writing_app = text;
1092                 break;
1093             }
1094
1095             case MATROSKA_ID_MUXINGAPP: {
1096                 char *text;
1097                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1098                     break;
1099                 matroska->muxing_app = text;
1100                 break;
1101             }
1102
1103             case MATROSKA_ID_DATEUTC: {
1104                 int64_t time;
1105                 if ((res = ebml_read_date(matroska, &id, &time)) < 0)
1106                     break;
1107                 matroska->created = time;
1108                 break;
1109             }
1110
1111             default:
1112                 av_log(matroska->ctx, AV_LOG_INFO,
1113                        "Unknown entry 0x%x in info header\n", id);
1114                 /* fall-through */
1115
1116             case EBML_ID_VOID:
1117                 res = ebml_read_skip(matroska);
1118                 break;
1119         }
1120
1121         if (matroska->level_up) {
1122             matroska->level_up--;
1123             break;
1124         }
1125     }
1126
1127     return res;
1128 }
1129
1130 static int
1131 matroska_add_stream (MatroskaDemuxContext *matroska)
1132 {
1133     int res = 0;
1134     uint32_t id;
1135     MatroskaTrack *track;
1136
1137     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing track, adding stream..,\n");
1138
1139     /* Allocate a generic track. As soon as we know its type we'll realloc. */
1140     track = av_mallocz(sizeof(MatroskaTrack));
1141     matroska->num_tracks++;
1142
1143     /* start with the master */
1144     if ((res = ebml_read_master(matroska, &id)) < 0)
1145         return res;
1146
1147     /* try reading the trackentry headers */
1148     while (res == 0) {
1149         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1150             res = AVERROR_IO;
1151             break;
1152         } else if (matroska->level_up > 0) {
1153             matroska->level_up--;
1154             break;
1155         }
1156
1157         switch (id) {
1158             /* track number (unique stream ID) */
1159             case MATROSKA_ID_TRACKNUMBER: {
1160                 uint64_t num;
1161                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1162                     break;
1163                 track->num = num;
1164                 break;
1165             }
1166
1167             /* track UID (unique identifier) */
1168             case MATROSKA_ID_TRACKUID: {
1169                 uint64_t num;
1170                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1171                     break;
1172                 track->uid = num;
1173                 break;
1174             }
1175
1176             /* track type (video, audio, combined, subtitle, etc.) */
1177             case MATROSKA_ID_TRACKTYPE: {
1178                 uint64_t num;
1179                 if (track->type != 0) {
1180                     av_log(matroska->ctx, AV_LOG_INFO,
1181                            "More than one tracktype in an entry - skip\n");
1182                     break;
1183                 }
1184                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1185                     break;
1186                 track->type = num;
1187
1188                 /* ok, so we're actually going to reallocate this thing */
1189                 switch (track->type) {
1190                     case MATROSKA_TRACK_TYPE_VIDEO:
1191                         track = (MatroskaTrack *)
1192                             av_realloc(track, sizeof(MatroskaVideoTrack));
1193                         break;
1194                     case MATROSKA_TRACK_TYPE_AUDIO:
1195                         track = (MatroskaTrack *)
1196                             av_realloc(track, sizeof(MatroskaAudioTrack));
1197                         ((MatroskaAudioTrack *)track)->channels = 1;
1198                         ((MatroskaAudioTrack *)track)->samplerate = 8000;
1199                         break;
1200                     case MATROSKA_TRACK_TYPE_SUBTITLE:
1201                         track = (MatroskaTrack *)
1202                             av_realloc(track, sizeof(MatroskaSubtitleTrack));
1203                         break;
1204                     case MATROSKA_TRACK_TYPE_COMPLEX:
1205                     case MATROSKA_TRACK_TYPE_LOGO:
1206                     case MATROSKA_TRACK_TYPE_CONTROL:
1207                     default:
1208                         av_log(matroska->ctx, AV_LOG_INFO,
1209                                "Unknown or unsupported track type 0x%x\n",
1210                                track->type);
1211                         track->type = 0;
1212                         break;
1213                 }
1214                 matroska->tracks[matroska->num_tracks - 1] = track;
1215                 break;
1216             }
1217
1218             /* tracktype specific stuff for video */
1219             case MATROSKA_ID_TRACKVIDEO: {
1220                 MatroskaVideoTrack *videotrack;
1221                 if (track->type != MATROSKA_TRACK_TYPE_VIDEO) {
1222                     av_log(matroska->ctx, AV_LOG_INFO,
1223                            "video data in non-video track - ignoring\n");
1224                     res = AVERROR_INVALIDDATA;
1225                     break;
1226                 } else if ((res = ebml_read_master(matroska, &id)) < 0)
1227                     break;
1228                 videotrack = (MatroskaVideoTrack *)track;
1229
1230                 while (res == 0) {
1231                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1232                         res = AVERROR_IO;
1233                         break;
1234                     } else if (matroska->level_up > 0) {
1235                         matroska->level_up--;
1236                         break;
1237                     }
1238
1239                     switch (id) {
1240                         /* fixme, this should be one-up, but I get it here */
1241                         case MATROSKA_ID_TRACKDEFAULTDURATION: {
1242                             uint64_t num;
1243                             if ((res = ebml_read_uint (matroska, &id,
1244                                                        &num)) < 0)
1245                                 break;
1246                             track->default_duration = num;
1247                             break;
1248                         }
1249
1250                         /* video framerate */
1251                         case MATROSKA_ID_VIDEOFRAMERATE: {
1252                             double num;
1253                             if ((res = ebml_read_float(matroska, &id,
1254                                                        &num)) < 0)
1255                                 break;
1256                             track->default_duration = 1000000000 * (1. / num);
1257                             break;
1258                         }
1259
1260                         /* width of the size to display the video at */
1261                         case MATROSKA_ID_VIDEODISPLAYWIDTH: {
1262                             uint64_t num;
1263                             if ((res = ebml_read_uint(matroska, &id,
1264                                                       &num)) < 0)
1265                                 break;
1266                             videotrack->display_width = num;
1267                             break;
1268                         }
1269
1270                         /* height of the size to display the video at */
1271                         case MATROSKA_ID_VIDEODISPLAYHEIGHT: {
1272                             uint64_t num;
1273                             if ((res = ebml_read_uint(matroska, &id,
1274                                                       &num)) < 0)
1275                                 break;
1276                             videotrack->display_height = num;
1277                             break;
1278                         }
1279
1280                         /* width of the video in the file */
1281                         case MATROSKA_ID_VIDEOPIXELWIDTH: {
1282                             uint64_t num;
1283                             if ((res = ebml_read_uint(matroska, &id,
1284                                                       &num)) < 0)
1285                                 break;
1286                             videotrack->pixel_width = num;
1287                             break;
1288                         }
1289
1290                         /* height of the video in the file */
1291                         case MATROSKA_ID_VIDEOPIXELHEIGHT: {
1292                             uint64_t num;
1293                             if ((res = ebml_read_uint(matroska, &id,
1294                                                       &num)) < 0)
1295                                 break;
1296                             videotrack->pixel_height = num;
1297                             break;
1298                         }
1299
1300                         /* whether the video is interlaced */
1301                         case MATROSKA_ID_VIDEOFLAGINTERLACED: {
1302                             uint64_t num;
1303                             if ((res = ebml_read_uint(matroska, &id,
1304                                                       &num)) < 0)
1305                                 break;
1306                             if (num)
1307                                 track->flags |=
1308                                     MATROSKA_VIDEOTRACK_INTERLACED;
1309                             else
1310                                 track->flags &=
1311                                     ~MATROSKA_VIDEOTRACK_INTERLACED;
1312                             break;
1313                         }
1314
1315                         /* stereo mode (whether the video has two streams,
1316                          * where one is for the left eye and the other for
1317                          * the right eye, which creates a 3D-like
1318                          * effect) */
1319                         case MATROSKA_ID_VIDEOSTEREOMODE: {
1320                             uint64_t num;
1321                             if ((res = ebml_read_uint(matroska, &id,
1322                                                       &num)) < 0)
1323                                 break;
1324                             if (num != MATROSKA_EYE_MODE_MONO &&
1325                                 num != MATROSKA_EYE_MODE_LEFT &&
1326                                 num != MATROSKA_EYE_MODE_RIGHT &&
1327                                 num != MATROSKA_EYE_MODE_BOTH) {
1328                                 av_log(matroska->ctx, AV_LOG_INFO,
1329                                        "Ignoring unknown eye mode 0x%x\n",
1330                                        (uint32_t) num);
1331                                 break;
1332                             }
1333                             videotrack->eye_mode = num;
1334                             break;
1335                         }
1336
1337                         /* aspect ratio behaviour */
1338                         case MATROSKA_ID_VIDEOASPECTRATIO: {
1339                             uint64_t num;
1340                             if ((res = ebml_read_uint(matroska, &id,
1341                                                       &num)) < 0)
1342                                 break;
1343                             if (num != MATROSKA_ASPECT_RATIO_MODE_FREE &&
1344                                 num != MATROSKA_ASPECT_RATIO_MODE_KEEP &&
1345                                 num != MATROSKA_ASPECT_RATIO_MODE_FIXED) {
1346                                 av_log(matroska->ctx, AV_LOG_INFO,
1347                                        "Ignoring unknown aspect ratio 0x%x\n",
1348                                        (uint32_t) num);
1349                                 break;
1350                             }
1351                             videotrack->ar_mode = num;
1352                             break;
1353                         }
1354
1355                         /* colourspace (only matters for raw video)
1356                          * fourcc */
1357                         case MATROSKA_ID_VIDEOCOLOURSPACE: {
1358                             uint64_t num;
1359                             if ((res = ebml_read_uint(matroska, &id,
1360                                                       &num)) < 0)
1361                                 break;
1362                             videotrack->fourcc = num;
1363                             break;
1364                         }
1365
1366                         default:
1367                             av_log(matroska->ctx, AV_LOG_INFO,
1368                                    "Unknown video track header entry "
1369                                    "0x%x - ignoring\n", id);
1370                             /* pass-through */
1371
1372                         case EBML_ID_VOID:
1373                             res = ebml_read_skip(matroska);
1374                             break;
1375                     }
1376
1377                     if (matroska->level_up) {
1378                         matroska->level_up--;
1379                         break;
1380                     }
1381                 }
1382                 break;
1383             }
1384
1385             /* tracktype specific stuff for audio */
1386             case MATROSKA_ID_TRACKAUDIO: {
1387                 MatroskaAudioTrack *audiotrack;
1388                 if (track->type != MATROSKA_TRACK_TYPE_AUDIO) {
1389                     av_log(matroska->ctx, AV_LOG_INFO,
1390                            "audio data in non-audio track - ignoring\n");
1391                     res = AVERROR_INVALIDDATA;
1392                     break;
1393                 } else if ((res = ebml_read_master(matroska, &id)) < 0)
1394                     break;
1395                 audiotrack = (MatroskaAudioTrack *)track;
1396
1397                 while (res == 0) {
1398                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1399                         res = AVERROR_IO;
1400                         break;
1401                     } else if (matroska->level_up > 0) {
1402                         matroska->level_up--;
1403                         break;
1404                     }
1405
1406                     switch (id) {
1407                         /* samplerate */
1408                         case MATROSKA_ID_AUDIOSAMPLINGFREQ: {
1409                             double num;
1410                             if ((res = ebml_read_float(matroska, &id,
1411                                                        &num)) < 0)
1412                                 break;
1413                             audiotrack->samplerate = num;
1414                             break;
1415                         }
1416
1417                             /* bitdepth */
1418                         case MATROSKA_ID_AUDIOBITDEPTH: {
1419                             uint64_t num;
1420                             if ((res = ebml_read_uint(matroska, &id,
1421                                                       &num)) < 0)
1422                                 break;
1423                             audiotrack->bitdepth = num;
1424                             break;
1425                         }
1426
1427                             /* channels */
1428                         case MATROSKA_ID_AUDIOCHANNELS: {
1429                             uint64_t num;
1430                             if ((res = ebml_read_uint(matroska, &id,
1431                                                       &num)) < 0)
1432                                 break;
1433                             audiotrack->channels = num;
1434                             break;
1435                         }
1436
1437                         default:
1438                             av_log(matroska->ctx, AV_LOG_INFO,
1439                                    "Unknown audio track header entry "
1440                                    "0x%x - ignoring\n", id);
1441                             /* pass-through */
1442
1443                         case EBML_ID_VOID:
1444                             res = ebml_read_skip(matroska);
1445                             break;
1446                     }
1447
1448                     if (matroska->level_up) {
1449                         matroska->level_up--;
1450                         break;
1451                     }
1452                 }
1453                 break;
1454             }
1455
1456                 /* codec identifier */
1457             case MATROSKA_ID_CODECID: {
1458                 char *text;
1459                 if ((res = ebml_read_ascii(matroska, &id, &text)) < 0)
1460                     break;
1461                 track->codec_id = text;
1462                 break;
1463             }
1464
1465                 /* codec private data */
1466             case MATROSKA_ID_CODECPRIVATE: {
1467                 uint8_t *data;
1468                 int size;
1469                 if ((res = ebml_read_binary(matroska, &id, &data, &size) < 0))
1470                     break;
1471                 track->codec_priv = data;
1472                 track->codec_priv_size = size;
1473                 break;
1474             }
1475
1476                 /* name of the codec */
1477             case MATROSKA_ID_CODECNAME: {
1478                 char *text;
1479                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1480                     break;
1481                 track->codec_name = text;
1482                 break;
1483             }
1484
1485                 /* name of this track */
1486             case MATROSKA_ID_TRACKNAME: {
1487                 char *text;
1488                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1489                     break;
1490                 track->name = text;
1491                 break;
1492             }
1493
1494                 /* language (matters for audio/subtitles, mostly) */
1495             case MATROSKA_ID_TRACKLANGUAGE: {
1496                 char *text;
1497                 if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1498                     break;
1499                 track->language = text;
1500                 break;
1501             }
1502
1503                 /* whether this is actually used */
1504             case MATROSKA_ID_TRACKFLAGENABLED: {
1505                 uint64_t num;
1506                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1507                     break;
1508                 if (num)
1509                     track->flags |= MATROSKA_TRACK_ENABLED;
1510                 else
1511                     track->flags &= ~MATROSKA_TRACK_ENABLED;
1512                 break;
1513             }
1514
1515                 /* whether it's the default for this track type */
1516             case MATROSKA_ID_TRACKFLAGDEFAULT: {
1517                 uint64_t num;
1518                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1519                     break;
1520                 if (num)
1521                     track->flags |= MATROSKA_TRACK_DEFAULT;
1522                 else
1523                     track->flags &= ~MATROSKA_TRACK_DEFAULT;
1524                 break;
1525             }
1526
1527                 /* lacing (like MPEG, where blocks don't end/start on frame
1528                  * boundaries) */
1529             case MATROSKA_ID_TRACKFLAGLACING: {
1530                 uint64_t num;
1531                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1532                     break;
1533                 if (num)
1534                     track->flags |= MATROSKA_TRACK_LACING;
1535                 else
1536                     track->flags &= ~MATROSKA_TRACK_LACING;
1537                 break;
1538             }
1539
1540                 /* default length (in time) of one data block in this track */
1541             case MATROSKA_ID_TRACKDEFAULTDURATION: {
1542                 uint64_t num;
1543                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1544                     break;
1545                 track->default_duration = num;
1546                 break;
1547             }
1548
1549             default:
1550                 av_log(matroska->ctx, AV_LOG_INFO,
1551                        "Unknown track header entry 0x%x - ignoring\n", id);
1552                 /* pass-through */
1553
1554             case EBML_ID_VOID:
1555             /* we ignore these because they're nothing useful. */
1556             case MATROSKA_ID_CODECINFOURL:
1557             case MATROSKA_ID_CODECDOWNLOADURL:
1558             case MATROSKA_ID_TRACKMINCACHE:
1559             case MATROSKA_ID_TRACKMAXCACHE:
1560                 res = ebml_read_skip(matroska);
1561                 break;
1562         }
1563
1564         if (matroska->level_up) {
1565             matroska->level_up--;
1566             break;
1567         }
1568     }
1569
1570     return res;
1571 }
1572
1573 static int
1574 matroska_parse_tracks (MatroskaDemuxContext *matroska)
1575 {
1576     int res = 0;
1577     uint32_t id;
1578
1579     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing tracks...\n");
1580
1581     while (res == 0) {
1582         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1583             res = AVERROR_IO;
1584             break;
1585         } else if (matroska->level_up) {
1586             matroska->level_up--;
1587             break;
1588         }
1589
1590         switch (id) {
1591             /* one track within the "all-tracks" header */
1592             case MATROSKA_ID_TRACKENTRY:
1593                 res = matroska_add_stream(matroska);
1594                 break;
1595
1596             default:
1597                 av_log(matroska->ctx, AV_LOG_INFO,
1598                        "Unknown entry 0x%x in track header\n", id);
1599                 /* fall-through */
1600
1601             case EBML_ID_VOID:
1602                 res = ebml_read_skip(matroska);
1603                 break;
1604         }
1605
1606         if (matroska->level_up) {
1607             matroska->level_up--;
1608             break;
1609         }
1610     }
1611
1612     return res;
1613 }
1614
1615 static int
1616 matroska_parse_index (MatroskaDemuxContext *matroska)
1617 {
1618     int res = 0;
1619     uint32_t id;
1620     MatroskaDemuxIndex idx;
1621
1622     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing index...\n");
1623
1624     while (res == 0) {
1625         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1626             res = AVERROR_IO;
1627             break;
1628         } else if (matroska->level_up) {
1629             matroska->level_up--;
1630             break;
1631         }
1632
1633         switch (id) {
1634             /* one single index entry ('point') */
1635             case MATROSKA_ID_POINTENTRY:
1636                 if ((res = ebml_read_master(matroska, &id)) < 0)
1637                     break;
1638
1639                 /* in the end, we hope to fill one entry with a
1640                  * timestamp, a file position and a tracknum */
1641                 idx.pos   = (uint64_t) -1;
1642                 idx.time  = (uint64_t) -1;
1643                 idx.track = (uint16_t) -1;
1644
1645                 while (res == 0) {
1646                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1647                         res = AVERROR_IO;
1648                         break;
1649                     } else if (matroska->level_up) {
1650                         matroska->level_up--;
1651                         break;
1652                     }
1653
1654                     switch (id) {
1655                         /* one single index entry ('point') */
1656                         case MATROSKA_ID_CUETIME: {
1657                             int64_t time;
1658                             if ((res = ebml_read_uint(matroska, &id,
1659                                                       &time)) < 0)
1660                                 break;
1661                             idx.time = time * matroska->time_scale;
1662                             break;
1663                         }
1664
1665                         /* position in the file + track to which it
1666                          * belongs */
1667                         case MATROSKA_ID_CUETRACKPOSITION:
1668                             if ((res = ebml_read_master(matroska, &id)) < 0)
1669                                 break;
1670
1671                             while (res == 0) {
1672                                 if (!(id = ebml_peek_id (matroska,
1673                                                     &matroska->level_up))) {
1674                                     res = AVERROR_IO;
1675                                     break;
1676                                 } else if (matroska->level_up) {
1677                                     matroska->level_up--;
1678                                     break;
1679                                 }
1680
1681                                 switch (id) {
1682                                     /* track number */
1683                                     case MATROSKA_ID_CUETRACK: {
1684                                         uint64_t num;
1685                                         if ((res = ebml_read_uint(matroska,
1686                                                           &id, &num)) < 0)
1687                                             break;
1688                                         idx.track = num;
1689                                         break;
1690                                     }
1691
1692                                         /* position in file */
1693                                     case MATROSKA_ID_CUECLUSTERPOSITION: {
1694                                         uint64_t num;
1695                                         if ((res = ebml_read_uint(matroska,
1696                                                           &id, &num)) < 0)
1697                                             break;
1698                                         idx.pos = num;
1699                                         break;
1700                                     }
1701
1702                                     default:
1703                                         av_log(matroska->ctx, AV_LOG_INFO,
1704                                                "Unknown entry 0x%x in "
1705                                                "CuesTrackPositions\n", id);
1706                                         /* fall-through */
1707
1708                                     case EBML_ID_VOID:
1709                                         res = ebml_read_skip(matroska);
1710                                         break;
1711                                 }
1712
1713                                 if (matroska->level_up) {
1714                                     matroska->level_up--;
1715                                     break;
1716                                 }
1717                             }
1718
1719                             break;
1720
1721                         default:
1722                             av_log(matroska->ctx, AV_LOG_INFO,
1723                                    "Unknown entry 0x%x in cuespoint "
1724                                    "index\n", id);
1725                             /* fall-through */
1726
1727                         case EBML_ID_VOID:
1728                             res = ebml_read_skip(matroska);
1729                             break;
1730                     }
1731
1732                     if (matroska->level_up) {
1733                         matroska->level_up--;
1734                         break;
1735                     }
1736                 }
1737
1738                 /* so let's see if we got what we wanted */
1739                 if (idx.pos   != (uint64_t) -1 &&
1740                     idx.time  != (uint64_t) -1 &&
1741                     idx.track != (uint16_t) -1) {
1742                     if (matroska->num_indexes % 32 == 0) {
1743                         /* re-allocate bigger index */
1744                         matroska->index =
1745                             av_realloc(matroska->index,
1746                                        (matroska->num_indexes + 32) *
1747                                        sizeof(MatroskaDemuxIndex));
1748                     }
1749                     matroska->index[matroska->num_indexes] = idx;
1750                     matroska->num_indexes++;
1751                 }
1752                 break;
1753
1754             default:
1755                 av_log(matroska->ctx, AV_LOG_INFO,
1756                        "Unknown entry 0x%x in cues header\n", id);
1757                 /* fall-through */
1758
1759             case EBML_ID_VOID:
1760                 res = ebml_read_skip(matroska);
1761                 break;
1762         }
1763
1764         if (matroska->level_up) {
1765             matroska->level_up--;
1766             break;
1767         }
1768     }
1769
1770     return res;
1771 }
1772
1773 static int
1774 matroska_parse_metadata (MatroskaDemuxContext *matroska)
1775 {
1776     int res = 0;
1777     uint32_t id;
1778
1779     while (res == 0) {
1780         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1781             res = AVERROR_IO;
1782             break;
1783         } else if (matroska->level_up) {
1784             matroska->level_up--;
1785             break;
1786         }
1787
1788         switch (id) {
1789             /* Hm, this is unsupported... */
1790             default:
1791                 av_log(matroska->ctx, AV_LOG_INFO,
1792                        "Unknown entry 0x%x in metadata header\n", id);
1793                 /* fall-through */
1794
1795             case EBML_ID_VOID:
1796                 res = ebml_read_skip(matroska);
1797                 break;
1798         }
1799
1800         if (matroska->level_up) {
1801             matroska->level_up--;
1802             break;
1803         }
1804     }
1805
1806     return res;
1807 }
1808
1809 static int
1810 matroska_parse_seekhead (MatroskaDemuxContext *matroska)
1811 {
1812     int res = 0;
1813     uint32_t id;
1814
1815     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing seekhead...\n");
1816
1817     while (res == 0) {
1818         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1819             res = AVERROR_IO;
1820             break;
1821         } else if (matroska->level_up) {
1822             matroska->level_up--;
1823             break;
1824         }
1825
1826         switch (id) {
1827             case MATROSKA_ID_SEEKENTRY: {
1828                 uint32_t seek_id = 0, peek_id_cache = 0;
1829                 uint64_t seek_pos = (uint64_t) -1, t;
1830
1831                 if ((res = ebml_read_master(matroska, &id)) < 0)
1832                     break;
1833
1834                 while (res == 0) {
1835                     if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1836                         res = AVERROR_IO;
1837                         break;
1838                     } else if (matroska->level_up) {
1839                         matroska->level_up--;
1840                         break;
1841                     }
1842
1843                     switch (id) {
1844                         case MATROSKA_ID_SEEKID:
1845                             res = ebml_read_uint(matroska, &id, &t);
1846                             seek_id = t;
1847                             break;
1848
1849                         case MATROSKA_ID_SEEKPOSITION:
1850                             res = ebml_read_uint(matroska, &id, &seek_pos);
1851                             break;
1852
1853                         default:
1854                             av_log(matroska->ctx, AV_LOG_INFO,
1855                                    "Unknown seekhead ID 0x%x\n", id);
1856                             /* fall-through */
1857
1858                         case EBML_ID_VOID:
1859                             res = ebml_read_skip(matroska);
1860                             break;
1861                     }
1862
1863                     if (matroska->level_up) {
1864                         matroska->level_up--;
1865                         break;
1866                     }
1867                 }
1868
1869                 if (!seek_id || seek_pos == (uint64_t) -1) {
1870                     av_log(matroska->ctx, AV_LOG_INFO,
1871                            "Incomplete seekhead entry (0x%x/%"PRIu64")\n",
1872                            seek_id, seek_pos);
1873                     break;
1874                 }
1875
1876                 switch (seek_id) {
1877                     case MATROSKA_ID_CUES:
1878                     case MATROSKA_ID_TAGS: {
1879                         uint32_t level_up = matroska->level_up;
1880                         offset_t before_pos;
1881                         uint64_t length;
1882                         MatroskaLevel level;
1883
1884                         /* remember the peeked ID and the current position */
1885                         peek_id_cache = matroska->peek_id;
1886                         before_pos = url_ftell(&matroska->ctx->pb);
1887
1888                         /* seek */
1889                         if ((res = ebml_read_seek(matroska, seek_pos +
1890                                                matroska->segment_start)) < 0)
1891                             return res;
1892
1893                         /* we don't want to lose our seekhead level, so we add
1894                          * a dummy. This is a crude hack. */
1895                         if (matroska->num_levels == EBML_MAX_DEPTH) {
1896                             av_log(matroska->ctx, AV_LOG_INFO,
1897                                    "Max EBML element depth (%d) reached, "
1898                                    "cannot parse further.\n", EBML_MAX_DEPTH);
1899                             return AVERROR_UNKNOWN;
1900                         }
1901
1902                         level.start = 0;
1903                         level.length = (uint64_t)-1;
1904                         matroska->levels[matroska->num_levels] = level;
1905                         matroska->num_levels++;
1906
1907                         /* check ID */
1908                         if (!(id = ebml_peek_id (matroska,
1909                                                  &matroska->level_up)))
1910                             break;
1911                         if (id != seek_id) {
1912                             av_log(matroska->ctx, AV_LOG_INFO,
1913                                    "We looked for ID=0x%x but got "
1914                                    "ID=0x%x (pos=%"PRIu64")",
1915                                    seek_id, id, seek_pos +
1916                                    matroska->segment_start);
1917                             goto finish;
1918                         }
1919
1920                         /* read master + parse */
1921                         if ((res = ebml_read_master(matroska, &id)) < 0)
1922                             break;
1923                         switch (id) {
1924                             case MATROSKA_ID_CUES:
1925                                 if (!(res = matroska_parse_index(matroska)) ||
1926                                     url_feof(&matroska->ctx->pb)) {
1927                                     matroska->index_parsed = 1;
1928                                     res = 0;
1929                                 }
1930                                 break;
1931                             case MATROSKA_ID_TAGS:
1932                                 if (!(res = matroska_parse_metadata(matroska)) ||
1933                                    url_feof(&matroska->ctx->pb)) {
1934                                     matroska->metadata_parsed = 1;
1935                                     res = 0;
1936                                 }
1937                                 break;
1938                         }
1939                         if (res < 0)
1940                             break;
1941
1942                     finish:
1943                         /* remove dummy level */
1944                         while (matroska->num_levels) {
1945                             matroska->num_levels--;
1946                             length =
1947                                 matroska->levels[matroska->num_levels].length;
1948                             if (length == (uint64_t)-1)
1949                                 break;
1950                         }
1951
1952                         /* seek back */
1953                         if ((res = ebml_read_seek(matroska, before_pos)) < 0)
1954                             return res;
1955                         matroska->peek_id = peek_id_cache;
1956                         matroska->level_up = level_up;
1957                         break;
1958                     }
1959
1960                     default:
1961                         av_log(matroska->ctx, AV_LOG_INFO,
1962                                "Ignoring seekhead entry for ID=0x%x\n",
1963                                seek_id);
1964                         break;
1965                 }
1966
1967                 break;
1968             }
1969
1970             default:
1971                 av_log(matroska->ctx, AV_LOG_INFO,
1972                        "Unknown seekhead ID 0x%x\n", id);
1973                 /* fall-through */
1974
1975             case EBML_ID_VOID:
1976                 res = ebml_read_skip(matroska);
1977                 break;
1978         }
1979
1980         if (matroska->level_up) {
1981             matroska->level_up--;
1982             break;
1983         }
1984     }
1985
1986     return res;
1987 }
1988
1989 static int
1990 matroska_read_header (AVFormatContext    *s,
1991                       AVFormatParameters *ap)
1992 {
1993     MatroskaDemuxContext *matroska = s->priv_data;
1994     char *doctype;
1995     int version, last_level, res = 0;
1996     uint32_t id;
1997
1998     matroska->ctx = s;
1999
2000     /* First read the EBML header. */
2001     doctype = NULL;
2002     if ((res = ebml_read_header(matroska, &doctype, &version)) < 0)
2003         return res;
2004     if ((doctype == NULL) || strcmp(doctype, "matroska")) {
2005         av_log(matroska->ctx, AV_LOG_ERROR,
2006                "Wrong EBML doctype ('%s' != 'matroska').\n",
2007                doctype ? doctype : "(none)");
2008         if (doctype)
2009             av_free(doctype);
2010         return AVERROR_NOFMT;
2011     }
2012     av_free(doctype);
2013     if (version != 1) {
2014         av_log(matroska->ctx, AV_LOG_ERROR,
2015                "Matroska demuxer version 1 too old for file version %d\n",
2016                version);
2017         return AVERROR_NOFMT;
2018     }
2019
2020     /* The next thing is a segment. */
2021     while (1) {
2022         if (!(id = ebml_peek_id(matroska, &last_level)))
2023             return AVERROR_IO;
2024         if (id == MATROSKA_ID_SEGMENT)
2025             break;
2026
2027         /* oi! */
2028         av_log(matroska->ctx, AV_LOG_INFO,
2029                "Expected a Segment ID (0x%x), but received 0x%x!\n",
2030                MATROSKA_ID_SEGMENT, id);
2031         if ((res = ebml_read_skip(matroska)) < 0)
2032             return res;
2033     }
2034
2035     /* We now have a Matroska segment.
2036      * Seeks are from the beginning of the segment,
2037      * after the segment ID/length. */
2038     if ((res = ebml_read_master(matroska, &id)) < 0)
2039         return res;
2040     matroska->segment_start = url_ftell(&s->pb);
2041
2042     matroska->time_scale = 1000000;
2043     /* we've found our segment, start reading the different contents in here */
2044     while (res == 0) {
2045         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2046             res = AVERROR_IO;
2047             break;
2048         } else if (matroska->level_up) {
2049             matroska->level_up--;
2050             break;
2051         }
2052
2053         switch (id) {
2054             /* stream info */
2055             case MATROSKA_ID_INFO: {
2056                 if ((res = ebml_read_master(matroska, &id)) < 0)
2057                     break;
2058                 res = matroska_parse_info(matroska);
2059                 break;
2060             }
2061
2062             /* track info headers */
2063             case MATROSKA_ID_TRACKS: {
2064                 if ((res = ebml_read_master(matroska, &id)) < 0)
2065                     break;
2066                 res = matroska_parse_tracks(matroska);
2067                 break;
2068             }
2069
2070             /* stream index */
2071             case MATROSKA_ID_CUES: {
2072                 if (!matroska->index_parsed) {
2073                     if ((res = ebml_read_master(matroska, &id)) < 0)
2074                         break;
2075                     res = matroska_parse_index(matroska);
2076                 } else
2077                     res = ebml_read_skip(matroska);
2078                 break;
2079             }
2080
2081             /* metadata */
2082             case MATROSKA_ID_TAGS: {
2083                 if (!matroska->metadata_parsed) {
2084                     if ((res = ebml_read_master(matroska, &id)) < 0)
2085                         break;
2086                     res = matroska_parse_metadata(matroska);
2087                 } else
2088                     res = ebml_read_skip(matroska);
2089                 break;
2090             }
2091
2092             /* file index (if seekable, seek to Cues/Tags to parse it) */
2093             case MATROSKA_ID_SEEKHEAD: {
2094                 if ((res = ebml_read_master(matroska, &id)) < 0)
2095                     break;
2096                 res = matroska_parse_seekhead(matroska);
2097                 break;
2098             }
2099
2100             case MATROSKA_ID_CLUSTER: {
2101                 /* Do not read the master - this will be done in the next
2102                  * call to matroska_read_packet. */
2103                 res = 1;
2104                 break;
2105             }
2106
2107             default:
2108                 av_log(matroska->ctx, AV_LOG_INFO,
2109                        "Unknown matroska file header ID 0x%x\n", id);
2110             /* fall-through */
2111
2112             case EBML_ID_VOID:
2113                 res = ebml_read_skip(matroska);
2114                 break;
2115         }
2116
2117         if (matroska->level_up) {
2118             matroska->level_up--;
2119             break;
2120         }
2121     }
2122
2123     if (res < 0)
2124         return res;
2125
2126     /* Have we found a cluster? */
2127     if (res == 1) {
2128         int i;
2129         enum CodecID codec_id;
2130         MatroskaTrack *track;
2131         AVStream *st;
2132         void *extradata = NULL;
2133         int extradata_size = 0;
2134
2135         for (i = 0; i < matroska->num_tracks; i++) {
2136             track = matroska->tracks[i];
2137
2138             /* libavformat does not really support subtitles.
2139              * Also apply some sanity checks. */
2140             if ((track->type == MATROSKA_TRACK_TYPE_SUBTITLE) ||
2141                 (track->codec_id == NULL))
2142                 continue;
2143
2144             /* Set the FourCC from the CodecID. */
2145             /* This is the MS compatibility mode which stores a
2146              * BITMAPINFOHEADER in the CodecPrivate. */
2147             if (!strcmp(track->codec_id,
2148                         MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&
2149                 (track->codec_priv_size >= 40) &&
2150                 (track->codec_priv != NULL)) {
2151                 unsigned char *p;
2152
2153                 /* Offset of biCompression. Stored in LE. */
2154                 p = (unsigned char *)track->codec_priv + 16;
2155                 ((MatroskaVideoTrack *)track)->fourcc = (p[3] << 24) |
2156                                  (p[2] << 16) | (p[1] << 8) | p[0];
2157                 codec_id = codec_get_bmp_id(((MatroskaVideoTrack *)track)->fourcc);
2158
2159             } else if (!strcmp(track->codec_id,
2160                                MATROSKA_CODEC_ID_VIDEO_MPEG4_SP) ||
2161                        !strcmp(track->codec_id,
2162                                MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP) ||
2163                        !strcmp(track->codec_id,
2164                                MATROSKA_CODEC_ID_VIDEO_MPEG4_AP))
2165                 codec_id = CODEC_ID_MPEG4;
2166             else if (!strcmp(track->codec_id,
2167                              MATROSKA_CODEC_ID_VIDEO_MPEG4_AVC))
2168                 codec_id = CODEC_ID_H264;
2169 /*             else if (!strcmp(track->codec_id, */
2170 /*                              MATROSKA_CODEC_ID_VIDEO_UNCOMPRESSED)) */
2171 /*                 codec_id = CODEC_ID_???; */
2172             else if (!strcmp(track->codec_id,
2173                              MATROSKA_CODEC_ID_VIDEO_MSMPEG4V3))
2174                 codec_id = CODEC_ID_MSMPEG4V3;
2175             else if (!strcmp(track->codec_id,
2176                              MATROSKA_CODEC_ID_VIDEO_MPEG1) ||
2177                      !strcmp(track->codec_id,
2178                              MATROSKA_CODEC_ID_VIDEO_MPEG2))
2179                 codec_id = CODEC_ID_MPEG2VIDEO;
2180
2181             /* This is the MS compatibility mode which stores a
2182              * WAVEFORMATEX in the CodecPrivate. */
2183             else if (!strcmp(track->codec_id,
2184                              MATROSKA_CODEC_ID_AUDIO_ACM) &&
2185                 (track->codec_priv_size >= 18) &&
2186                 (track->codec_priv != NULL)) {
2187                 unsigned char *p;
2188                 uint16_t tag;
2189
2190                 /* Offset of wFormatTag. Stored in LE. */
2191                 p = (unsigned char *)track->codec_priv;
2192                 tag = (p[1] << 8) | p[0];
2193                 codec_id = codec_get_wav_id(tag);
2194
2195             } else if (!strcmp(track->codec_id,
2196                                MATROSKA_CODEC_ID_AUDIO_MPEG1_L1) ||
2197                        !strcmp(track->codec_id,
2198                                MATROSKA_CODEC_ID_AUDIO_MPEG1_L2) ||
2199                        !strcmp(track->codec_id,
2200                                MATROSKA_CODEC_ID_AUDIO_MPEG1_L3))
2201                 codec_id = CODEC_ID_MP3;
2202             else if (!strcmp(track->codec_id,
2203                              MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE))
2204                 codec_id = CODEC_ID_PCM_U16BE;
2205             else if (!strcmp(track->codec_id,
2206                              MATROSKA_CODEC_ID_AUDIO_PCM_INT_LE))
2207                 codec_id = CODEC_ID_PCM_U16LE;
2208 /*             else if (!strcmp(track->codec_id, */
2209 /*                              MATROSKA_CODEC_ID_AUDIO_PCM_FLOAT)) */
2210 /*                 codec_id = CODEC_ID_PCM_???; */
2211             else if (!strcmp(track->codec_id,
2212                              MATROSKA_CODEC_ID_AUDIO_AC3))
2213                 codec_id = CODEC_ID_AC3;
2214             else if (!strcmp(track->codec_id,
2215                              MATROSKA_CODEC_ID_AUDIO_DTS))
2216                 codec_id = CODEC_ID_DTS;
2217             /* No such codec id so far. */
2218 /*             else if (!strcmp(track->codec_id, */
2219 /*                              MATROSKA_CODEC_ID_AUDIO_DTS)) */
2220 /*                 codec_id = CODEC_ID_DTS; */
2221             else if (!strcmp(track->codec_id,
2222                              MATROSKA_CODEC_ID_AUDIO_VORBIS)) {
2223                 extradata_size = track->codec_priv_size;
2224                 if(extradata_size) {
2225                     extradata = av_malloc(extradata_size);
2226                     if(extradata == NULL)
2227                         return AVERROR_NOMEM;
2228                     memcpy(extradata, track->codec_priv, extradata_size);
2229                 }
2230                 codec_id = CODEC_ID_VORBIS;
2231             } else if (!strcmp(track->codec_id,
2232                                MATROSKA_CODEC_ID_AUDIO_MPEG2) ||
2233                        !strcmp(track->codec_id,
2234                                MATROSKA_CODEC_ID_AUDIO_MPEG4))
2235                 codec_id = CODEC_ID_AAC;
2236             else
2237                 codec_id = CODEC_ID_NONE;
2238
2239             if (codec_id == CODEC_ID_NONE) {
2240                 av_log(matroska->ctx, AV_LOG_INFO,
2241                        "Unknown/unsupported CodecID %s.\n",
2242                        track->codec_id);
2243             }
2244
2245             track->stream_index = matroska->num_streams;
2246
2247             matroska->num_streams++;
2248             st = av_new_stream(s, track->stream_index);
2249             if (st == NULL)
2250                 return AVERROR_NOMEM;
2251             av_set_pts_info(st, 24, 1, 1000); /* 24 bit pts in ms */
2252
2253             st->codec->codec_id = codec_id;
2254
2255             if(extradata){
2256                 st->codec->extradata = extradata;
2257                 st->codec->extradata_size = extradata_size;
2258             } else if(track->codec_priv && track->codec_priv_size > 0){
2259                 st->codec->extradata = av_malloc(track->codec_priv_size);
2260                 if(st->codec->extradata == NULL)
2261                     return AVERROR_NOMEM;
2262                 st->codec->extradata_size = track->codec_priv_size;
2263                 memcpy(st->codec->extradata, track->codec_priv,
2264                        track->codec_priv_size);
2265             }
2266
2267             if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2268                 MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
2269
2270                 st->codec->codec_type = CODEC_TYPE_VIDEO;
2271                 st->codec->codec_tag = videotrack->fourcc;
2272                 st->codec->width = videotrack->pixel_width;
2273                 st->codec->height = videotrack->pixel_height;
2274                 if (videotrack->display_width == 0)
2275                     videotrack->display_width= videotrack->pixel_width;
2276                 if (videotrack->display_height == 0)
2277                     videotrack->display_height= videotrack->pixel_height;
2278                 av_reduce(&st->codec->sample_aspect_ratio.num,
2279                           &st->codec->sample_aspect_ratio.den,
2280                           st->codec->height * videotrack->display_width,
2281                           st->codec-> width * videotrack->display_height,
2282                           255);
2283             } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2284                 MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2285
2286                 st->codec->codec_type = CODEC_TYPE_AUDIO;
2287                 st->codec->sample_rate = audiotrack->samplerate;
2288                 st->codec->channels = audiotrack->channels;
2289             }
2290
2291             /* What do we do with private data? E.g. for Vorbis. */
2292         }
2293     }
2294
2295     return 0;
2296 }
2297
2298 static int
2299 matroska_find_track_by_num (MatroskaDemuxContext *matroska,
2300                             int                   num)
2301 {
2302     int i;
2303
2304     for (i = 0; i < matroska->num_tracks; i++)
2305         if (matroska->tracks[i]->num == num)
2306             return i;
2307
2308     return -1;
2309 }
2310
2311 static int
2312 matroska_parse_blockgroup (MatroskaDemuxContext *matroska,
2313                            uint64_t              cluster_time)
2314 {
2315     int res = 0;
2316     uint32_t id;
2317     AVPacket *pkt;
2318     int is_keyframe = PKT_FLAG_KEY, last_num_packets = matroska->num_packets;
2319
2320     av_log(matroska->ctx, AV_LOG_DEBUG, "parsing blockgroup...\n");
2321
2322     while (res == 0) {
2323         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2324             res = AVERROR_IO;
2325             break;
2326         } else if (matroska->level_up) {
2327             matroska->level_up--;
2328             break;
2329         }
2330
2331         switch (id) {
2332             /* one block inside the group. Note, block parsing is one
2333              * of the harder things, so this code is a bit complicated.
2334              * See http://www.matroska.org/ for documentation. */
2335             case MATROSKA_ID_BLOCK: {
2336                 uint8_t *data, *origdata;
2337                 int size;
2338                 uint64_t time;
2339                 uint32_t *lace_size = NULL;
2340                 int n, track, flags, laces = 0;
2341                 uint64_t num;
2342                 int64_t pos= url_ftell(&matroska->ctx->pb);
2343
2344                 if ((res = ebml_read_binary(matroska, &id, &data, &size)) < 0)
2345                     break;
2346                 origdata = data;
2347
2348                 /* first byte(s): blocknum */
2349                 if ((n = matroska_ebmlnum_uint(data, size, &num)) < 0) {
2350                     av_log(matroska->ctx, AV_LOG_ERROR,
2351                            "EBML block data error\n");
2352                     av_free(origdata);
2353                     break;
2354                 }
2355                 data += n;
2356                 size -= n;
2357
2358                 /* fetch track from num */
2359                 track = matroska_find_track_by_num(matroska, num);
2360                 if (size <= 3 || track < 0 || track >= matroska->num_tracks) {
2361                     av_log(matroska->ctx, AV_LOG_INFO,
2362                            "Invalid stream %d or size %u\n", track, size);
2363                     av_free(origdata);
2364                     break;
2365                 }
2366                 if(matroska->ctx->streams[ matroska->tracks[track]->stream_index ]->discard >= AVDISCARD_ALL){
2367                     av_free(origdata);
2368                     break;
2369                 }
2370
2371                 /* time (relative to cluster time) */
2372                 time = ((data[0] << 8) | data[1]) * matroska->time_scale;
2373                 data += 2;
2374                 size -= 2;
2375                 flags = *data;
2376                 data += 1;
2377                 size -= 1;
2378                 switch ((flags & 0x06) >> 1) {
2379                     case 0x0: /* no lacing */
2380                         laces = 1;
2381                         lace_size = av_mallocz(sizeof(int));
2382                         lace_size[0] = size;
2383                         break;
2384
2385                     case 0x1: /* xiph lacing */
2386                     case 0x2: /* fixed-size lacing */
2387                     case 0x3: /* EBML lacing */
2388                         if (size == 0) {
2389                             res = -1;
2390                             break;
2391                         }
2392                         laces = (*data) + 1;
2393                         data += 1;
2394                         size -= 1;
2395                         lace_size = av_mallocz(laces * sizeof(int));
2396
2397                         switch ((flags & 0x06) >> 1) {
2398                             case 0x1: /* xiph lacing */ {
2399                                 uint8_t temp;
2400                                 uint32_t total = 0;
2401                                 for (n = 0; res == 0 && n < laces - 1; n++) {
2402                                     while (1) {
2403                                         if (size == 0) {
2404                                             res = -1;
2405                                             break;
2406                                         }
2407                                         temp = *data;
2408                                         lace_size[n] += temp;
2409                                         data += 1;
2410                                         size -= 1;
2411                                         if (temp != 0xff)
2412                                             break;
2413                                     }
2414                                     total += lace_size[n];
2415                                 }
2416                                 lace_size[n] = size - total;
2417                                 break;
2418                             }
2419
2420                             case 0x2: /* fixed-size lacing */
2421                                 for (n = 0; n < laces; n++)
2422                                     lace_size[n] = size / laces;
2423                                 break;
2424
2425                             case 0x3: /* EBML lacing */ {
2426                                 uint32_t total;
2427                                 n = matroska_ebmlnum_uint(data, size, &num);
2428                                 if (n < 0) {
2429                                     av_log(matroska->ctx, AV_LOG_INFO,
2430                                            "EBML block data error\n");
2431                                     break;
2432                                 }
2433                                 data += n;
2434                                 size -= n;
2435                                 total = lace_size[0] = num;
2436                                 for (n = 1; res == 0 && n < laces - 1; n++) {
2437                                     int64_t snum;
2438                                     int r;
2439                                     r = matroska_ebmlnum_sint (data, size,
2440                                                                &snum);
2441                                     if (r < 0) {
2442                                         av_log(matroska->ctx, AV_LOG_INFO,
2443                                                "EBML block data error\n");
2444                                         break;
2445                                     }
2446                                     data += r;
2447                                     size -= r;
2448                                     lace_size[n] = lace_size[n - 1] + snum;
2449                                     total += lace_size[n];
2450                                 }
2451                                 lace_size[n] = size - total;
2452                                 break;
2453                             }
2454                         }
2455                         break;
2456                 }
2457
2458                 if (res == 0) {
2459                     for (n = 0; n < laces; n++) {
2460                         uint64_t timecode = 0;
2461
2462                         pkt = av_mallocz(sizeof(AVPacket));
2463                         /* XXX: prevent data copy... */
2464                         if (av_new_packet(pkt,lace_size[n]) < 0) {
2465                             res = AVERROR_NOMEM;
2466                             break;
2467                         }
2468                         if (cluster_time != (uint64_t)-1) {
2469                             if (time < 0 && (-time) > cluster_time)
2470                                 timecode = cluster_time;
2471                             else
2472                                 timecode = cluster_time + time;
2473                         }
2474                         /* FIXME: duration */
2475
2476                         memcpy(pkt->data, data, lace_size[n]);
2477                         data += lace_size[n];
2478                         if (n == 0)
2479                             pkt->flags = is_keyframe;
2480                         pkt->stream_index =
2481                             matroska->tracks[track]->stream_index;
2482
2483                         pkt->pts = timecode / 1000000; /* ns to ms */
2484                         pkt->pos= pos;
2485
2486                         matroska_queue_packet(matroska, pkt);
2487                     }
2488                 }
2489
2490                 av_free(lace_size);
2491                 av_free(origdata);
2492                 break;
2493             }
2494
2495             case MATROSKA_ID_BLOCKDURATION: {
2496                 uint64_t num;
2497                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
2498                     break;
2499                 av_log(matroska->ctx, AV_LOG_INFO,
2500                        "FIXME: implement support for BlockDuration\n");
2501                 break;
2502             }
2503
2504             case MATROSKA_ID_BLOCKREFERENCE:
2505                 /* We've found a reference, so not even the first frame in
2506                  * the lace is a key frame. */
2507                 is_keyframe = 0;
2508                 if (last_num_packets != matroska->num_packets)
2509                     matroska->packets[last_num_packets]->flags = 0;
2510                 res = ebml_read_skip(matroska);
2511                 break;
2512
2513             default:
2514                 av_log(matroska->ctx, AV_LOG_INFO,
2515                        "Unknown entry 0x%x in blockgroup data\n", id);
2516                 /* fall-through */
2517
2518             case EBML_ID_VOID:
2519                 res = ebml_read_skip(matroska);
2520                 break;
2521         }
2522
2523         if (matroska->level_up) {
2524             matroska->level_up--;
2525             break;
2526         }
2527     }
2528
2529     return res;
2530 }
2531
2532 static int
2533 matroska_parse_cluster (MatroskaDemuxContext *matroska)
2534 {
2535     int res = 0;
2536     uint32_t id;
2537     uint64_t cluster_time = 0;
2538
2539     av_log(matroska->ctx, AV_LOG_DEBUG,
2540            "parsing cluster at %"PRId64"\n", url_ftell(&matroska->ctx->pb));
2541
2542     while (res == 0) {
2543         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2544             res = AVERROR_IO;
2545             break;
2546         } else if (matroska->level_up) {
2547             matroska->level_up--;
2548             break;
2549         }
2550
2551         switch (id) {
2552             /* cluster timecode */
2553             case MATROSKA_ID_CLUSTERTIMECODE: {
2554                 uint64_t num;
2555                 if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
2556                     break;
2557                 cluster_time = num * matroska->time_scale;
2558                 break;
2559             }
2560
2561                 /* a group of blocks inside a cluster */
2562             case MATROSKA_ID_BLOCKGROUP:
2563                 if ((res = ebml_read_master(matroska, &id)) < 0)
2564                     break;
2565                 res = matroska_parse_blockgroup(matroska, cluster_time);
2566                 break;
2567
2568             default:
2569                 av_log(matroska->ctx, AV_LOG_INFO,
2570                        "Unknown entry 0x%x in cluster data\n", id);
2571                 /* fall-through */
2572
2573             case EBML_ID_VOID:
2574                 res = ebml_read_skip(matroska);
2575                 break;
2576         }
2577
2578         if (matroska->level_up) {
2579             matroska->level_up--;
2580             break;
2581         }
2582     }
2583
2584     return res;
2585 }
2586
2587 static int
2588 matroska_read_packet (AVFormatContext *s,
2589                       AVPacket        *pkt)
2590 {
2591     MatroskaDemuxContext *matroska = s->priv_data;
2592     int res = 0;
2593     uint32_t id;
2594
2595     /* Do we still have a packet queued? */
2596     if (matroska_deliver_packet(matroska, pkt) == 0)
2597         return 0;
2598
2599     /* Have we already reached the end? */
2600     if (matroska->done)
2601         return AVERROR_IO;
2602
2603     while (res == 0) {
2604         if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2605             res = AVERROR_IO;
2606             break;
2607         } else if (matroska->level_up) {
2608             matroska->level_up--;
2609             break;
2610         }
2611
2612         switch (id) {
2613             case MATROSKA_ID_CLUSTER:
2614                 if ((res = ebml_read_master(matroska, &id)) < 0)
2615                     break;
2616                 if ((res = matroska_parse_cluster(matroska)) == 0)
2617                     res = 1; /* Parsed one cluster, let's get out. */
2618                 break;
2619
2620             default:
2621             case EBML_ID_VOID:
2622                 res = ebml_read_skip(matroska);
2623                 break;
2624         }
2625
2626         if (matroska->level_up) {
2627             matroska->level_up--;
2628             break;
2629         }
2630     }
2631
2632     if (res == -1)
2633         matroska->done = 1;
2634
2635     return matroska_deliver_packet(matroska, pkt);
2636 }
2637
2638 static int
2639 matroska_read_close (AVFormatContext *s)
2640 {
2641     MatroskaDemuxContext *matroska = s->priv_data;
2642     int n = 0;
2643
2644     if (matroska->writing_app)
2645         av_free(matroska->writing_app);
2646     if (matroska->muxing_app)
2647         av_free(matroska->muxing_app);
2648     if (matroska->index)
2649         av_free(matroska->index);
2650
2651     if (matroska->packets != NULL) {
2652         for (n = 0; n < matroska->num_packets; n++) {
2653             av_free_packet(matroska->packets[n]);
2654             av_free(matroska->packets[n]);
2655         }
2656         av_free(matroska->packets);
2657     }
2658
2659     for (n = 0; n < matroska->num_tracks; n++) {
2660         MatroskaTrack *track = matroska->tracks[n];
2661         if (track->codec_id)
2662             av_free(track->codec_id);
2663         if (track->codec_name)
2664             av_free(track->codec_name);
2665         if (track->codec_priv)
2666             av_free(track->codec_priv);
2667         if (track->name)
2668             av_free(track->name);
2669         if (track->language)
2670             av_free(track->language);
2671
2672         av_free(track);
2673     }
2674
2675     for (n = 0; n < s->nb_streams; n++) {
2676         av_free(s->streams[n]->codec->extradata);
2677     }
2678
2679     memset(matroska, 0, sizeof(MatroskaDemuxContext));
2680
2681     return 0;
2682 }
2683
2684 static AVInputFormat matroska_iformat = {
2685     "matroska",
2686     "Matroska file format",
2687     sizeof(MatroskaDemuxContext),
2688     matroska_probe,
2689     matroska_read_header,
2690     matroska_read_packet,
2691     matroska_read_close,
2692 };
2693
2694 int
2695 matroska_init(void)
2696 {
2697     av_register_input_format(&matroska_iformat);
2698     return 0;
2699 }