Statistics
| Branch: | Revision:

ffmpeg / libavformat / matroskadec.c @ 979c0910

History | View | Annotate | Download (87.8 KB)

1
/*
2
 * Matroska file demuxer (no muxer yet)
3
 * Copyright (c) 2003-2004 The ffmpeg Project
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file matroskadec.c
24
 * Matroska file demuxer
25
 * by Ronald Bultje <rbultje@ronald.bitfreak.net>
26
 * with a little help from Moritz Bunkus <moritz@bunkus.org>
27
 * Specs available on the matroska project page:
28
 * http://www.matroska.org/.
29
 */
30

    
31
#include "avformat.h"
32
/* For codec_get_id(). */
33
#include "riff.h"
34
#include "intfloat_readwrite.h"
35
#include "matroska.h"
36

    
37
typedef struct Track {
38
    MatroskaTrackType type;
39

    
40
    /* Unique track number and track ID. stream_index is the index that
41
     * the calling app uses for this track. */
42
    uint32_t num;
43
    uint32_t uid;
44
    int stream_index;
45

    
46
    char *name;
47
    char language[4];
48

    
49
    char *codec_id;
50
    char *codec_name;
51

    
52
    unsigned char *codec_priv;
53
    int codec_priv_size;
54

    
55
    uint64_t default_duration;
56
    MatroskaTrackFlags flags;
57
} MatroskaTrack;
58

    
59
typedef struct MatroskaVideoTrack {
60
    MatroskaTrack track;
61

    
62
    int pixel_width;
63
    int pixel_height;
64
    int display_width;
65
    int display_height;
66

    
67
    uint32_t fourcc;
68

    
69
    MatroskaAspectRatioMode ar_mode;
70
    MatroskaEyeMode eye_mode;
71

    
72
    //..
73
} MatroskaVideoTrack;
74

    
75
typedef struct MatroskaAudioTrack {
76
    MatroskaTrack track;
77

    
78
    int channels;
79
    int bitdepth;
80
    int internal_samplerate;
81
    int samplerate;
82
    int block_align;
83

    
84
    /* real audio header */
85
    int coded_framesize;
86
    int sub_packet_h;
87
    int frame_size;
88
    int sub_packet_size;
89
    int sub_packet_cnt;
90
    int pkt_cnt;
91
    uint8_t *buf;
92
    //..
93
} MatroskaAudioTrack;
94

    
95
typedef struct MatroskaSubtitleTrack {
96
    MatroskaTrack track;
97

    
98
    int ass;
99
    //..
100
} MatroskaSubtitleTrack;
101

    
102
#define MAX_TRACK_SIZE (FFMAX(FFMAX(sizeof(MatroskaVideoTrack), \
103
                                    sizeof(MatroskaAudioTrack)), \
104
                                    sizeof(MatroskaSubtitleTrack)))
105

    
106
typedef struct MatroskaLevel {
107
    uint64_t start;
108
    uint64_t length;
109
} MatroskaLevel;
110

    
111
typedef struct MatroskaDemuxIndex {
112
  uint64_t        pos;   /* of the corresponding *cluster*! */
113
  uint16_t        track; /* reference to 'num' */
114
  uint64_t        time;  /* in nanoseconds */
115
} MatroskaDemuxIndex;
116

    
117
typedef struct MatroskaDemuxContext {
118
    AVFormatContext *ctx;
119

    
120
    /* ebml stuff */
121
    int num_levels;
122
    MatroskaLevel levels[EBML_MAX_DEPTH];
123
    int level_up;
124

    
125
    /* matroska stuff */
126
    char *writing_app;
127
    char *muxing_app;
128
    int64_t created;
129

    
130
    /* timescale in the file */
131
    int64_t time_scale;
132

    
133
    /* num_streams is the number of streams that av_new_stream() was called
134
     * for ( = that are available to the calling program). */
135
    int num_tracks;
136
    int num_streams;
137
    MatroskaTrack *tracks[MAX_STREAMS];
138

    
139
    /* cache for ID peeking */
140
    uint32_t peek_id;
141

    
142
    /* byte position of the segment inside the stream */
143
    offset_t segment_start;
144

    
145
    /* The packet queue. */
146
    AVPacket **packets;
147
    int num_packets;
148

    
149
    /* have we already parse metadata/cues/clusters? */
150
    int metadata_parsed;
151
    int index_parsed;
152
    int done;
153

    
154
    /* The index for seeking. */
155
    int num_indexes;
156
    MatroskaDemuxIndex *index;
157

    
158
    /* What to skip before effectively reading a packet. */
159
    int skip_to_keyframe;
160
    AVStream *skip_to_stream;
161
} MatroskaDemuxContext;
162

    
163
/*
164
 * The first few functions handle EBML file parsing. The rest
165
 * is the document interpretation. Matroska really just is a
166
 * EBML file.
167
 */
168

    
169
/*
170
 * Return: the amount of levels in the hierarchy that the
171
 * current element lies higher than the previous one.
172
 * The opposite isn't done - that's auto-done using master
173
 * element reading.
174
 */
175

    
176
static int
177
ebml_read_element_level_up (MatroskaDemuxContext *matroska)
178
{
179
    ByteIOContext *pb = &matroska->ctx->pb;
180
    offset_t pos = url_ftell(pb);
181
    int num = 0;
182

    
183
    while (matroska->num_levels > 0) {
184
        MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
185

    
186
        if (pos >= level->start + level->length) {
187
            matroska->num_levels--;
188
            num++;
189
        } else {
190
            break;
191
        }
192
    }
193

    
194
    return num;
195
}
196

    
197
/*
198
 * Read: an "EBML number", which is defined as a variable-length
199
 * array of bytes. The first byte indicates the length by giving a
200
 * number of 0-bits followed by a one. The position of the first
201
 * "one" bit inside the first byte indicates the length of this
202
 * number.
203
 * Returns: num. of bytes read. < 0 on error.
204
 */
205

    
206
static int
207
ebml_read_num (MatroskaDemuxContext *matroska,
208
               int                   max_size,
209
               uint64_t             *number)
210
{
211
    ByteIOContext *pb = &matroska->ctx->pb;
212
    int len_mask = 0x80, read = 1, n = 1;
213
    int64_t total = 0;
214

    
215
    /* the first byte tells us the length in bytes - get_byte() can normally
216
     * return 0, but since that's not a valid first ebmlID byte, we can
217
     * use it safely here to catch EOS. */
218
    if (!(total = get_byte(pb))) {
219
        /* we might encounter EOS here */
220
        if (!url_feof(pb)) {
221
            offset_t pos = url_ftell(pb);
222
            av_log(matroska->ctx, AV_LOG_ERROR,
223
                   "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
224
                   pos, pos);
225
        }
226
        return AVERROR_IO; /* EOS or actual I/O error */
227
    }
228

    
229
    /* get the length of the EBML number */
230
    while (read <= max_size && !(total & len_mask)) {
231
        read++;
232
        len_mask >>= 1;
233
    }
234
    if (read > max_size) {
235
        offset_t pos = url_ftell(pb) - 1;
236
        av_log(matroska->ctx, AV_LOG_ERROR,
237
               "Invalid EBML number size tag 0x%02x at pos %"PRIu64" (0x%"PRIx64")\n",
238
               (uint8_t) total, pos, pos);
239
        return AVERROR_INVALIDDATA;
240
    }
241

    
242
    /* read out length */
243
    total &= ~len_mask;
244
    while (n++ < read)
245
        total = (total << 8) | get_byte(pb);
246

    
247
    *number = total;
248

    
249
    return read;
250
}
251

    
252
/*
253
 * Read: the element content data ID.
254
 * Return: the number of bytes read or < 0 on error.
255
 */
256

    
257
static int
258
ebml_read_element_id (MatroskaDemuxContext *matroska,
259
                      uint32_t             *id,
260
                      int                  *level_up)
261
{
262
    int read;
263
    uint64_t total;
264

    
265
    /* if we re-call this, use our cached ID */
266
    if (matroska->peek_id != 0) {
267
        if (level_up)
268
            *level_up = 0;
269
        *id = matroska->peek_id;
270
        return 0;
271
    }
272

    
273
    /* read out the "EBML number", include tag in ID */
274
    if ((read = ebml_read_num(matroska, 4, &total)) < 0)
275
        return read;
276
    *id = matroska->peek_id  = total | (1 << (read * 7));
277

    
278
    /* level tracking */
279
    if (level_up)
280
        *level_up = ebml_read_element_level_up(matroska);
281

    
282
    return read;
283
}
284

    
285
/*
286
 * Read: element content length.
287
 * Return: the number of bytes read or < 0 on error.
288
 */
289

    
290
static int
291
ebml_read_element_length (MatroskaDemuxContext *matroska,
292
                          uint64_t             *length)
293
{
294
    /* clear cache since we're now beyond that data point */
295
    matroska->peek_id = 0;
296

    
297
    /* read out the "EBML number", include tag in ID */
298
    return ebml_read_num(matroska, 8, length);
299
}
300

    
301
/*
302
 * Return: the ID of the next element, or 0 on error.
303
 * Level_up contains the amount of levels that this
304
 * next element lies higher than the previous one.
305
 */
306

    
307
static uint32_t
308
ebml_peek_id (MatroskaDemuxContext *matroska,
309
              int                  *level_up)
310
{
311
    uint32_t id;
312

    
313
    assert(level_up != NULL);
314

    
315
    if (ebml_read_element_id(matroska, &id, level_up) < 0)
316
        return 0;
317

    
318
    return id;
319
}
320

    
321
/*
322
 * Seek to a given offset.
323
 * 0 is success, -1 is failure.
324
 */
325

    
326
static int
327
ebml_read_seek (MatroskaDemuxContext *matroska,
328
                offset_t              offset)
329
{
330
    ByteIOContext *pb = &matroska->ctx->pb;
331

    
332
    /* clear ID cache, if any */
333
    matroska->peek_id = 0;
334

    
335
    return (url_fseek(pb, offset, SEEK_SET) == offset) ? 0 : -1;
336
}
337

    
338
/*
339
 * Skip the next element.
340
 * 0 is success, -1 is failure.
341
 */
342

    
343
static int
344
ebml_read_skip (MatroskaDemuxContext *matroska)
345
{
346
    ByteIOContext *pb = &matroska->ctx->pb;
347
    uint32_t id;
348
    uint64_t length;
349
    int res;
350

    
351
    if ((res = ebml_read_element_id(matroska, &id, NULL)) < 0 ||
352
        (res = ebml_read_element_length(matroska, &length)) < 0)
353
        return res;
354

    
355
    url_fskip(pb, length);
356

    
357
    return 0;
358
}
359

    
360
/*
361
 * Read the next element as an unsigned int.
362
 * 0 is success, < 0 is failure.
363
 */
364

    
365
static int
366
ebml_read_uint (MatroskaDemuxContext *matroska,
367
                uint32_t             *id,
368
                uint64_t             *num)
369
{
370
    ByteIOContext *pb = &matroska->ctx->pb;
371
    int n = 0, size, res;
372
    uint64_t rlength;
373

    
374
    if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
375
        (res = ebml_read_element_length(matroska, &rlength)) < 0)
376
        return res;
377
    size = rlength;
378
    if (size < 1 || size > 8) {
379
        offset_t pos = url_ftell(pb);
380
        av_log(matroska->ctx, AV_LOG_ERROR,
381
               "Invalid uint element size %d at position %"PRId64" (0x%"PRIx64")\n",
382
                size, pos, pos);
383
        return AVERROR_INVALIDDATA;
384
    }
385

    
386
    /* big-endian ordening; build up number */
387
    *num = 0;
388
    while (n++ < size)
389
        *num = (*num << 8) | get_byte(pb);
390

    
391
    return 0;
392
}
393

    
394
/*
395
 * Read the next element as a signed int.
396
 * 0 is success, < 0 is failure.
397
 */
398

    
399
static int
400
ebml_read_sint (MatroskaDemuxContext *matroska,
401
                uint32_t             *id,
402
                int64_t              *num)
403
{
404
    ByteIOContext *pb = &matroska->ctx->pb;
405
    int size, n = 1, negative = 0, res;
406
    uint64_t rlength;
407

    
408
    if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
409
        (res = ebml_read_element_length(matroska, &rlength)) < 0)
410
        return res;
411
    size = rlength;
412
    if (size < 1 || size > 8) {
413
        offset_t pos = url_ftell(pb);
414
        av_log(matroska->ctx, AV_LOG_ERROR,
415
               "Invalid sint element size %d at position %"PRId64" (0x%"PRIx64")\n",
416
                size, pos, pos);
417
        return AVERROR_INVALIDDATA;
418
    }
419
    if ((*num = get_byte(pb)) & 0x80) {
420
        negative = 1;
421
        *num &= ~0x80;
422
    }
423
    while (n++ < size)
424
        *num = (*num << 8) | get_byte(pb);
425

    
426
    /* make signed */
427
    if (negative)
428
        *num = *num - (1LL << ((8 * size) - 1));
429

    
430
    return 0;
431
}
432

    
433
/*
434
 * Read the next element as a float.
435
 * 0 is success, < 0 is failure.
436
 */
437

    
438
static int
439
ebml_read_float (MatroskaDemuxContext *matroska,
440
                 uint32_t             *id,
441
                 double               *num)
442
{
443
    ByteIOContext *pb = &matroska->ctx->pb;
444
    int size, res;
445
    uint64_t rlength;
446

    
447
    if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
448
        (res = ebml_read_element_length(matroska, &rlength)) < 0)
449
        return res;
450
    size = rlength;
451

    
452
    if (size == 4) {
453
        *num= av_int2flt(get_be32(pb));
454
    } else if(size==8){
455
        *num= av_int2dbl(get_be64(pb));
456
    } else{
457
        offset_t pos = url_ftell(pb);
458
        av_log(matroska->ctx, AV_LOG_ERROR,
459
               "Invalid float element size %d at position %"PRIu64" (0x%"PRIx64")\n",
460
               size, pos, pos);
461
        return AVERROR_INVALIDDATA;
462
    }
463

    
464
    return 0;
465
}
466

    
467
/*
468
 * Read the next element as an ASCII string.
469
 * 0 is success, < 0 is failure.
470
 */
471

    
472
static int
473
ebml_read_ascii (MatroskaDemuxContext *matroska,
474
                 uint32_t             *id,
475
                 char                **str)
476
{
477
    ByteIOContext *pb = &matroska->ctx->pb;
478
    int size, res;
479
    uint64_t rlength;
480

    
481
    if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
482
        (res = ebml_read_element_length(matroska, &rlength)) < 0)
483
        return res;
484
    size = rlength;
485

    
486
    /* ebml strings are usually not 0-terminated, so we allocate one
487
     * byte more, read the string and NULL-terminate it ourselves. */
488
    if (size < 0 || !(*str = av_malloc(size + 1))) {
489
        av_log(matroska->ctx, AV_LOG_ERROR, "Memory allocation failed\n");
490
        return AVERROR_NOMEM;
491
    }
492
    if (get_buffer(pb, (uint8_t *) *str, size) != size) {
493
        offset_t pos = url_ftell(pb);
494
        av_log(matroska->ctx, AV_LOG_ERROR,
495
               "Read error at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
496
        return AVERROR_IO;
497
    }
498
    (*str)[size] = '\0';
499

    
500
    return 0;
501
}
502

    
503
/*
504
 * Read the next element as a UTF-8 string.
505
 * 0 is success, < 0 is failure.
506
 */
507

    
508
static int
509
ebml_read_utf8 (MatroskaDemuxContext *matroska,
510
                uint32_t             *id,
511
                char                **str)
512
{
513
  return ebml_read_ascii(matroska, id, str);
514
}
515

    
516
/*
517
 * Read the next element as a date (nanoseconds since 1/1/2000).
518
 * 0 is success, < 0 is failure.
519
 */
520

    
521
static int
522
ebml_read_date (MatroskaDemuxContext *matroska,
523
                uint32_t             *id,
524
                int64_t              *date)
525
{
526
  return ebml_read_sint(matroska, id, date);
527
}
528

    
529
/*
530
 * Read the next element, but only the header. The contents
531
 * are supposed to be sub-elements which can be read separately.
532
 * 0 is success, < 0 is failure.
533
 */
534

    
535
static int
536
ebml_read_master (MatroskaDemuxContext *matroska,
537
                  uint32_t             *id)
538
{
539
    ByteIOContext *pb = &matroska->ctx->pb;
540
    uint64_t length;
541
    MatroskaLevel *level;
542
    int res;
543

    
544
    if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
545
        (res = ebml_read_element_length(matroska, &length)) < 0)
546
        return res;
547

    
548
    /* protect... (Heaven forbids that the '>' is true) */
549
    if (matroska->num_levels >= EBML_MAX_DEPTH) {
550
        av_log(matroska->ctx, AV_LOG_ERROR,
551
               "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
552
        return AVERROR_NOTSUPP;
553
    }
554

    
555
    /* remember level */
556
    level = &matroska->levels[matroska->num_levels++];
557
    level->start = url_ftell(pb);
558
    level->length = length;
559

    
560
    return 0;
561
}
562

    
563
/*
564
 * Read the next element as binary data.
565
 * 0 is success, < 0 is failure.
566
 */
567

    
568
static int
569
ebml_read_binary (MatroskaDemuxContext *matroska,
570
                  uint32_t             *id,
571
                  uint8_t             **binary,
572
                  int                  *size)
573
{
574
    ByteIOContext *pb = &matroska->ctx->pb;
575
    uint64_t rlength;
576
    int res;
577

    
578
    if ((res = ebml_read_element_id(matroska, id, NULL)) < 0 ||
579
        (res = ebml_read_element_length(matroska, &rlength)) < 0)
580
        return res;
581
    *size = rlength;
582

    
583
    if (!(*binary = av_malloc(*size))) {
584
        av_log(matroska->ctx, AV_LOG_ERROR,
585
               "Memory allocation error\n");
586
        return AVERROR_NOMEM;
587
    }
588

    
589
    if (get_buffer(pb, *binary, *size) != *size) {
590
        offset_t pos = url_ftell(pb);
591
        av_log(matroska->ctx, AV_LOG_ERROR,
592
               "Read error at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
593
        return AVERROR_IO;
594
    }
595

    
596
    return 0;
597
}
598

    
599
/*
600
 * Read signed/unsigned "EBML" numbers.
601
 * Return: number of bytes processed, < 0 on error.
602
 * XXX: use ebml_read_num().
603
 */
604

    
605
static int
606
matroska_ebmlnum_uint (uint8_t  *data,
607
                       uint32_t  size,
608
                       uint64_t *num)
609
{
610
    int len_mask = 0x80, read = 1, n = 1, num_ffs = 0;
611
    uint64_t total;
612

    
613
    if (size <= 0)
614
        return AVERROR_INVALIDDATA;
615

    
616
    total = data[0];
617
    while (read <= 8 && !(total & len_mask)) {
618
        read++;
619
        len_mask >>= 1;
620
    }
621
    if (read > 8)
622
        return AVERROR_INVALIDDATA;
623

    
624
    if ((total &= (len_mask - 1)) == len_mask - 1)
625
        num_ffs++;
626
    if (size < read)
627
        return AVERROR_INVALIDDATA;
628
    while (n < read) {
629
        if (data[n] == 0xff)
630
            num_ffs++;
631
        total = (total << 8) | data[n];
632
        n++;
633
    }
634

    
635
    if (read == num_ffs)
636
        *num = (uint64_t)-1;
637
    else
638
        *num = total;
639

    
640
    return read;
641
}
642

    
643
/*
644
 * Same as above, but signed.
645
 */
646

    
647
static int
648
matroska_ebmlnum_sint (uint8_t  *data,
649
                       uint32_t  size,
650
                       int64_t  *num)
651
{
652
    uint64_t unum;
653
    int res;
654

    
655
    /* read as unsigned number first */
656
    if ((res = matroska_ebmlnum_uint(data, size, &unum)) < 0)
657
        return res;
658

    
659
    /* make signed (weird way) */
660
    if (unum == (uint64_t)-1)
661
        *num = INT64_MAX;
662
    else
663
        *num = unum - ((1LL << ((7 * res) - 1)) - 1);
664

    
665
    return res;
666
}
667

    
668
/*
669
 * Read an EBML header.
670
 * 0 is success, < 0 is failure.
671
 */
672

    
673
static int
674
ebml_read_header (MatroskaDemuxContext *matroska,
675
                  char                **doctype,
676
                  int                  *version)
677
{
678
    uint32_t id;
679
    int level_up, res = 0;
680

    
681
    /* default init */
682
    if (doctype)
683
        *doctype = NULL;
684
    if (version)
685
        *version = 1;
686

    
687
    if (!(id = ebml_peek_id(matroska, &level_up)) ||
688
        level_up != 0 || id != EBML_ID_HEADER) {
689
        av_log(matroska->ctx, AV_LOG_ERROR,
690
               "This is not an EBML file (id=0x%x/0x%x)\n", id, EBML_ID_HEADER);
691
        return AVERROR_INVALIDDATA;
692
    }
693
    if ((res = ebml_read_master(matroska, &id)) < 0)
694
        return res;
695

    
696
    while (res == 0) {
697
        if (!(id = ebml_peek_id(matroska, &level_up)))
698
            return AVERROR_IO;
699

    
700
        /* end-of-header */
701
        if (level_up)
702
            break;
703

    
704
        switch (id) {
705
            /* is our read version uptodate? */
706
            case EBML_ID_EBMLREADVERSION: {
707
                uint64_t num;
708

    
709
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
710
                    return res;
711
                if (num > EBML_VERSION) {
712
                    av_log(matroska->ctx, AV_LOG_ERROR,
713
                           "EBML version %"PRIu64" (> %d) is not supported\n",
714
                           num, EBML_VERSION);
715
                    return AVERROR_INVALIDDATA;
716
                }
717
                break;
718
            }
719

    
720
            /* we only handle 8 byte lengths at max */
721
            case EBML_ID_EBMLMAXSIZELENGTH: {
722
                uint64_t num;
723

    
724
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
725
                    return res;
726
                if (num > sizeof(uint64_t)) {
727
                    av_log(matroska->ctx, AV_LOG_ERROR,
728
                           "Integers of size %"PRIu64" (> %zd) not supported\n",
729
                           num, sizeof(uint64_t));
730
                    return AVERROR_INVALIDDATA;
731
                }
732
                break;
733
            }
734

    
735
            /* we handle 4 byte IDs at max */
736
            case EBML_ID_EBMLMAXIDLENGTH: {
737
                uint64_t num;
738

    
739
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
740
                    return res;
741
                if (num > sizeof(uint32_t)) {
742
                    av_log(matroska->ctx, AV_LOG_ERROR,
743
                           "IDs of size %"PRIu64" (> %zu) not supported\n",
744
                            num, sizeof(uint32_t));
745
                    return AVERROR_INVALIDDATA;
746
                }
747
                break;
748
            }
749

    
750
            case EBML_ID_DOCTYPE: {
751
                char *text;
752

    
753
                if ((res = ebml_read_ascii(matroska, &id, &text)) < 0)
754
                    return res;
755
                if (doctype) {
756
                    if (*doctype)
757
                        av_free(*doctype);
758
                    *doctype = text;
759
                } else
760
                    av_free(text);
761
                break;
762
            }
763

    
764
            case EBML_ID_DOCTYPEREADVERSION: {
765
                uint64_t num;
766

    
767
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
768
                    return res;
769
                if (version)
770
                    *version = num;
771
                break;
772
            }
773

    
774
            default:
775
                av_log(matroska->ctx, AV_LOG_INFO,
776
                       "Unknown data type 0x%x in EBML header", id);
777
                /* pass-through */
778

    
779
            case EBML_ID_VOID:
780
            /* we ignore these two, as they don't tell us anything we
781
             * care about */
782
            case EBML_ID_EBMLVERSION:
783
            case EBML_ID_DOCTYPEVERSION:
784
                res = ebml_read_skip (matroska);
785
                break;
786
        }
787
    }
788

    
789
    return 0;
790
}
791

    
792

    
793
static int
794
matroska_find_track_by_num (MatroskaDemuxContext *matroska,
795
                            int                   num)
796
{
797
    int i;
798

    
799
    for (i = 0; i < matroska->num_tracks; i++)
800
        if (matroska->tracks[i]->num == num)
801
            return i;
802

    
803
    return -1;
804
}
805

    
806

    
807
/*
808
 * Put one packet in an application-supplied AVPacket struct.
809
 * Returns 0 on success or -1 on failure.
810
 */
811

    
812
static int
813
matroska_deliver_packet (MatroskaDemuxContext *matroska,
814
                         AVPacket             *pkt)
815
{
816
    if (matroska->num_packets > 0) {
817
        memcpy(pkt, matroska->packets[0], sizeof(AVPacket));
818
        av_free(matroska->packets[0]);
819
        if (matroska->num_packets > 1) {
820
            memmove(&matroska->packets[0], &matroska->packets[1],
821
                    (matroska->num_packets - 1) * sizeof(AVPacket *));
822
            matroska->packets =
823
                av_realloc(matroska->packets, (matroska->num_packets - 1) *
824
                           sizeof(AVPacket *));
825
        } else {
826
            av_freep(&matroska->packets);
827
        }
828
        matroska->num_packets--;
829
        return 0;
830
    }
831

    
832
    return -1;
833
}
834

    
835
/*
836
 * Put a packet into our internal queue. Will be delivered to the
837
 * user/application during the next get_packet() call.
838
 */
839

    
840
static void
841
matroska_queue_packet (MatroskaDemuxContext *matroska,
842
                       AVPacket             *pkt)
843
{
844
    matroska->packets =
845
        av_realloc(matroska->packets, (matroska->num_packets + 1) *
846
                   sizeof(AVPacket *));
847
    matroska->packets[matroska->num_packets] = pkt;
848
    matroska->num_packets++;
849
}
850

    
851

    
852
/*
853
 * Autodetecting...
854
 */
855

    
856
static int
857
matroska_probe (AVProbeData *p)
858
{
859
    uint64_t total = 0;
860
    int len_mask = 0x80, size = 1, n = 1;
861
    uint8_t probe_data[] = { 'm', 'a', 't', 'r', 'o', 's', 'k', 'a' };
862

    
863
    /* ebml header? */
864
    if (AV_RB32(p->buf) != EBML_ID_HEADER)
865
        return 0;
866

    
867
    /* length of header */
868
    total = p->buf[4];
869
    while (size <= 8 && !(total & len_mask)) {
870
        size++;
871
        len_mask >>= 1;
872
    }
873
    if (size > 8)
874
      return 0;
875
    total &= (len_mask - 1);
876
    while (n < size)
877
        total = (total << 8) | p->buf[4 + n++];
878

    
879
    /* does the probe data contain the whole header? */
880
    if (p->buf_size < 4 + size + total)
881
      return 0;
882

    
883
    /* the header must contain the document type 'matroska'. For now,
884
     * we don't parse the whole header but simply check for the
885
     * availability of that array of characters inside the header.
886
     * Not fully fool-proof, but good enough. */
887
    for (n = 4 + size; n <= 4 + size + total - sizeof(probe_data); n++)
888
        if (!memcmp (&p->buf[n], probe_data, sizeof(probe_data)))
889
            return AVPROBE_SCORE_MAX;
890

    
891
    return 0;
892
}
893

    
894
/*
895
 * From here on, it's all XML-style DTD stuff... Needs no comments.
896
 */
897

    
898
static int
899
matroska_parse_info (MatroskaDemuxContext *matroska)
900
{
901
    int res = 0;
902
    uint32_t id;
903

    
904
    av_log(matroska->ctx, AV_LOG_DEBUG, "Parsing info...\n");
905

    
906
    while (res == 0) {
907
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
908
            res = AVERROR_IO;
909
            break;
910
        } else if (matroska->level_up) {
911
            matroska->level_up--;
912
            break;
913
        }
914

    
915
        switch (id) {
916
            /* cluster timecode */
917
            case MATROSKA_ID_TIMECODESCALE: {
918
                uint64_t num;
919
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
920
                    break;
921
                matroska->time_scale = num;
922
                break;
923
            }
924

    
925
            case MATROSKA_ID_DURATION: {
926
                double num;
927
                if ((res = ebml_read_float(matroska, &id, &num)) < 0)
928
                    break;
929
                matroska->ctx->duration = num * matroska->time_scale * 1000 / AV_TIME_BASE;
930
                break;
931
            }
932

    
933
            case MATROSKA_ID_TITLE: {
934
                char *text;
935
                if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
936
                    break;
937
                strncpy(matroska->ctx->title, text,
938
                        sizeof(matroska->ctx->title)-1);
939
                av_free(text);
940
                break;
941
            }
942

    
943
            case MATROSKA_ID_WRITINGAPP: {
944
                char *text;
945
                if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
946
                    break;
947
                matroska->writing_app = text;
948
                break;
949
            }
950

    
951
            case MATROSKA_ID_MUXINGAPP: {
952
                char *text;
953
                if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
954
                    break;
955
                matroska->muxing_app = text;
956
                break;
957
            }
958

    
959
            case MATROSKA_ID_DATEUTC: {
960
                int64_t time;
961
                if ((res = ebml_read_date(matroska, &id, &time)) < 0)
962
                    break;
963
                matroska->created = time;
964
                break;
965
            }
966

    
967
            default:
968
                av_log(matroska->ctx, AV_LOG_INFO,
969
                       "Unknown entry 0x%x in info header\n", id);
970
                /* fall-through */
971

    
972
            case EBML_ID_VOID:
973
                res = ebml_read_skip(matroska);
974
                break;
975
        }
976

    
977
        if (matroska->level_up) {
978
            matroska->level_up--;
979
            break;
980
        }
981
    }
982

    
983
    return res;
984
}
985

    
986
static int
987
matroska_add_stream (MatroskaDemuxContext *matroska)
988
{
989
    int res = 0;
990
    uint32_t id;
991
    MatroskaTrack *track;
992

    
993
    av_log(matroska->ctx, AV_LOG_DEBUG, "parsing track, adding stream..,\n");
994

    
995
    /* Allocate a generic track. As soon as we know its type we'll realloc. */
996
    track = av_mallocz(MAX_TRACK_SIZE);
997
    matroska->num_tracks++;
998
    strcpy(track->language, "eng");
999

    
1000
    /* start with the master */
1001
    if ((res = ebml_read_master(matroska, &id)) < 0)
1002
        return res;
1003

    
1004
    /* try reading the trackentry headers */
1005
    while (res == 0) {
1006
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1007
            res = AVERROR_IO;
1008
            break;
1009
        } else if (matroska->level_up > 0) {
1010
            matroska->level_up--;
1011
            break;
1012
        }
1013

    
1014
        switch (id) {
1015
            /* track number (unique stream ID) */
1016
            case MATROSKA_ID_TRACKNUMBER: {
1017
                uint64_t num;
1018
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1019
                    break;
1020
                track->num = num;
1021
                break;
1022
            }
1023

    
1024
            /* track UID (unique identifier) */
1025
            case MATROSKA_ID_TRACKUID: {
1026
                uint64_t num;
1027
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1028
                    break;
1029
                track->uid = num;
1030
                break;
1031
            }
1032

    
1033
            /* track type (video, audio, combined, subtitle, etc.) */
1034
            case MATROSKA_ID_TRACKTYPE: {
1035
                uint64_t num;
1036
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1037
                    break;
1038
                if (track->type && track->type != num) {
1039
                    av_log(matroska->ctx, AV_LOG_INFO,
1040
                           "More than one tracktype in an entry - skip\n");
1041
                    break;
1042
                }
1043
                track->type = num;
1044

    
1045
                switch (track->type) {
1046
                    case MATROSKA_TRACK_TYPE_VIDEO:
1047
                    case MATROSKA_TRACK_TYPE_AUDIO:
1048
                    case MATROSKA_TRACK_TYPE_SUBTITLE:
1049
                        break;
1050
                    case MATROSKA_TRACK_TYPE_COMPLEX:
1051
                    case MATROSKA_TRACK_TYPE_LOGO:
1052
                    case MATROSKA_TRACK_TYPE_CONTROL:
1053
                    default:
1054
                        av_log(matroska->ctx, AV_LOG_INFO,
1055
                               "Unknown or unsupported track type 0x%x\n",
1056
                               track->type);
1057
                        track->type = 0;
1058
                        break;
1059
                }
1060
                matroska->tracks[matroska->num_tracks - 1] = track;
1061
                break;
1062
            }
1063

    
1064
            /* tracktype specific stuff for video */
1065
            case MATROSKA_ID_TRACKVIDEO: {
1066
                MatroskaVideoTrack *videotrack;
1067
                if (!track->type)
1068
                    track->type = MATROSKA_TRACK_TYPE_VIDEO;
1069
                if (track->type != MATROSKA_TRACK_TYPE_VIDEO) {
1070
                    av_log(matroska->ctx, AV_LOG_INFO,
1071
                           "video data in non-video track - ignoring\n");
1072
                    res = AVERROR_INVALIDDATA;
1073
                    break;
1074
                } else if ((res = ebml_read_master(matroska, &id)) < 0)
1075
                    break;
1076
                videotrack = (MatroskaVideoTrack *)track;
1077

    
1078
                while (res == 0) {
1079
                    if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1080
                        res = AVERROR_IO;
1081
                        break;
1082
                    } else if (matroska->level_up > 0) {
1083
                        matroska->level_up--;
1084
                        break;
1085
                    }
1086

    
1087
                    switch (id) {
1088
                        /* fixme, this should be one-up, but I get it here */
1089
                        case MATROSKA_ID_TRACKDEFAULTDURATION: {
1090
                            uint64_t num;
1091
                            if ((res = ebml_read_uint (matroska, &id,
1092
                                                       &num)) < 0)
1093
                                break;
1094
                            track->default_duration = num/matroska->time_scale;
1095
                            break;
1096
                        }
1097

    
1098
                        /* video framerate */
1099
                        case MATROSKA_ID_VIDEOFRAMERATE: {
1100
                            double num;
1101
                            if ((res = ebml_read_float(matroska, &id,
1102
                                                       &num)) < 0)
1103
                                break;
1104
                            track->default_duration = 1000000000/(matroska->time_scale*num);
1105
                            break;
1106
                        }
1107

    
1108
                        /* width of the size to display the video at */
1109
                        case MATROSKA_ID_VIDEODISPLAYWIDTH: {
1110
                            uint64_t num;
1111
                            if ((res = ebml_read_uint(matroska, &id,
1112
                                                      &num)) < 0)
1113
                                break;
1114
                            videotrack->display_width = num;
1115
                            break;
1116
                        }
1117

    
1118
                        /* height of the size to display the video at */
1119
                        case MATROSKA_ID_VIDEODISPLAYHEIGHT: {
1120
                            uint64_t num;
1121
                            if ((res = ebml_read_uint(matroska, &id,
1122
                                                      &num)) < 0)
1123
                                break;
1124
                            videotrack->display_height = num;
1125
                            break;
1126
                        }
1127

    
1128
                        /* width of the video in the file */
1129
                        case MATROSKA_ID_VIDEOPIXELWIDTH: {
1130
                            uint64_t num;
1131
                            if ((res = ebml_read_uint(matroska, &id,
1132
                                                      &num)) < 0)
1133
                                break;
1134
                            videotrack->pixel_width = num;
1135
                            break;
1136
                        }
1137

    
1138
                        /* height of the video in the file */
1139
                        case MATROSKA_ID_VIDEOPIXELHEIGHT: {
1140
                            uint64_t num;
1141
                            if ((res = ebml_read_uint(matroska, &id,
1142
                                                      &num)) < 0)
1143
                                break;
1144
                            videotrack->pixel_height = num;
1145
                            break;
1146
                        }
1147

    
1148
                        /* whether the video is interlaced */
1149
                        case MATROSKA_ID_VIDEOFLAGINTERLACED: {
1150
                            uint64_t num;
1151
                            if ((res = ebml_read_uint(matroska, &id,
1152
                                                      &num)) < 0)
1153
                                break;
1154
                            if (num)
1155
                                track->flags |=
1156
                                    MATROSKA_VIDEOTRACK_INTERLACED;
1157
                            else
1158
                                track->flags &=
1159
                                    ~MATROSKA_VIDEOTRACK_INTERLACED;
1160
                            break;
1161
                        }
1162

    
1163
                        /* stereo mode (whether the video has two streams,
1164
                         * where one is for the left eye and the other for
1165
                         * the right eye, which creates a 3D-like
1166
                         * effect) */
1167
                        case MATROSKA_ID_VIDEOSTEREOMODE: {
1168
                            uint64_t num;
1169
                            if ((res = ebml_read_uint(matroska, &id,
1170
                                                      &num)) < 0)
1171
                                break;
1172
                            if (num != MATROSKA_EYE_MODE_MONO &&
1173
                                num != MATROSKA_EYE_MODE_LEFT &&
1174
                                num != MATROSKA_EYE_MODE_RIGHT &&
1175
                                num != MATROSKA_EYE_MODE_BOTH) {
1176
                                av_log(matroska->ctx, AV_LOG_INFO,
1177
                                       "Ignoring unknown eye mode 0x%x\n",
1178
                                       (uint32_t) num);
1179
                                break;
1180
                            }
1181
                            videotrack->eye_mode = num;
1182
                            break;
1183
                        }
1184

    
1185
                        /* aspect ratio behaviour */
1186
                        case MATROSKA_ID_VIDEOASPECTRATIO: {
1187
                            uint64_t num;
1188
                            if ((res = ebml_read_uint(matroska, &id,
1189
                                                      &num)) < 0)
1190
                                break;
1191
                            if (num != MATROSKA_ASPECT_RATIO_MODE_FREE &&
1192
                                num != MATROSKA_ASPECT_RATIO_MODE_KEEP &&
1193
                                num != MATROSKA_ASPECT_RATIO_MODE_FIXED) {
1194
                                av_log(matroska->ctx, AV_LOG_INFO,
1195
                                       "Ignoring unknown aspect ratio 0x%x\n",
1196
                                       (uint32_t) num);
1197
                                break;
1198
                            }
1199
                            videotrack->ar_mode = num;
1200
                            break;
1201
                        }
1202

    
1203
                        /* colourspace (only matters for raw video)
1204
                         * fourcc */
1205
                        case MATROSKA_ID_VIDEOCOLOURSPACE: {
1206
                            uint64_t num;
1207
                            if ((res = ebml_read_uint(matroska, &id,
1208
                                                      &num)) < 0)
1209
                                break;
1210
                            videotrack->fourcc = num;
1211
                            break;
1212
                        }
1213

    
1214
                        default:
1215
                            av_log(matroska->ctx, AV_LOG_INFO,
1216
                                   "Unknown video track header entry "
1217
                                   "0x%x - ignoring\n", id);
1218
                            /* pass-through */
1219

    
1220
                        case EBML_ID_VOID:
1221
                            res = ebml_read_skip(matroska);
1222
                            break;
1223
                    }
1224

    
1225
                    if (matroska->level_up) {
1226
                        matroska->level_up--;
1227
                        break;
1228
                    }
1229
                }
1230
                break;
1231
            }
1232

    
1233
            /* tracktype specific stuff for audio */
1234
            case MATROSKA_ID_TRACKAUDIO: {
1235
                MatroskaAudioTrack *audiotrack;
1236
                if (!track->type)
1237
                    track->type = MATROSKA_TRACK_TYPE_AUDIO;
1238
                if (track->type != MATROSKA_TRACK_TYPE_AUDIO) {
1239
                    av_log(matroska->ctx, AV_LOG_INFO,
1240
                           "audio data in non-audio track - ignoring\n");
1241
                    res = AVERROR_INVALIDDATA;
1242
                    break;
1243
                } else if ((res = ebml_read_master(matroska, &id)) < 0)
1244
                    break;
1245
                audiotrack = (MatroskaAudioTrack *)track;
1246
                audiotrack->channels = 1;
1247
                audiotrack->samplerate = 8000;
1248

    
1249
                while (res == 0) {
1250
                    if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1251
                        res = AVERROR_IO;
1252
                        break;
1253
                    } else if (matroska->level_up > 0) {
1254
                        matroska->level_up--;
1255
                        break;
1256
                    }
1257

    
1258
                    switch (id) {
1259
                        /* samplerate */
1260
                        case MATROSKA_ID_AUDIOSAMPLINGFREQ: {
1261
                            double num;
1262
                            if ((res = ebml_read_float(matroska, &id,
1263
                                                       &num)) < 0)
1264
                                break;
1265
                            audiotrack->internal_samplerate =
1266
                            audiotrack->samplerate = num;
1267
                            break;
1268
                        }
1269

    
1270
                        case MATROSKA_ID_AUDIOOUTSAMPLINGFREQ: {
1271
                            double num;
1272
                            if ((res = ebml_read_float(matroska, &id,
1273
                                                       &num)) < 0)
1274
                                break;
1275
                            audiotrack->samplerate = num;
1276
                            break;
1277
                        }
1278

    
1279
                            /* bitdepth */
1280
                        case MATROSKA_ID_AUDIOBITDEPTH: {
1281
                            uint64_t num;
1282
                            if ((res = ebml_read_uint(matroska, &id,
1283
                                                      &num)) < 0)
1284
                                break;
1285
                            audiotrack->bitdepth = num;
1286
                            break;
1287
                        }
1288

    
1289
                            /* channels */
1290
                        case MATROSKA_ID_AUDIOCHANNELS: {
1291
                            uint64_t num;
1292
                            if ((res = ebml_read_uint(matroska, &id,
1293
                                                      &num)) < 0)
1294
                                break;
1295
                            audiotrack->channels = num;
1296
                            break;
1297
                        }
1298

    
1299
                        default:
1300
                            av_log(matroska->ctx, AV_LOG_INFO,
1301
                                   "Unknown audio track header entry "
1302
                                   "0x%x - ignoring\n", id);
1303
                            /* pass-through */
1304

    
1305
                        case EBML_ID_VOID:
1306
                            res = ebml_read_skip(matroska);
1307
                            break;
1308
                    }
1309

    
1310
                    if (matroska->level_up) {
1311
                        matroska->level_up--;
1312
                        break;
1313
                    }
1314
                }
1315
                break;
1316
            }
1317

    
1318
                /* codec identifier */
1319
            case MATROSKA_ID_CODECID: {
1320
                char *text;
1321
                if ((res = ebml_read_ascii(matroska, &id, &text)) < 0)
1322
                    break;
1323
                track->codec_id = text;
1324
                break;
1325
            }
1326

    
1327
                /* codec private data */
1328
            case MATROSKA_ID_CODECPRIVATE: {
1329
                uint8_t *data;
1330
                int size;
1331
                if ((res = ebml_read_binary(matroska, &id, &data, &size) < 0))
1332
                    break;
1333
                track->codec_priv = data;
1334
                track->codec_priv_size = size;
1335
                break;
1336
            }
1337

    
1338
                /* name of the codec */
1339
            case MATROSKA_ID_CODECNAME: {
1340
                char *text;
1341
                if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1342
                    break;
1343
                track->codec_name = text;
1344
                break;
1345
            }
1346

    
1347
                /* name of this track */
1348
            case MATROSKA_ID_TRACKNAME: {
1349
                char *text;
1350
                if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1351
                    break;
1352
                track->name = text;
1353
                break;
1354
            }
1355

    
1356
                /* language (matters for audio/subtitles, mostly) */
1357
            case MATROSKA_ID_TRACKLANGUAGE: {
1358
                char *text, *end;
1359
                if ((res = ebml_read_utf8(matroska, &id, &text)) < 0)
1360
                    break;
1361
                if ((end = strchr(text, '-')))
1362
                    *end = '\0';
1363
                if (strlen(text) == 3)
1364
                    strcpy(track->language, text);
1365
                av_free(text);
1366
                break;
1367
            }
1368

    
1369
                /* whether this is actually used */
1370
            case MATROSKA_ID_TRACKFLAGENABLED: {
1371
                uint64_t num;
1372
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1373
                    break;
1374
                if (num)
1375
                    track->flags |= MATROSKA_TRACK_ENABLED;
1376
                else
1377
                    track->flags &= ~MATROSKA_TRACK_ENABLED;
1378
                break;
1379
            }
1380

    
1381
                /* whether it's the default for this track type */
1382
            case MATROSKA_ID_TRACKFLAGDEFAULT: {
1383
                uint64_t num;
1384
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1385
                    break;
1386
                if (num)
1387
                    track->flags |= MATROSKA_TRACK_DEFAULT;
1388
                else
1389
                    track->flags &= ~MATROSKA_TRACK_DEFAULT;
1390
                break;
1391
            }
1392

    
1393
                /* lacing (like MPEG, where blocks don't end/start on frame
1394
                 * boundaries) */
1395
            case MATROSKA_ID_TRACKFLAGLACING: {
1396
                uint64_t num;
1397
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1398
                    break;
1399
                if (num)
1400
                    track->flags |= MATROSKA_TRACK_LACING;
1401
                else
1402
                    track->flags &= ~MATROSKA_TRACK_LACING;
1403
                break;
1404
            }
1405

    
1406
                /* default length (in time) of one data block in this track */
1407
            case MATROSKA_ID_TRACKDEFAULTDURATION: {
1408
                uint64_t num;
1409
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
1410
                    break;
1411
                track->default_duration = num / matroska->time_scale;
1412
                break;
1413
            }
1414

    
1415
            default:
1416
                av_log(matroska->ctx, AV_LOG_INFO,
1417
                       "Unknown track header entry 0x%x - ignoring\n", id);
1418
                /* pass-through */
1419

    
1420
            case EBML_ID_VOID:
1421
            /* we ignore these because they're nothing useful. */
1422
            case MATROSKA_ID_CODECINFOURL:
1423
            case MATROSKA_ID_CODECDOWNLOADURL:
1424
            case MATROSKA_ID_TRACKMINCACHE:
1425
            case MATROSKA_ID_TRACKMAXCACHE:
1426
                res = ebml_read_skip(matroska);
1427
                break;
1428
        }
1429

    
1430
        if (matroska->level_up) {
1431
            matroska->level_up--;
1432
            break;
1433
        }
1434
    }
1435

    
1436
    return res;
1437
}
1438

    
1439
static int
1440
matroska_parse_tracks (MatroskaDemuxContext *matroska)
1441
{
1442
    int res = 0;
1443
    uint32_t id;
1444

    
1445
    av_log(matroska->ctx, AV_LOG_DEBUG, "parsing tracks...\n");
1446

    
1447
    while (res == 0) {
1448
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1449
            res = AVERROR_IO;
1450
            break;
1451
        } else if (matroska->level_up) {
1452
            matroska->level_up--;
1453
            break;
1454
        }
1455

    
1456
        switch (id) {
1457
            /* one track within the "all-tracks" header */
1458
            case MATROSKA_ID_TRACKENTRY:
1459
                res = matroska_add_stream(matroska);
1460
                break;
1461

    
1462
            default:
1463
                av_log(matroska->ctx, AV_LOG_INFO,
1464
                       "Unknown entry 0x%x in track header\n", id);
1465
                /* fall-through */
1466

    
1467
            case EBML_ID_VOID:
1468
                res = ebml_read_skip(matroska);
1469
                break;
1470
        }
1471

    
1472
        if (matroska->level_up) {
1473
            matroska->level_up--;
1474
            break;
1475
        }
1476
    }
1477

    
1478
    return res;
1479
}
1480

    
1481
static int
1482
matroska_parse_index (MatroskaDemuxContext *matroska)
1483
{
1484
    int res = 0;
1485
    uint32_t id;
1486
    MatroskaDemuxIndex idx;
1487

    
1488
    av_log(matroska->ctx, AV_LOG_DEBUG, "parsing index...\n");
1489

    
1490
    while (res == 0) {
1491
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1492
            res = AVERROR_IO;
1493
            break;
1494
        } else if (matroska->level_up) {
1495
            matroska->level_up--;
1496
            break;
1497
        }
1498

    
1499
        switch (id) {
1500
            /* one single index entry ('point') */
1501
            case MATROSKA_ID_POINTENTRY:
1502
                if ((res = ebml_read_master(matroska, &id)) < 0)
1503
                    break;
1504

    
1505
                /* in the end, we hope to fill one entry with a
1506
                 * timestamp, a file position and a tracknum */
1507
                idx.pos   = (uint64_t) -1;
1508
                idx.time  = (uint64_t) -1;
1509
                idx.track = (uint16_t) -1;
1510

    
1511
                while (res == 0) {
1512
                    if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1513
                        res = AVERROR_IO;
1514
                        break;
1515
                    } else if (matroska->level_up) {
1516
                        matroska->level_up--;
1517
                        break;
1518
                    }
1519

    
1520
                    switch (id) {
1521
                        /* one single index entry ('point') */
1522
                        case MATROSKA_ID_CUETIME: {
1523
                            uint64_t time;
1524
                            if ((res = ebml_read_uint(matroska, &id,
1525
                                                      &time)) < 0)
1526
                                break;
1527
                            idx.time = time * matroska->time_scale;
1528
                            break;
1529
                        }
1530

    
1531
                        /* position in the file + track to which it
1532
                         * belongs */
1533
                        case MATROSKA_ID_CUETRACKPOSITION:
1534
                            if ((res = ebml_read_master(matroska, &id)) < 0)
1535
                                break;
1536

    
1537
                            while (res == 0) {
1538
                                if (!(id = ebml_peek_id (matroska,
1539
                                                    &matroska->level_up))) {
1540
                                    res = AVERROR_IO;
1541
                                    break;
1542
                                } else if (matroska->level_up) {
1543
                                    matroska->level_up--;
1544
                                    break;
1545
                                }
1546

    
1547
                                switch (id) {
1548
                                    /* track number */
1549
                                    case MATROSKA_ID_CUETRACK: {
1550
                                        uint64_t num;
1551
                                        if ((res = ebml_read_uint(matroska,
1552
                                                          &id, &num)) < 0)
1553
                                            break;
1554
                                        idx.track = num;
1555
                                        break;
1556
                                    }
1557

    
1558
                                        /* position in file */
1559
                                    case MATROSKA_ID_CUECLUSTERPOSITION: {
1560
                                        uint64_t num;
1561
                                        if ((res = ebml_read_uint(matroska,
1562
                                                          &id, &num)) < 0)
1563
                                            break;
1564
                                        idx.pos = num+matroska->segment_start;
1565
                                        break;
1566
                                    }
1567

    
1568
                                    default:
1569
                                        av_log(matroska->ctx, AV_LOG_INFO,
1570
                                               "Unknown entry 0x%x in "
1571
                                               "CuesTrackPositions\n", id);
1572
                                        /* fall-through */
1573

    
1574
                                    case EBML_ID_VOID:
1575
                                        res = ebml_read_skip(matroska);
1576
                                        break;
1577
                                }
1578

    
1579
                                if (matroska->level_up) {
1580
                                    matroska->level_up--;
1581
                                    break;
1582
                                }
1583
                            }
1584

    
1585
                            break;
1586

    
1587
                        default:
1588
                            av_log(matroska->ctx, AV_LOG_INFO,
1589
                                   "Unknown entry 0x%x in cuespoint "
1590
                                   "index\n", id);
1591
                            /* fall-through */
1592

    
1593
                        case EBML_ID_VOID:
1594
                            res = ebml_read_skip(matroska);
1595
                            break;
1596
                    }
1597

    
1598
                    if (matroska->level_up) {
1599
                        matroska->level_up--;
1600
                        break;
1601
                    }
1602
                }
1603

    
1604
                /* so let's see if we got what we wanted */
1605
                if (idx.pos   != (uint64_t) -1 &&
1606
                    idx.time  != (uint64_t) -1 &&
1607
                    idx.track != (uint16_t) -1) {
1608
                    if (matroska->num_indexes % 32 == 0) {
1609
                        /* re-allocate bigger index */
1610
                        matroska->index =
1611
                            av_realloc(matroska->index,
1612
                                       (matroska->num_indexes + 32) *
1613
                                       sizeof(MatroskaDemuxIndex));
1614
                    }
1615
                    matroska->index[matroska->num_indexes] = idx;
1616
                    matroska->num_indexes++;
1617
                }
1618
                break;
1619

    
1620
            default:
1621
                av_log(matroska->ctx, AV_LOG_INFO,
1622
                       "Unknown entry 0x%x in cues header\n", id);
1623
                /* fall-through */
1624

    
1625
            case EBML_ID_VOID:
1626
                res = ebml_read_skip(matroska);
1627
                break;
1628
        }
1629

    
1630
        if (matroska->level_up) {
1631
            matroska->level_up--;
1632
            break;
1633
        }
1634
    }
1635

    
1636
    return res;
1637
}
1638

    
1639
static int
1640
matroska_parse_metadata (MatroskaDemuxContext *matroska)
1641
{
1642
    int res = 0;
1643
    uint32_t id;
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
            /* Hm, this is unsupported... */
1656
            default:
1657
                av_log(matroska->ctx, AV_LOG_INFO,
1658
                       "Unknown entry 0x%x in metadata header\n", id);
1659
                /* fall-through */
1660

    
1661
            case EBML_ID_VOID:
1662
                res = ebml_read_skip(matroska);
1663
                break;
1664
        }
1665

    
1666
        if (matroska->level_up) {
1667
            matroska->level_up--;
1668
            break;
1669
        }
1670
    }
1671

    
1672
    return res;
1673
}
1674

    
1675
static int
1676
matroska_parse_seekhead (MatroskaDemuxContext *matroska)
1677
{
1678
    int res = 0;
1679
    uint32_t id;
1680

    
1681
    av_log(matroska->ctx, AV_LOG_DEBUG, "parsing seekhead...\n");
1682

    
1683
    while (res == 0) {
1684
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1685
            res = AVERROR_IO;
1686
            break;
1687
        } else if (matroska->level_up) {
1688
            matroska->level_up--;
1689
            break;
1690
        }
1691

    
1692
        switch (id) {
1693
            case MATROSKA_ID_SEEKENTRY: {
1694
                uint32_t seek_id = 0, peek_id_cache = 0;
1695
                uint64_t seek_pos = (uint64_t) -1, t;
1696

    
1697
                if ((res = ebml_read_master(matroska, &id)) < 0)
1698
                    break;
1699

    
1700
                while (res == 0) {
1701
                    if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1702
                        res = AVERROR_IO;
1703
                        break;
1704
                    } else if (matroska->level_up) {
1705
                        matroska->level_up--;
1706
                        break;
1707
                    }
1708

    
1709
                    switch (id) {
1710
                        case MATROSKA_ID_SEEKID:
1711
                            res = ebml_read_uint(matroska, &id, &t);
1712
                            seek_id = t;
1713
                            break;
1714

    
1715
                        case MATROSKA_ID_SEEKPOSITION:
1716
                            res = ebml_read_uint(matroska, &id, &seek_pos);
1717
                            break;
1718

    
1719
                        default:
1720
                            av_log(matroska->ctx, AV_LOG_INFO,
1721
                                   "Unknown seekhead ID 0x%x\n", id);
1722
                            /* fall-through */
1723

    
1724
                        case EBML_ID_VOID:
1725
                            res = ebml_read_skip(matroska);
1726
                            break;
1727
                    }
1728

    
1729
                    if (matroska->level_up) {
1730
                        matroska->level_up--;
1731
                        break;
1732
                    }
1733
                }
1734

    
1735
                if (!seek_id || seek_pos == (uint64_t) -1) {
1736
                    av_log(matroska->ctx, AV_LOG_INFO,
1737
                           "Incomplete seekhead entry (0x%x/%"PRIu64")\n",
1738
                           seek_id, seek_pos);
1739
                    break;
1740
                }
1741

    
1742
                switch (seek_id) {
1743
                    case MATROSKA_ID_CUES:
1744
                    case MATROSKA_ID_TAGS: {
1745
                        uint32_t level_up = matroska->level_up;
1746
                        offset_t before_pos;
1747
                        uint64_t length;
1748
                        MatroskaLevel level;
1749

    
1750
                        /* remember the peeked ID and the current position */
1751
                        peek_id_cache = matroska->peek_id;
1752
                        before_pos = url_ftell(&matroska->ctx->pb);
1753

    
1754
                        /* seek */
1755
                        if ((res = ebml_read_seek(matroska, seek_pos +
1756
                                               matroska->segment_start)) < 0)
1757
                            return res;
1758

    
1759
                        /* we don't want to lose our seekhead level, so we add
1760
                         * a dummy. This is a crude hack. */
1761
                        if (matroska->num_levels == EBML_MAX_DEPTH) {
1762
                            av_log(matroska->ctx, AV_LOG_INFO,
1763
                                   "Max EBML element depth (%d) reached, "
1764
                                   "cannot parse further.\n", EBML_MAX_DEPTH);
1765
                            return AVERROR_UNKNOWN;
1766
                        }
1767

    
1768
                        level.start = 0;
1769
                        level.length = (uint64_t)-1;
1770
                        matroska->levels[matroska->num_levels] = level;
1771
                        matroska->num_levels++;
1772

    
1773
                        /* check ID */
1774
                        if (!(id = ebml_peek_id (matroska,
1775
                                                 &matroska->level_up)))
1776
                            goto finish;
1777
                        if (id != seek_id) {
1778
                            av_log(matroska->ctx, AV_LOG_INFO,
1779
                                   "We looked for ID=0x%x but got "
1780
                                   "ID=0x%x (pos=%"PRIu64")",
1781
                                   seek_id, id, seek_pos +
1782
                                   matroska->segment_start);
1783
                            goto finish;
1784
                        }
1785

    
1786
                        /* read master + parse */
1787
                        if ((res = ebml_read_master(matroska, &id)) < 0)
1788
                            goto finish;
1789
                        switch (id) {
1790
                            case MATROSKA_ID_CUES:
1791
                                if (!(res = matroska_parse_index(matroska)) ||
1792
                                    url_feof(&matroska->ctx->pb)) {
1793
                                    matroska->index_parsed = 1;
1794
                                    res = 0;
1795
                                }
1796
                                break;
1797
                            case MATROSKA_ID_TAGS:
1798
                                if (!(res = matroska_parse_metadata(matroska)) ||
1799
                                   url_feof(&matroska->ctx->pb)) {
1800
                                    matroska->metadata_parsed = 1;
1801
                                    res = 0;
1802
                                }
1803
                                break;
1804
                        }
1805

    
1806
                    finish:
1807
                        /* remove dummy level */
1808
                        while (matroska->num_levels) {
1809
                            matroska->num_levels--;
1810
                            length =
1811
                                matroska->levels[matroska->num_levels].length;
1812
                            if (length == (uint64_t)-1)
1813
                                break;
1814
                        }
1815

    
1816
                        /* seek back */
1817
                        if ((res = ebml_read_seek(matroska, before_pos)) < 0)
1818
                            return res;
1819
                        matroska->peek_id = peek_id_cache;
1820
                        matroska->level_up = level_up;
1821
                        break;
1822
                    }
1823

    
1824
                    default:
1825
                        av_log(matroska->ctx, AV_LOG_INFO,
1826
                               "Ignoring seekhead entry for ID=0x%x\n",
1827
                               seek_id);
1828
                        break;
1829
                }
1830

    
1831
                break;
1832
            }
1833

    
1834
            default:
1835
                av_log(matroska->ctx, AV_LOG_INFO,
1836
                       "Unknown seekhead ID 0x%x\n", id);
1837
                /* fall-through */
1838

    
1839
            case EBML_ID_VOID:
1840
                res = ebml_read_skip(matroska);
1841
                break;
1842
        }
1843

    
1844
        if (matroska->level_up) {
1845
            matroska->level_up--;
1846
            break;
1847
        }
1848
    }
1849

    
1850
    return res;
1851
}
1852

    
1853
#define ARRAY_SIZE(x)  (sizeof(x)/sizeof(*x))
1854

    
1855
static int
1856
matroska_aac_profile (char *codec_id)
1857
{
1858
    static const char *aac_profiles[] = {
1859
        "MAIN", "LC", "SSR"
1860
    };
1861
    int profile;
1862

    
1863
    for (profile=0; profile<ARRAY_SIZE(aac_profiles); profile++)
1864
        if (strstr(codec_id, aac_profiles[profile]))
1865
            break;
1866
    return profile + 1;
1867
}
1868

    
1869
static int
1870
matroska_aac_sri (int samplerate)
1871
{
1872
    static const int aac_sample_rates[] = {
1873
        96000, 88200, 64000, 48000, 44100, 32000,
1874
        24000, 22050, 16000, 12000, 11025,  8000,
1875
    };
1876
    int sri;
1877

    
1878
    for (sri=0; sri<ARRAY_SIZE(aac_sample_rates); sri++)
1879
        if (aac_sample_rates[sri] == samplerate)
1880
            break;
1881
    return sri;
1882
}
1883

    
1884
static int
1885
matroska_read_header (AVFormatContext    *s,
1886
                      AVFormatParameters *ap)
1887
{
1888
    MatroskaDemuxContext *matroska = s->priv_data;
1889
    char *doctype;
1890
    int version, last_level, res = 0;
1891
    uint32_t id;
1892

    
1893
    matroska->ctx = s;
1894

    
1895
    /* First read the EBML header. */
1896
    doctype = NULL;
1897
    if ((res = ebml_read_header(matroska, &doctype, &version)) < 0)
1898
        return res;
1899
    if ((doctype == NULL) || strcmp(doctype, "matroska")) {
1900
        av_log(matroska->ctx, AV_LOG_ERROR,
1901
               "Wrong EBML doctype ('%s' != 'matroska').\n",
1902
               doctype ? doctype : "(none)");
1903
        if (doctype)
1904
            av_free(doctype);
1905
        return AVERROR_NOFMT;
1906
    }
1907
    av_free(doctype);
1908
    if (version > 2) {
1909
        av_log(matroska->ctx, AV_LOG_ERROR,
1910
               "Matroska demuxer version 2 too old for file version %d\n",
1911
               version);
1912
        return AVERROR_NOFMT;
1913
    }
1914

    
1915
    /* The next thing is a segment. */
1916
    while (1) {
1917
        if (!(id = ebml_peek_id(matroska, &last_level)))
1918
            return AVERROR_IO;
1919
        if (id == MATROSKA_ID_SEGMENT)
1920
            break;
1921

    
1922
        /* oi! */
1923
        av_log(matroska->ctx, AV_LOG_INFO,
1924
               "Expected a Segment ID (0x%x), but received 0x%x!\n",
1925
               MATROSKA_ID_SEGMENT, id);
1926
        if ((res = ebml_read_skip(matroska)) < 0)
1927
            return res;
1928
    }
1929

    
1930
    /* We now have a Matroska segment.
1931
     * Seeks are from the beginning of the segment,
1932
     * after the segment ID/length. */
1933
    if ((res = ebml_read_master(matroska, &id)) < 0)
1934
        return res;
1935
    matroska->segment_start = url_ftell(&s->pb);
1936

    
1937
    matroska->time_scale = 1000000;
1938
    /* we've found our segment, start reading the different contents in here */
1939
    while (res == 0) {
1940
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
1941
            res = AVERROR_IO;
1942
            break;
1943
        } else if (matroska->level_up) {
1944
            matroska->level_up--;
1945
            break;
1946
        }
1947

    
1948
        switch (id) {
1949
            /* stream info */
1950
            case MATROSKA_ID_INFO: {
1951
                if ((res = ebml_read_master(matroska, &id)) < 0)
1952
                    break;
1953
                res = matroska_parse_info(matroska);
1954
                break;
1955
            }
1956

    
1957
            /* track info headers */
1958
            case MATROSKA_ID_TRACKS: {
1959
                if ((res = ebml_read_master(matroska, &id)) < 0)
1960
                    break;
1961
                res = matroska_parse_tracks(matroska);
1962
                break;
1963
            }
1964

    
1965
            /* stream index */
1966
            case MATROSKA_ID_CUES: {
1967
                if (!matroska->index_parsed) {
1968
                    if ((res = ebml_read_master(matroska, &id)) < 0)
1969
                        break;
1970
                    res = matroska_parse_index(matroska);
1971
                } else
1972
                    res = ebml_read_skip(matroska);
1973
                break;
1974
            }
1975

    
1976
            /* metadata */
1977
            case MATROSKA_ID_TAGS: {
1978
                if (!matroska->metadata_parsed) {
1979
                    if ((res = ebml_read_master(matroska, &id)) < 0)
1980
                        break;
1981
                    res = matroska_parse_metadata(matroska);
1982
                } else
1983
                    res = ebml_read_skip(matroska);
1984
                break;
1985
            }
1986

    
1987
            /* file index (if seekable, seek to Cues/Tags to parse it) */
1988
            case MATROSKA_ID_SEEKHEAD: {
1989
                if ((res = ebml_read_master(matroska, &id)) < 0)
1990
                    break;
1991
                res = matroska_parse_seekhead(matroska);
1992
                break;
1993
            }
1994

    
1995
            case MATROSKA_ID_CLUSTER: {
1996
                /* Do not read the master - this will be done in the next
1997
                 * call to matroska_read_packet. */
1998
                res = 1;
1999
                break;
2000
            }
2001

    
2002
            default:
2003
                av_log(matroska->ctx, AV_LOG_INFO,
2004
                       "Unknown matroska file header ID 0x%x\n", id);
2005
            /* fall-through */
2006

    
2007
            case EBML_ID_VOID:
2008
                res = ebml_read_skip(matroska);
2009
                break;
2010
        }
2011

    
2012
        if (matroska->level_up) {
2013
            matroska->level_up--;
2014
            break;
2015
        }
2016
    }
2017

    
2018
    /* Have we found a cluster? */
2019
    if (ebml_peek_id(matroska, NULL) == MATROSKA_ID_CLUSTER) {
2020
        int i, j;
2021
        MatroskaTrack *track;
2022
        AVStream *st;
2023

    
2024
        for (i = 0; i < matroska->num_tracks; i++) {
2025
            enum CodecID codec_id = CODEC_ID_NONE;
2026
            uint8_t *extradata = NULL;
2027
            int extradata_size = 0;
2028
            int extradata_offset = 0;
2029
            track = matroska->tracks[i];
2030
            track->stream_index = -1;
2031

    
2032
            /* Apply some sanity checks. */
2033
            if (track->codec_id == NULL)
2034
                continue;
2035

    
2036
            for(j=0; ff_mkv_codec_tags[j].str; j++){
2037
                if(!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
2038
                            strlen(ff_mkv_codec_tags[j].str))){
2039
                    codec_id= ff_mkv_codec_tags[j].id;
2040
                    break;
2041
                }
2042
            }
2043

    
2044
            /* Set the FourCC from the CodecID. */
2045
            /* This is the MS compatibility mode which stores a
2046
             * BITMAPINFOHEADER in the CodecPrivate. */
2047
            if (!strcmp(track->codec_id,
2048
                        MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC) &&
2049
                (track->codec_priv_size >= 40) &&
2050
                (track->codec_priv != NULL)) {
2051
                MatroskaVideoTrack *vtrack = (MatroskaVideoTrack *) track;
2052

    
2053
                /* Offset of biCompression. Stored in LE. */
2054
                vtrack->fourcc = AV_RL32(track->codec_priv + 16);
2055
                codec_id = codec_get_id(codec_bmp_tags, vtrack->fourcc);
2056

    
2057
            }
2058

    
2059
            /* This is the MS compatibility mode which stores a
2060
             * WAVEFORMATEX in the CodecPrivate. */
2061
            else if (!strcmp(track->codec_id,
2062
                             MATROSKA_CODEC_ID_AUDIO_ACM) &&
2063
                (track->codec_priv_size >= 18) &&
2064
                (track->codec_priv != NULL)) {
2065
                uint16_t tag;
2066

    
2067
                /* Offset of wFormatTag. Stored in LE. */
2068
                tag = AV_RL16(track->codec_priv);
2069
                codec_id = codec_get_id(codec_wav_tags, tag);
2070

    
2071
            }
2072

    
2073
            else if (codec_id == CODEC_ID_AAC && !track->codec_priv_size) {
2074
                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
2075
                int profile = matroska_aac_profile(track->codec_id);
2076
                int sri = matroska_aac_sri(audiotrack->internal_samplerate);
2077
                extradata = av_malloc(5);
2078
                if (extradata == NULL)
2079
                    return AVERROR_NOMEM;
2080
                extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
2081
                extradata[1] = ((sri&0x01) << 7) | (audiotrack->channels<<3);
2082
                if (strstr(track->codec_id, "SBR")) {
2083
                    sri = matroska_aac_sri(audiotrack->samplerate);
2084
                    extradata[2] = 0x56;
2085
                    extradata[3] = 0xE5;
2086
                    extradata[4] = 0x80 | (sri<<3);
2087
                    extradata_size = 5;
2088
                } else {
2089
                    extradata_size = 2;
2090
                }
2091
                track->default_duration = 1024*1000 / audiotrack->internal_samplerate;
2092
            }
2093

    
2094
            else if (codec_id == CODEC_ID_TTA) {
2095
                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *) track;
2096
                ByteIOContext b;
2097
                extradata_size = 30;
2098
                extradata = av_mallocz(extradata_size);
2099
                if (extradata == NULL)
2100
                    return AVERROR_NOMEM;
2101
                init_put_byte(&b, extradata, extradata_size, 1,
2102
                              NULL, NULL, NULL, NULL);
2103
                put_buffer(&b, (uint8_t *) "TTA1", 4);
2104
                put_le16(&b, 1);
2105
                put_le16(&b, audiotrack->channels);
2106
                put_le16(&b, audiotrack->bitdepth);
2107
                put_le32(&b, audiotrack->samplerate);
2108
                put_le32(&b, matroska->ctx->duration * audiotrack->samplerate);
2109
            }
2110

    
2111
            else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
2112
                     codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
2113
                extradata_offset = 26;
2114
                track->codec_priv_size -= extradata_offset;
2115
                track->flags |= MATROSKA_TRACK_REAL_V;
2116
            }
2117

    
2118
            else if (codec_id == CODEC_ID_RA_144) {
2119
                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2120
                audiotrack->samplerate = 8000;
2121
                audiotrack->channels = 1;
2122
            }
2123

    
2124
            else if (codec_id == CODEC_ID_RA_288 ||
2125
                     codec_id == CODEC_ID_COOK ||
2126
                     codec_id == CODEC_ID_ATRAC3) {
2127
                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2128
                ByteIOContext b;
2129

    
2130
                init_put_byte(&b, track->codec_priv, track->codec_priv_size, 0,
2131
                              NULL, NULL, NULL, NULL);
2132
                url_fskip(&b, 24);
2133
                audiotrack->coded_framesize = get_be32(&b);
2134
                url_fskip(&b, 12);
2135
                audiotrack->sub_packet_h    = get_be16(&b);
2136
                audiotrack->frame_size      = get_be16(&b);
2137
                audiotrack->sub_packet_size = get_be16(&b);
2138
                audiotrack->buf = av_malloc(audiotrack->frame_size * audiotrack->sub_packet_h);
2139
                if (codec_id == CODEC_ID_RA_288) {
2140
                    audiotrack->block_align = audiotrack->coded_framesize;
2141
                    track->codec_priv_size = 0;
2142
                } else {
2143
                    audiotrack->block_align = audiotrack->sub_packet_size;
2144
                    extradata_offset = 78;
2145
                    track->codec_priv_size -= extradata_offset;
2146
                }
2147
            }
2148

    
2149
            else if (codec_id == CODEC_ID_TEXT) {
2150
                MatroskaSubtitleTrack *subtrack=(MatroskaSubtitleTrack *)track;
2151
                if (!strcmp(track->codec_id, "S_TEXT/ASS") ||
2152
                    !strcmp(track->codec_id, "S_TEXT/SSA"))
2153
                    subtrack->ass = 1;
2154
            }
2155

    
2156
            if (codec_id == CODEC_ID_NONE) {
2157
                av_log(matroska->ctx, AV_LOG_INFO,
2158
                       "Unknown/unsupported CodecID %s.\n",
2159
                       track->codec_id);
2160
            }
2161

    
2162
            track->stream_index = matroska->num_streams;
2163

    
2164
            matroska->num_streams++;
2165
            st = av_new_stream(s, track->stream_index);
2166
            if (st == NULL)
2167
                return AVERROR_NOMEM;
2168
            av_set_pts_info(st, 64, matroska->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
2169

    
2170
            st->codec->codec_id = codec_id;
2171
            st->start_time = 0;
2172
            if (strcmp(track->language, "und"))
2173
                strcpy(st->language, track->language);
2174

    
2175
            if (track->default_duration)
2176
                av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
2177
                          track->default_duration, 1000, 30000);
2178

    
2179
            if(extradata){
2180
                st->codec->extradata = extradata;
2181
                st->codec->extradata_size = extradata_size;
2182
            } else if(track->codec_priv && track->codec_priv_size > 0){
2183
                st->codec->extradata = av_malloc(track->codec_priv_size);
2184
                if(st->codec->extradata == NULL)
2185
                    return AVERROR_NOMEM;
2186
                st->codec->extradata_size = track->codec_priv_size;
2187
                memcpy(st->codec->extradata,track->codec_priv+extradata_offset,
2188
                       track->codec_priv_size);
2189
            }
2190

    
2191
            if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2192
                MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
2193

    
2194
                st->codec->codec_type = CODEC_TYPE_VIDEO;
2195
                st->codec->codec_tag = videotrack->fourcc;
2196
                st->codec->width = videotrack->pixel_width;
2197
                st->codec->height = videotrack->pixel_height;
2198
                if (videotrack->display_width == 0)
2199
                    videotrack->display_width= videotrack->pixel_width;
2200
                if (videotrack->display_height == 0)
2201
                    videotrack->display_height= videotrack->pixel_height;
2202
                av_reduce(&st->codec->sample_aspect_ratio.num,
2203
                          &st->codec->sample_aspect_ratio.den,
2204
                          st->codec->height * videotrack->display_width,
2205
                          st->codec-> width * videotrack->display_height,
2206
                          255);
2207
                st->need_parsing = AVSTREAM_PARSE_HEADERS;
2208
            } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2209
                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2210

    
2211
                st->codec->codec_type = CODEC_TYPE_AUDIO;
2212
                st->codec->sample_rate = audiotrack->samplerate;
2213
                st->codec->channels = audiotrack->channels;
2214
                st->codec->block_align = audiotrack->block_align;
2215
            } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
2216
                st->codec->codec_type = CODEC_TYPE_SUBTITLE;
2217
            }
2218

    
2219
            /* What do we do with private data? E.g. for Vorbis. */
2220
        }
2221
        res = 0;
2222
    }
2223

    
2224
    if (matroska->index_parsed) {
2225
        int i, track, stream;
2226
        for (i=0; i<matroska->num_indexes; i++) {
2227
            MatroskaDemuxIndex *idx = &matroska->index[i];
2228
            track = matroska_find_track_by_num(matroska, idx->track);
2229
            stream = matroska->tracks[track]->stream_index;
2230
            if (stream >= 0)
2231
                av_add_index_entry(matroska->ctx->streams[stream],
2232
                                   idx->pos, idx->time/matroska->time_scale,
2233
                                   0, 0, AVINDEX_KEYFRAME);
2234
        }
2235
    }
2236

    
2237
    return res;
2238
}
2239

    
2240
static inline int
2241
rv_offset(uint8_t *data, int slice, int slices)
2242
{
2243
    return AV_RL32(data+8*slice+4) + 8*slices;
2244
}
2245

    
2246
static int
2247
matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size,
2248
                     int64_t pos, uint64_t cluster_time, uint64_t duration,
2249
                     int is_keyframe, int is_bframe)
2250
{
2251
    int res = 0;
2252
    int track;
2253
    AVStream *st;
2254
    AVPacket *pkt;
2255
    uint8_t *origdata = data;
2256
    int16_t block_time;
2257
    uint32_t *lace_size = NULL;
2258
    int n, flags, laces = 0;
2259
    uint64_t num;
2260

    
2261
    /* first byte(s): tracknum */
2262
    if ((n = matroska_ebmlnum_uint(data, size, &num)) < 0) {
2263
        av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
2264
        av_free(origdata);
2265
        return res;
2266
    }
2267
    data += n;
2268
    size -= n;
2269

    
2270
    /* fetch track from num */
2271
    track = matroska_find_track_by_num(matroska, num);
2272
    if (size <= 3 || track < 0 || track >= matroska->num_tracks) {
2273
        av_log(matroska->ctx, AV_LOG_INFO,
2274
               "Invalid stream %d or size %u\n", track, size);
2275
        av_free(origdata);
2276
        return res;
2277
    }
2278
    if (matroska->tracks[track]->stream_index < 0)
2279
        return res;
2280
    st = matroska->ctx->streams[matroska->tracks[track]->stream_index];
2281
    if (st->discard >= AVDISCARD_ALL) {
2282
        av_free(origdata);
2283
        return res;
2284
    }
2285
    if (duration == AV_NOPTS_VALUE)
2286
        duration = matroska->tracks[track]->default_duration;
2287

    
2288
    /* block_time (relative to cluster time) */
2289
    block_time = AV_RB16(data);
2290
    data += 2;
2291
    flags = *data++;
2292
    size -= 3;
2293
    if (is_keyframe == -1)
2294
        is_keyframe = flags & 1 ? PKT_FLAG_KEY : 0;
2295

    
2296
    if (matroska->skip_to_keyframe) {
2297
        if (!is_keyframe || st != matroska->skip_to_stream)
2298
            return res;
2299
        matroska->skip_to_keyframe = 0;
2300
    }
2301

    
2302
    switch ((flags & 0x06) >> 1) {
2303
        case 0x0: /* no lacing */
2304
            laces = 1;
2305
            lace_size = av_mallocz(sizeof(int));
2306
            lace_size[0] = size;
2307
            break;
2308

    
2309
        case 0x1: /* xiph lacing */
2310
        case 0x2: /* fixed-size lacing */
2311
        case 0x3: /* EBML lacing */
2312
            if (size == 0) {
2313
                res = -1;
2314
                break;
2315
            }
2316
            laces = (*data) + 1;
2317
            data += 1;
2318
            size -= 1;
2319
            lace_size = av_mallocz(laces * sizeof(int));
2320

    
2321
            switch ((flags & 0x06) >> 1) {
2322
                case 0x1: /* xiph lacing */ {
2323
                    uint8_t temp;
2324
                    uint32_t total = 0;
2325
                    for (n = 0; res == 0 && n < laces - 1; n++) {
2326
                        while (1) {
2327
                            if (size == 0) {
2328
                                res = -1;
2329
                                break;
2330
                            }
2331
                            temp = *data;
2332
                            lace_size[n] += temp;
2333
                            data += 1;
2334
                            size -= 1;
2335
                            if (temp != 0xff)
2336
                                break;
2337
                        }
2338
                        total += lace_size[n];
2339
                    }
2340
                    lace_size[n] = size - total;
2341
                    break;
2342
                }
2343

    
2344
                case 0x2: /* fixed-size lacing */
2345
                    for (n = 0; n < laces; n++)
2346
                        lace_size[n] = size / laces;
2347
                    break;
2348

    
2349
                case 0x3: /* EBML lacing */ {
2350
                    uint32_t total;
2351
                    n = matroska_ebmlnum_uint(data, size, &num);
2352
                    if (n < 0) {
2353
                        av_log(matroska->ctx, AV_LOG_INFO,
2354
                               "EBML block data error\n");
2355
                        break;
2356
                    }
2357
                    data += n;
2358
                    size -= n;
2359
                    total = lace_size[0] = num;
2360
                    for (n = 1; res == 0 && n < laces - 1; n++) {
2361
                        int64_t snum;
2362
                        int r;
2363
                        r = matroska_ebmlnum_sint (data, size, &snum);
2364
                        if (r < 0) {
2365
                            av_log(matroska->ctx, AV_LOG_INFO,
2366
                                   "EBML block data error\n");
2367
                            break;
2368
                        }
2369
                        data += r;
2370
                        size -= r;
2371
                        lace_size[n] = lace_size[n - 1] + snum;
2372
                        total += lace_size[n];
2373
                    }
2374
                    lace_size[n] = size - total;
2375
                    break;
2376
                }
2377
            }
2378
            break;
2379
    }
2380

    
2381
    if (res == 0) {
2382
        int real_v = matroska->tracks[track]->flags & MATROSKA_TRACK_REAL_V;
2383
        uint64_t timecode = AV_NOPTS_VALUE;
2384

    
2385
        if (cluster_time != (uint64_t)-1 && cluster_time + block_time >= 0)
2386
            timecode = cluster_time + block_time;
2387

    
2388
        for (n = 0; n < laces; n++) {
2389
            int slice, slices = 1;
2390

    
2391
            if (real_v) {
2392
                slices = *data++ + 1;
2393
                lace_size[n]--;
2394
            }
2395

    
2396
            for (slice=0; slice<slices; slice++) {
2397
                int slice_size, slice_offset = 0;
2398
                if (real_v)
2399
                    slice_offset = rv_offset(data, slice, slices);
2400
                if (slice+1 == slices)
2401
                    slice_size = lace_size[n] - slice_offset;
2402
                else
2403
                    slice_size = rv_offset(data, slice+1, slices) - slice_offset;
2404

    
2405
                if (st->codec->codec_id == CODEC_ID_RA_288 ||
2406
                    st->codec->codec_id == CODEC_ID_COOK ||
2407
                    st->codec->codec_id == CODEC_ID_ATRAC3) {
2408
                    MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)matroska->tracks[track];
2409
                    int a = st->codec->block_align;
2410
                    int sps = audiotrack->sub_packet_size;
2411
                    int cfs = audiotrack->coded_framesize;
2412
                    int h = audiotrack->sub_packet_h;
2413
                    int y = audiotrack->sub_packet_cnt;
2414
                    int w = audiotrack->frame_size;
2415
                    int x;
2416

    
2417
                    if (!audiotrack->pkt_cnt) {
2418
                        if (st->codec->codec_id == CODEC_ID_RA_288)
2419
                            for (x=0; x<h/2; x++)
2420
                                memcpy(audiotrack->buf+x*2*w+y*cfs,
2421
                                       data+x*cfs, cfs);
2422
                        else
2423
                            for (x=0; x<w/sps; x++)
2424
                                memcpy(audiotrack->buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps);
2425

    
2426
                        if (++audiotrack->sub_packet_cnt >= h) {
2427
                            audiotrack->sub_packet_cnt = 0;
2428
                            audiotrack->pkt_cnt = h*w / a;
2429
                        }
2430
                    }
2431
                    while (audiotrack->pkt_cnt) {
2432
                        pkt = av_mallocz(sizeof(AVPacket));
2433
                        av_new_packet(pkt, a);
2434
                        memcpy(pkt->data, audiotrack->buf
2435
                               + a * (h*w / a - audiotrack->pkt_cnt--), a);
2436
                        pkt->pos = pos;
2437
                        pkt->stream_index = matroska->tracks[track]->stream_index;
2438
                        matroska_queue_packet(matroska, pkt);
2439
                    }
2440
                } else {
2441
                    int offset = 0;
2442

    
2443
                    if (st->codec->codec_id == CODEC_ID_TEXT
2444
                        && ((MatroskaSubtitleTrack *)(matroska->tracks[track]))->ass) {
2445
                        int i;
2446
                        for (i=0; i<8 && data[slice_offset+offset]; offset++)
2447
                            if (data[slice_offset+offset] == ',')
2448
                                i++;
2449
                    }
2450

    
2451
                    pkt = av_mallocz(sizeof(AVPacket));
2452
                    /* XXX: prevent data copy... */
2453
                    if (av_new_packet(pkt, slice_size-offset) < 0) {
2454
                        res = AVERROR_NOMEM;
2455
                        n = laces-1;
2456
                        break;
2457
                    }
2458
                    memcpy (pkt->data, data+slice_offset+offset, slice_size-offset);
2459

    
2460
                    if (n == 0)
2461
                        pkt->flags = is_keyframe;
2462
                    pkt->stream_index = matroska->tracks[track]->stream_index;
2463

    
2464
                    pkt->pts = timecode;
2465
                    pkt->pos = pos;
2466
                    pkt->duration = duration;
2467

    
2468
                    matroska_queue_packet(matroska, pkt);
2469
                }
2470

    
2471
                if (timecode != AV_NOPTS_VALUE)
2472
                    timecode = duration ? timecode + duration : AV_NOPTS_VALUE;
2473
            }
2474
            data += lace_size[n];
2475
        }
2476
    }
2477

    
2478
    av_free(lace_size);
2479
    av_free(origdata);
2480
    return res;
2481
}
2482

    
2483
static int
2484
matroska_parse_blockgroup (MatroskaDemuxContext *matroska,
2485
                           uint64_t              cluster_time)
2486
{
2487
    int res = 0;
2488
    uint32_t id;
2489
    int is_bframe = 0;
2490
    int is_keyframe = PKT_FLAG_KEY, last_num_packets = matroska->num_packets;
2491
    uint64_t duration = AV_NOPTS_VALUE;
2492
    uint8_t *data;
2493
    int size = 0;
2494
    int64_t pos = 0;
2495

    
2496
    av_log(matroska->ctx, AV_LOG_DEBUG, "parsing blockgroup...\n");
2497

    
2498
    while (res == 0) {
2499
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2500
            res = AVERROR_IO;
2501
            break;
2502
        } else if (matroska->level_up) {
2503
            matroska->level_up--;
2504
            break;
2505
        }
2506

    
2507
        switch (id) {
2508
            /* one block inside the group. Note, block parsing is one
2509
             * of the harder things, so this code is a bit complicated.
2510
             * See http://www.matroska.org/ for documentation. */
2511
            case MATROSKA_ID_BLOCK: {
2512
                pos = url_ftell(&matroska->ctx->pb);
2513
                res = ebml_read_binary(matroska, &id, &data, &size);
2514
                break;
2515
            }
2516

    
2517
            case MATROSKA_ID_BLOCKDURATION: {
2518
                if ((res = ebml_read_uint(matroska, &id, &duration)) < 0)
2519
                    break;
2520
                break;
2521
            }
2522

    
2523
            case MATROSKA_ID_BLOCKREFERENCE: {
2524
                int64_t num;
2525
                /* We've found a reference, so not even the first frame in
2526
                 * the lace is a key frame. */
2527
                is_keyframe = 0;
2528
                if (last_num_packets != matroska->num_packets)
2529
                    matroska->packets[last_num_packets]->flags = 0;
2530
                if ((res = ebml_read_sint(matroska, &id, &num)) < 0)
2531
                    break;
2532
                if (num > 0)
2533
                    is_bframe = 1;
2534
                break;
2535
            }
2536

    
2537
            default:
2538
                av_log(matroska->ctx, AV_LOG_INFO,
2539
                       "Unknown entry 0x%x in blockgroup data\n", id);
2540
                /* fall-through */
2541

    
2542
            case EBML_ID_VOID:
2543
                res = ebml_read_skip(matroska);
2544
                break;
2545
        }
2546

    
2547
        if (matroska->level_up) {
2548
            matroska->level_up--;
2549
            break;
2550
        }
2551
    }
2552

    
2553
    if (res)
2554
        return res;
2555

    
2556
    if (size > 0)
2557
        res = matroska_parse_block(matroska, data, size, pos, cluster_time,
2558
                                   duration, is_keyframe, is_bframe);
2559

    
2560
    return res;
2561
}
2562

    
2563
static int
2564
matroska_parse_cluster (MatroskaDemuxContext *matroska)
2565
{
2566
    int res = 0;
2567
    uint32_t id;
2568
    uint64_t cluster_time = 0;
2569
    uint8_t *data;
2570
    int64_t pos;
2571
    int size;
2572

    
2573
    av_log(matroska->ctx, AV_LOG_DEBUG,
2574
           "parsing cluster at %"PRId64"\n", url_ftell(&matroska->ctx->pb));
2575

    
2576
    while (res == 0) {
2577
        if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2578
            res = AVERROR_IO;
2579
            break;
2580
        } else if (matroska->level_up) {
2581
            matroska->level_up--;
2582
            break;
2583
        }
2584

    
2585
        switch (id) {
2586
            /* cluster timecode */
2587
            case MATROSKA_ID_CLUSTERTIMECODE: {
2588
                uint64_t num;
2589
                if ((res = ebml_read_uint(matroska, &id, &num)) < 0)
2590
                    break;
2591
                cluster_time = num;
2592
                break;
2593
            }
2594

    
2595
                /* a group of blocks inside a cluster */
2596
            case MATROSKA_ID_BLOCKGROUP:
2597
                if ((res = ebml_read_master(matroska, &id)) < 0)
2598
                    break;
2599
                res = matroska_parse_blockgroup(matroska, cluster_time);
2600
                break;
2601

    
2602
            case MATROSKA_ID_SIMPLEBLOCK:
2603
                pos = url_ftell(&matroska->ctx->pb);
2604
                res = ebml_read_binary(matroska, &id, &data, &size);
2605
                if (res == 0)
2606
                    res = matroska_parse_block(matroska, data, size, pos,
2607
                                               cluster_time, AV_NOPTS_VALUE,
2608
                                               -1, 0);
2609
                break;
2610

    
2611
            default:
2612
                av_log(matroska->ctx, AV_LOG_INFO,
2613
                       "Unknown entry 0x%x in cluster data\n", id);
2614
                /* fall-through */
2615

    
2616
            case EBML_ID_VOID:
2617
                res = ebml_read_skip(matroska);
2618
                break;
2619
        }
2620

    
2621
        if (matroska->level_up) {
2622
            matroska->level_up--;
2623
            break;
2624
        }
2625
    }
2626

    
2627
    return res;
2628
}
2629

    
2630
static int
2631
matroska_read_packet (AVFormatContext *s,
2632
                      AVPacket        *pkt)
2633
{
2634
    MatroskaDemuxContext *matroska = s->priv_data;
2635
    int res;
2636
    uint32_t id;
2637

    
2638
    /* Read stream until we have a packet queued. */
2639
    while (matroska_deliver_packet(matroska, pkt)) {
2640

    
2641
        /* Have we already reached the end? */
2642
        if (matroska->done)
2643
            return AVERROR_IO;
2644

    
2645
        res = 0;
2646
        while (res == 0) {
2647
            if (!(id = ebml_peek_id(matroska, &matroska->level_up))) {
2648
                return AVERROR_IO;
2649
            } else if (matroska->level_up) {
2650
                matroska->level_up--;
2651
                break;
2652
            }
2653

    
2654
            switch (id) {
2655
                case MATROSKA_ID_CLUSTER:
2656
                    if ((res = ebml_read_master(matroska, &id)) < 0)
2657
                        break;
2658
                    if ((res = matroska_parse_cluster(matroska)) == 0)
2659
                        res = 1; /* Parsed one cluster, let's get out. */
2660
                    break;
2661

    
2662
                default:
2663
                case EBML_ID_VOID:
2664
                    res = ebml_read_skip(matroska);
2665
                    break;
2666
            }
2667

    
2668
            if (matroska->level_up) {
2669
                matroska->level_up--;
2670
                break;
2671
            }
2672
        }
2673

    
2674
        if (res == -1)
2675
            matroska->done = 1;
2676
    }
2677

    
2678
    return 0;
2679
}
2680

    
2681
static int
2682
matroska_read_seek (AVFormatContext *s, int stream_index, int64_t timestamp,
2683
                    int flags)
2684
{
2685
    MatroskaDemuxContext *matroska = s->priv_data;
2686
    AVStream *st = s->streams[stream_index];
2687
    int index;
2688

    
2689
    /* find index entry */
2690
    index = av_index_search_timestamp(st, timestamp, flags);
2691
    if (index < 0)
2692
        return 0;
2693

    
2694
    /* do the seek */
2695
    url_fseek(&s->pb, st->index_entries[index].pos, SEEK_SET);
2696
    matroska->skip_to_keyframe = !(flags & AVSEEK_FLAG_ANY);
2697
    matroska->skip_to_stream = st;
2698
    matroska->num_packets = 0;
2699
    matroska->peek_id = 0;
2700
    return 0;
2701
}
2702

    
2703
static int
2704
matroska_read_close (AVFormatContext *s)
2705
{
2706
    MatroskaDemuxContext *matroska = s->priv_data;
2707
    int n = 0;
2708

    
2709
    av_free(matroska->writing_app);
2710
    av_free(matroska->muxing_app);
2711
    av_free(matroska->index);
2712

    
2713
    if (matroska->packets != NULL) {
2714
        for (n = 0; n < matroska->num_packets; n++) {
2715
            av_free_packet(matroska->packets[n]);
2716
            av_free(matroska->packets[n]);
2717
        }
2718
        av_free(matroska->packets);
2719
    }
2720

    
2721
    for (n = 0; n < matroska->num_tracks; n++) {
2722
        MatroskaTrack *track = matroska->tracks[n];
2723
        av_free(track->codec_id);
2724
        av_free(track->codec_name);
2725
        av_free(track->codec_priv);
2726
        av_free(track->name);
2727

    
2728
        if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2729
            MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
2730
            av_free(audiotrack->buf);
2731
        }
2732

    
2733
        av_free(track);
2734
    }
2735

    
2736
    return 0;
2737
}
2738

    
2739
AVInputFormat matroska_demuxer = {
2740
    "matroska",
2741
    "Matroska file format",
2742
    sizeof(MatroskaDemuxContext),
2743
    matroska_probe,
2744
    matroska_read_header,
2745
    matroska_read_packet,
2746
    matroska_read_close,
2747
    matroska_read_seek,
2748
};