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

/**
23
 * @file matroskadec.c
24 25 26
 * Matroska file demuxer
 * by Ronald Bultje <rbultje@ronald.bitfreak.net>
 * with a little help from Moritz Bunkus <moritz@bunkus.org>
27
 * totally reworked by Aurelien Jacobs <aurel@gnuage.org>
Diego Biurrun's avatar
Diego Biurrun committed
28
 * Specs available on the Matroska project page: http://www.matroska.org/.
29 30
 */

31
#include <stdio.h>
32 33 34
#include "avformat.h"
/* For codec_get_id(). */
#include "riff.h"
35
#include "isom.h"
36
#include "matroska.h"
37
#include "libavcodec/mpeg4audio.h"
38
#include "libavutil/intfloat_readwrite.h"
39
#include "libavutil/avstring.h"
40
#include "libavutil/lzo.h"
41 42 43
#ifdef CONFIG_ZLIB
#include <zlib.h>
#endif
44 45 46
#ifdef CONFIG_BZLIB
#include <bzlib.h>
#endif
47

48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
typedef enum {
    EBML_NONE,
    EBML_UINT,
    EBML_FLOAT,
    EBML_STR,
    EBML_UTF8,
    EBML_BIN,
    EBML_NEST,
    EBML_PASS,
    EBML_STOP,
} EbmlType;

typedef const struct EbmlSyntax {
    uint32_t id;
    EbmlType type;
    int list_elem_size;
    int data_offset;
    union {
        uint64_t    u;
        double      f;
        const char *s;
        const struct EbmlSyntax *n;
    } def;
} EbmlSyntax;

typedef struct {
    int nb_elem;
    void *elem;
} EbmlList;

typedef struct {
    int      size;
    uint8_t *data;
    int64_t  pos;
} EbmlBin;

84 85 86 87 88 89 90 91
typedef struct {
    uint64_t version;
    uint64_t max_size;
    uint64_t id_length;
    char    *doctype;
    uint64_t doctype_version;
} Ebml;

92 93 94 95
typedef struct {
    uint64_t algo;
    EbmlBin  settings;
} MatroskaTrackCompression;
96

97 98 99 100 101
typedef struct {
    uint64_t scope;
    uint64_t type;
    MatroskaTrackCompression compression;
} MatroskaTrackEncoding;
102

103 104 105 106 107 108 109 110
typedef struct {
    double   frame_rate;
    uint64_t display_width;
    uint64_t display_height;
    uint64_t pixel_width;
    uint64_t pixel_height;
    uint64_t fourcc;
} MatroskaTrackVideo;
111

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
typedef struct {
    double   samplerate;
    double   out_samplerate;
    uint64_t bitdepth;
    uint64_t channels;

    /* real audio header (extracted from extradata) */
    int      coded_framesize;
    int      sub_packet_h;
    int      frame_size;
    int      sub_packet_size;
    int      sub_packet_cnt;
    int      pkt_cnt;
    uint8_t *buf;
} MatroskaTrackAudio;
127

128 129 130 131 132 133
typedef struct {
    uint64_t num;
    uint64_t type;
    char    *codec_id;
    EbmlBin  codec_priv;
    char    *language;
134
    double time_scale;
135
    uint64_t default_duration;
136
    uint64_t flag_default;
137 138 139
    MatroskaTrackVideo video;
    MatroskaTrackAudio audio;
    EbmlList encodings;
140 141

    AVStream *stream;
142
    int64_t end_timecode;
143 144
} MatroskaTrack;

145 146 147 148 149 150
typedef struct {
    char *filename;
    char *mime;
    EbmlBin bin;
} MatroskaAttachement;

151 152 153 154 155 156 157
typedef struct {
    uint64_t start;
    uint64_t end;
    uint64_t uid;
    char    *title;
} MatroskaChapter;

158 159 160 161 162 163 164 165 166 167
typedef struct {
    uint64_t track;
    uint64_t pos;
} MatroskaIndexPos;

typedef struct {
    uint64_t time;
    EbmlList pos;
} MatroskaIndex;

168 169 170 171 172 173
typedef struct {
    char *name;
    char *string;
    EbmlList sub;
} MatroskaTag;

174 175 176 177 178
typedef struct {
    uint64_t id;
    uint64_t pos;
} MatroskaSeekhead;

179
typedef struct {
180 181
    uint64_t start;
    uint64_t length;
182 183
} MatroskaLevel;

184
typedef struct {
185 186
    AVFormatContext *ctx;

Diego Biurrun's avatar
Diego Biurrun committed
187
    /* EBML stuff */
188 189 190 191
    int num_levels;
    MatroskaLevel levels[EBML_MAX_DEPTH];
    int level_up;

192 193 194
    uint64_t time_scale;
    double   duration;
    char    *title;
195
    EbmlList tracks;
196
    EbmlList attachments;
197
    EbmlList chapters;
198
    EbmlList index;
199
    EbmlList tags;
200
    EbmlList seekhead;
201 202 203 204

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

Diego Biurrun's avatar
Diego Biurrun committed
205
    /* the packet queue */
206 207 208
    AVPacket **packets;
    int num_packets;

209
    int done;
210
    int has_cluster_id;
211 212 213

    /* What to skip before effectively reading a packet. */
    int skip_to_keyframe;
214
    uint64_t skip_to_timecode;
215 216
} MatroskaDemuxContext;

217 218 219 220 221 222 223 224 225 226 227
typedef struct {
    uint64_t duration;
    int64_t  reference;
    EbmlBin  bin;
} MatroskaBlock;

typedef struct {
    uint64_t timecode;
    EbmlList blocks;
} MatroskaCluster;

228 229
#define ARRAY_SIZE(x)  (sizeof(x)/sizeof(*x))

230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
static EbmlSyntax ebml_header[] = {
    { EBML_ID_EBMLREADVERSION,        EBML_UINT, 0, offsetof(Ebml,version), {.u=EBML_VERSION} },
    { EBML_ID_EBMLMAXSIZELENGTH,      EBML_UINT, 0, offsetof(Ebml,max_size), {.u=8} },
    { EBML_ID_EBMLMAXIDLENGTH,        EBML_UINT, 0, offsetof(Ebml,id_length), {.u=4} },
    { EBML_ID_DOCTYPE,                EBML_STR,  0, offsetof(Ebml,doctype), {.s="(none)"} },
    { EBML_ID_DOCTYPEREADVERSION,     EBML_UINT, 0, offsetof(Ebml,doctype_version), {.u=1} },
    { EBML_ID_EBMLVERSION,            EBML_NONE },
    { EBML_ID_DOCTYPEVERSION,         EBML_NONE },
    { 0 }
};

static EbmlSyntax ebml_syntax[] = {
    { EBML_ID_HEADER,                 EBML_NEST, 0, 0, {.n=ebml_header} },
    { 0 }
};

246 247 248 249 250 251 252 253 254 255 256
static EbmlSyntax matroska_info[] = {
    { MATROSKA_ID_TIMECODESCALE,      EBML_UINT,  0, offsetof(MatroskaDemuxContext,time_scale), {.u=1000000} },
    { MATROSKA_ID_DURATION,           EBML_FLOAT, 0, offsetof(MatroskaDemuxContext,duration) },
    { MATROSKA_ID_TITLE,              EBML_UTF8,  0, offsetof(MatroskaDemuxContext,title) },
    { MATROSKA_ID_WRITINGAPP,         EBML_NONE },
    { MATROSKA_ID_MUXINGAPP,          EBML_NONE },
    { MATROSKA_ID_DATEUTC,            EBML_NONE },
    { MATROSKA_ID_SEGMENTUID,         EBML_NONE },
    { 0 }
};

257 258 259 260 261 262 263
static EbmlSyntax matroska_track_video[] = {
    { MATROSKA_ID_VIDEOFRAMERATE,     EBML_FLOAT,0, offsetof(MatroskaTrackVideo,frame_rate) },
    { MATROSKA_ID_VIDEODISPLAYWIDTH,  EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_width) },
    { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_height) },
    { MATROSKA_ID_VIDEOPIXELWIDTH,    EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_width) },
    { MATROSKA_ID_VIDEOPIXELHEIGHT,   EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_height) },
    { MATROSKA_ID_VIDEOCOLORSPACE,    EBML_UINT, 0, offsetof(MatroskaTrackVideo,fourcc) },
264 265 266 267 268
    { MATROSKA_ID_VIDEOPIXELCROPB,    EBML_NONE },
    { MATROSKA_ID_VIDEOPIXELCROPT,    EBML_NONE },
    { MATROSKA_ID_VIDEOPIXELCROPL,    EBML_NONE },
    { MATROSKA_ID_VIDEOPIXELCROPR,    EBML_NONE },
    { MATROSKA_ID_VIDEODISPLAYUNIT,   EBML_NONE },
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
    { MATROSKA_ID_VIDEOFLAGINTERLACED,EBML_NONE },
    { MATROSKA_ID_VIDEOSTEREOMODE,    EBML_NONE },
    { MATROSKA_ID_VIDEOASPECTRATIO,   EBML_NONE },
    { 0 }
};

static EbmlSyntax matroska_track_audio[] = {
    { MATROSKA_ID_AUDIOSAMPLINGFREQ,  EBML_FLOAT,0, offsetof(MatroskaTrackAudio,samplerate), {.f=8000.0} },
    { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ,EBML_FLOAT,0,offsetof(MatroskaTrackAudio,out_samplerate) },
    { MATROSKA_ID_AUDIOBITDEPTH,      EBML_UINT, 0, offsetof(MatroskaTrackAudio,bitdepth) },
    { MATROSKA_ID_AUDIOCHANNELS,      EBML_UINT, 0, offsetof(MatroskaTrackAudio,channels), {.u=1} },
    { 0 }
};

static EbmlSyntax matroska_track_encoding_compression[] = {
    { MATROSKA_ID_ENCODINGCOMPALGO,   EBML_UINT, 0, offsetof(MatroskaTrackCompression,algo), {.u=0} },
    { MATROSKA_ID_ENCODINGCOMPSETTINGS,EBML_BIN, 0, offsetof(MatroskaTrackCompression,settings) },
    { 0 }
};

static EbmlSyntax matroska_track_encoding[] = {
    { MATROSKA_ID_ENCODINGSCOPE,      EBML_UINT, 0, offsetof(MatroskaTrackEncoding,scope), {.u=1} },
    { MATROSKA_ID_ENCODINGTYPE,       EBML_UINT, 0, offsetof(MatroskaTrackEncoding,type), {.u=0} },
    { MATROSKA_ID_ENCODINGCOMPRESSION,EBML_NEST, 0, offsetof(MatroskaTrackEncoding,compression), {.n=matroska_track_encoding_compression} },
293
    { MATROSKA_ID_ENCODINGORDER,      EBML_NONE },
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
    { 0 }
};

static EbmlSyntax matroska_track_encodings[] = {
    { MATROSKA_ID_TRACKCONTENTENCODING, EBML_NEST, sizeof(MatroskaTrackEncoding), offsetof(MatroskaTrack,encodings), {.n=matroska_track_encoding} },
    { 0 }
};

static EbmlSyntax matroska_track[] = {
    { MATROSKA_ID_TRACKNUMBER,          EBML_UINT, 0, offsetof(MatroskaTrack,num) },
    { MATROSKA_ID_TRACKTYPE,            EBML_UINT, 0, offsetof(MatroskaTrack,type) },
    { MATROSKA_ID_CODECID,              EBML_STR,  0, offsetof(MatroskaTrack,codec_id) },
    { MATROSKA_ID_CODECPRIVATE,         EBML_BIN,  0, offsetof(MatroskaTrack,codec_priv) },
    { MATROSKA_ID_TRACKLANGUAGE,        EBML_UTF8, 0, offsetof(MatroskaTrack,language), {.s="eng"} },
    { MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, offsetof(MatroskaTrack,default_duration) },
    { MATROSKA_ID_TRACKTIMECODESCALE,   EBML_FLOAT,0, offsetof(MatroskaTrack,time_scale), {.f=1.0} },
    { MATROSKA_ID_TRACKFLAGDEFAULT,     EBML_UINT, 0, offsetof(MatroskaTrack,flag_default), {.u=1} },
    { MATROSKA_ID_TRACKVIDEO,           EBML_NEST, 0, offsetof(MatroskaTrack,video), {.n=matroska_track_video} },
    { MATROSKA_ID_TRACKAUDIO,           EBML_NEST, 0, offsetof(MatroskaTrack,audio), {.n=matroska_track_audio} },
    { MATROSKA_ID_TRACKCONTENTENCODINGS,EBML_NEST, 0, 0, {.n=matroska_track_encodings} },
    { MATROSKA_ID_TRACKUID,             EBML_NONE },
    { MATROSKA_ID_TRACKNAME,            EBML_NONE },
    { MATROSKA_ID_TRACKFLAGENABLED,     EBML_NONE },
    { MATROSKA_ID_TRACKFLAGFORCED,      EBML_NONE },
    { MATROSKA_ID_TRACKFLAGLACING,      EBML_NONE },
    { MATROSKA_ID_CODECNAME,            EBML_NONE },
    { MATROSKA_ID_CODECDECODEALL,       EBML_NONE },
    { MATROSKA_ID_CODECINFOURL,         EBML_NONE },
    { MATROSKA_ID_CODECDOWNLOADURL,     EBML_NONE },
    { MATROSKA_ID_TRACKMINCACHE,        EBML_NONE },
    { MATROSKA_ID_TRACKMAXCACHE,        EBML_NONE },
325
    { MATROSKA_ID_TRACKMAXBLKADDID,     EBML_NONE },
326 327 328 329 330 331 332 333
    { 0 }
};

static EbmlSyntax matroska_tracks[] = {
    { MATROSKA_ID_TRACKENTRY,         EBML_NEST, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext,tracks), {.n=matroska_track} },
    { 0 }
};

334 335 336 337
static EbmlSyntax matroska_attachment[] = {
    { MATROSKA_ID_FILENAME,           EBML_UTF8, 0, offsetof(MatroskaAttachement,filename) },
    { MATROSKA_ID_FILEMIMETYPE,       EBML_STR,  0, offsetof(MatroskaAttachement,mime) },
    { MATROSKA_ID_FILEDATA,           EBML_BIN,  0, offsetof(MatroskaAttachement,bin) },
338
    { MATROSKA_ID_FILEDESC,           EBML_NONE },
339 340 341 342 343 344 345 346 347
    { MATROSKA_ID_FILEUID,            EBML_NONE },
    { 0 }
};

static EbmlSyntax matroska_attachments[] = {
    { MATROSKA_ID_ATTACHEDFILE,       EBML_NEST, sizeof(MatroskaAttachement), offsetof(MatroskaDemuxContext,attachments), {.n=matroska_attachment} },
    { 0 }
};

348 349
static EbmlSyntax matroska_chapter_display[] = {
    { MATROSKA_ID_CHAPSTRING,         EBML_UTF8, 0, offsetof(MatroskaChapter,title) },
350
    { MATROSKA_ID_CHAPLANG,           EBML_NONE },
351 352 353 354 355 356 357 358 359
    { 0 }
};

static EbmlSyntax matroska_chapter_entry[] = {
    { MATROSKA_ID_CHAPTERTIMESTART,   EBML_UINT, 0, offsetof(MatroskaChapter,start), {.u=AV_NOPTS_VALUE} },
    { MATROSKA_ID_CHAPTERTIMEEND,     EBML_UINT, 0, offsetof(MatroskaChapter,end), {.u=AV_NOPTS_VALUE} },
    { MATROSKA_ID_CHAPTERUID,         EBML_UINT, 0, offsetof(MatroskaChapter,uid) },
    { MATROSKA_ID_CHAPTERDISPLAY,     EBML_NEST, 0, 0, {.n=matroska_chapter_display} },
    { MATROSKA_ID_CHAPTERFLAGHIDDEN,  EBML_NONE },
360 361 362
    { MATROSKA_ID_CHAPTERFLAGENABLED, EBML_NONE },
    { MATROSKA_ID_CHAPTERPHYSEQUIV,   EBML_NONE },
    { MATROSKA_ID_CHAPTERATOM,        EBML_NONE },
363 364 365 366 367 368 369 370
    { 0 }
};

static EbmlSyntax matroska_chapter[] = {
    { MATROSKA_ID_CHAPTERATOM,        EBML_NEST, sizeof(MatroskaChapter), offsetof(MatroskaDemuxContext,chapters), {.n=matroska_chapter_entry} },
    { MATROSKA_ID_EDITIONUID,         EBML_NONE },
    { MATROSKA_ID_EDITIONFLAGHIDDEN,  EBML_NONE },
    { MATROSKA_ID_EDITIONFLAGDEFAULT, EBML_NONE },
371
    { MATROSKA_ID_EDITIONFLAGORDERED, EBML_NONE },
372 373 374 375 376 377 378 379
    { 0 }
};

static EbmlSyntax matroska_chapters[] = {
    { MATROSKA_ID_EDITIONENTRY,       EBML_NEST, 0, 0, {.n=matroska_chapter} },
    { 0 }
};

380 381 382
static EbmlSyntax matroska_index_pos[] = {
    { MATROSKA_ID_CUETRACK,           EBML_UINT, 0, offsetof(MatroskaIndexPos,track) },
    { MATROSKA_ID_CUECLUSTERPOSITION, EBML_UINT, 0, offsetof(MatroskaIndexPos,pos)   },
383
    { MATROSKA_ID_CUEBLOCKNUMBER,     EBML_NONE },
384 385 386 387 388 389 390 391 392 393 394 395 396 397
    { 0 }
};

static EbmlSyntax matroska_index_entry[] = {
    { MATROSKA_ID_CUETIME,            EBML_UINT, 0, offsetof(MatroskaIndex,time) },
    { MATROSKA_ID_CUETRACKPOSITION,   EBML_NEST, sizeof(MatroskaIndexPos), offsetof(MatroskaIndex,pos), {.n=matroska_index_pos} },
    { 0 }
};

static EbmlSyntax matroska_index[] = {
    { MATROSKA_ID_POINTENTRY,         EBML_NEST, sizeof(MatroskaIndex), offsetof(MatroskaDemuxContext,index), {.n=matroska_index_entry} },
    { 0 }
};

398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
static EbmlSyntax matroska_simpletag[] = {
    { MATROSKA_ID_TAGNAME,            EBML_UTF8, 0, offsetof(MatroskaTag,name) },
    { MATROSKA_ID_TAGSTRING,          EBML_UTF8, 0, offsetof(MatroskaTag,string) },
    { MATROSKA_ID_SIMPLETAG,          EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTag,sub), {.n=matroska_simpletag} },
    { MATROSKA_ID_TAGLANG,            EBML_NONE },
    { MATROSKA_ID_TAGDEFAULT,         EBML_NONE },
    { 0 }
};

static EbmlSyntax matroska_tag[] = {
    { MATROSKA_ID_SIMPLETAG,          EBML_NEST, sizeof(MatroskaTag), 0, {.n=matroska_simpletag} },
    { MATROSKA_ID_TAGTARGETS,         EBML_NONE },
    { 0 }
};

413
static EbmlSyntax matroska_tags[] = {
414
    { MATROSKA_ID_TAG,                EBML_NEST, 0, offsetof(MatroskaDemuxContext,tags), {.n=matroska_tag} },
415 416 417
    { 0 }
};

418 419 420 421 422 423 424 425 426 427 428
static EbmlSyntax matroska_seekhead_entry[] = {
    { MATROSKA_ID_SEEKID,             EBML_UINT, 0, offsetof(MatroskaSeekhead,id) },
    { MATROSKA_ID_SEEKPOSITION,       EBML_UINT, 0, offsetof(MatroskaSeekhead,pos), {.u=-1} },
    { 0 }
};

static EbmlSyntax matroska_seekhead[] = {
    { MATROSKA_ID_SEEKENTRY,          EBML_NEST, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext,seekhead), {.n=matroska_seekhead_entry} },
    { 0 }
};

429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
static EbmlSyntax matroska_segment[] = {
    { MATROSKA_ID_INFO,           EBML_NEST, 0, 0, {.n=matroska_info       } },
    { MATROSKA_ID_TRACKS,         EBML_NEST, 0, 0, {.n=matroska_tracks     } },
    { MATROSKA_ID_ATTACHMENTS,    EBML_NEST, 0, 0, {.n=matroska_attachments} },
    { MATROSKA_ID_CHAPTERS,       EBML_NEST, 0, 0, {.n=matroska_chapters   } },
    { MATROSKA_ID_CUES,           EBML_NEST, 0, 0, {.n=matroska_index      } },
    { MATROSKA_ID_TAGS,           EBML_NEST, 0, 0, {.n=matroska_tags       } },
    { MATROSKA_ID_SEEKHEAD,       EBML_NEST, 0, 0, {.n=matroska_seekhead   } },
    { MATROSKA_ID_CLUSTER,        EBML_STOP, 0, offsetof(MatroskaDemuxContext,has_cluster_id) },
    { 0 }
};

static EbmlSyntax matroska_segments[] = {
    { MATROSKA_ID_SEGMENT,        EBML_NEST, 0, 0, {.n=matroska_segment    } },
    { 0 }
};

446 447 448 449 450 451 452 453 454 455 456 457
static EbmlSyntax matroska_blockgroup[] = {
    { MATROSKA_ID_BLOCK,          EBML_BIN,  0, offsetof(MatroskaBlock,bin) },
    { MATROSKA_ID_SIMPLEBLOCK,    EBML_BIN,  0, offsetof(MatroskaBlock,bin) },
    { MATROSKA_ID_BLOCKDURATION,  EBML_UINT, 0, offsetof(MatroskaBlock,duration), {.u=AV_NOPTS_VALUE} },
    { MATROSKA_ID_BLOCKREFERENCE, EBML_UINT, 0, offsetof(MatroskaBlock,reference) },
    { 0 }
};

static EbmlSyntax matroska_cluster[] = {
    { MATROSKA_ID_CLUSTERTIMECODE,EBML_UINT,0, offsetof(MatroskaCluster,timecode) },
    { MATROSKA_ID_BLOCKGROUP,     EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
    { MATROSKA_ID_SIMPLEBLOCK,    EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
458 459
    { MATROSKA_ID_CLUSTERPOSITION,EBML_NONE },
    { MATROSKA_ID_CLUSTERPREVSIZE,EBML_NONE },
460 461 462 463 464
    { 0 }
};

static EbmlSyntax matroska_clusters[] = {
    { MATROSKA_ID_CLUSTER,        EBML_NEST, 0, 0, {.n=matroska_cluster} },
465 466 467 468
    { MATROSKA_ID_INFO,           EBML_NONE },
    { MATROSKA_ID_CUES,           EBML_NONE },
    { MATROSKA_ID_TAGS,           EBML_NONE },
    { MATROSKA_ID_SEEKHEAD,       EBML_NONE },
469 470 471
    { 0 }
};

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
#define SIZE_OFF(x) sizeof(((AVFormatContext*)0)->x),offsetof(AVFormatContext,x)
const struct {
    const char name[16];
    int   size;
    int   offset;
} metadata[] = {
    { "TITLE",           SIZE_OFF(title)      },
    { "ARTIST",          SIZE_OFF(author)     },
    { "WRITTEN_BY",      SIZE_OFF(author)     },
    { "LEAD_PERFORMER",  SIZE_OFF(author)     },
    { "COPYRIGHT",       SIZE_OFF(copyright)  },
    { "COMMENT",         SIZE_OFF(comment)    },
    { "ALBUM",           SIZE_OFF(album)      },
    { "DATE_WRITTEN",    SIZE_OFF(year)       },
    { "DATE_RELEASED",   SIZE_OFF(year)       },
    { "PART_NUMBER",     SIZE_OFF(track)      },
    { "GENRE",           SIZE_OFF(genre)      },
};

491
/*
Diego Biurrun's avatar
Diego Biurrun committed
492
 * Return: Whether we reached the end of a level in the hierarchy or not.
493
 */
494
static int ebml_level_end(MatroskaDemuxContext *matroska)
495
{
496
    ByteIOContext *pb = matroska->ctx->pb;
497 498
    offset_t pos = url_ftell(pb);

499
    if (matroska->num_levels > 0) {
500
        MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
501
        if (pos - level->start >= level->length) {
502
            matroska->num_levels--;
503
            return 1;
504 505
        }
    }
506
    return 0;
507 508 509 510 511 512 513 514
}

/*
 * Read: an "EBML number", which is defined as a variable-length
 * array of bytes. The first byte indicates the length by giving a
 * number of 0-bits followed by a one. The position of the first
 * "one" bit inside the first byte indicates the length of this
 * number.
Diego Biurrun's avatar
Diego Biurrun committed
515
 * Returns: number of bytes read, < 0 on error
516
 */
517
static int ebml_read_num(MatroskaDemuxContext *matroska, ByteIOContext *pb,
518
                         int max_size, uint64_t *number)
519 520 521 522
{
    int len_mask = 0x80, read = 1, n = 1;
    int64_t total = 0;

Diego Biurrun's avatar
Diego Biurrun committed
523
    /* The first byte tells us the length in bytes - get_byte() can normally
524 525 526 527 528 529 530 531 532 533
     * return 0, but since that's not a valid first ebmlID byte, we can
     * use it safely here to catch EOS. */
    if (!(total = get_byte(pb))) {
        /* we might encounter EOS here */
        if (!url_feof(pb)) {
            offset_t pos = url_ftell(pb);
            av_log(matroska->ctx, AV_LOG_ERROR,
                   "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
                   pos, pos);
        }
534
        return AVERROR(EIO); /* EOS or actual I/O error */
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
    }

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

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

    *number = total;

    return read;
}

/*
 * Read the next element as an unsigned int.
 * 0 is success, < 0 is failure.
 */
564
static int ebml_read_uint(ByteIOContext *pb, int size, uint64_t *num)
565
{
566
    int n = 0;
567

568
    if (size < 1 || size > 8)
569 570
        return AVERROR_INVALIDDATA;

Diego Biurrun's avatar
Diego Biurrun committed
571
    /* big-endian ordering; build up number */
572 573 574 575 576 577 578 579 580 581 582
    *num = 0;
    while (n++ < size)
        *num = (*num << 8) | get_byte(pb);

    return 0;
}

/*
 * Read the next element as a float.
 * 0 is success, < 0 is failure.
 */
583
static int ebml_read_float(ByteIOContext *pb, int size, double *num)
584 585 586 587 588
{
    if (size == 4) {
        *num= av_int2flt(get_be32(pb));
    } else if(size==8){
        *num= av_int2dbl(get_be64(pb));
589
    } else
590 591 592 593 594 595 596 597 598
        return AVERROR_INVALIDDATA;

    return 0;
}

/*
 * Read the next element as an ASCII string.
 * 0 is success, < 0 is failure.
 */
599
static int ebml_read_ascii(ByteIOContext *pb, int size, char **str)
600
{
601
    av_free(*str);
Diego Biurrun's avatar
Diego Biurrun committed
602
    /* EBML strings are usually not 0-terminated, so we allocate one
603
     * byte more, read the string and NULL-terminate it ourselves. */
604
    if (!(*str = av_malloc(size + 1)))
605
        return AVERROR(ENOMEM);
606
    if (get_buffer(pb, (uint8_t *) *str, size) != size) {
607
        av_free(*str);
608
        return AVERROR(EIO);
609 610 611 612 613 614
    }
    (*str)[size] = '\0';

    return 0;
}

615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
/*
 * Read the next element as binary data.
 * 0 is success, < 0 is failure.
 */
static int ebml_read_binary(ByteIOContext *pb, int length, EbmlBin *bin)
{
    av_free(bin->data);
    if (!(bin->data = av_malloc(length)))
        return AVERROR(ENOMEM);

    bin->size = length;
    bin->pos  = url_ftell(pb);
    if (get_buffer(pb, bin->data, length) != length)
        return AVERROR(EIO);

    return 0;
}

633 634 635 636 637
/*
 * Read the next element, but only the header. The contents
 * are supposed to be sub-elements which can be read separately.
 * 0 is success, < 0 is failure.
 */
638
static int ebml_read_master(MatroskaDemuxContext *matroska, int length)
639
{
640
    ByteIOContext *pb = matroska->ctx->pb;
641 642 643 644 645
    MatroskaLevel *level;

    if (matroska->num_levels >= EBML_MAX_DEPTH) {
        av_log(matroska->ctx, AV_LOG_ERROR,
               "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
646
        return AVERROR(ENOSYS);
647 648 649 650 651 652 653 654 655 656 657
    }

    level = &matroska->levels[matroska->num_levels++];
    level->start = url_ftell(pb);
    level->length = length;

    return 0;
}

/*
 * Read signed/unsigned "EBML" numbers.
Diego Biurrun's avatar
Diego Biurrun committed
658
 * Return: number of bytes processed, < 0 on error
659
 */
660 661
static int matroska_ebmlnum_uint(MatroskaDemuxContext *matroska,
                                 uint8_t *data, uint32_t size, uint64_t *num)
662
{
663 664 665
    ByteIOContext pb;
    init_put_byte(&pb, data, size, 0, NULL, NULL, NULL, NULL);
    return ebml_read_num(matroska, &pb, 8, num);
666 667 668 669 670
}

/*
 * Same as above, but signed.
 */
671 672
static int matroska_ebmlnum_sint(MatroskaDemuxContext *matroska,
                                 uint8_t *data, uint32_t size, int64_t *num)
673 674 675 676 677
{
    uint64_t unum;
    int res;

    /* read as unsigned number first */
678
    if ((res = matroska_ebmlnum_uint(matroska, data, size, &unum)) < 0)
679 680 681
        return res;

    /* make signed (weird way) */
682
    *num = unum - ((1LL << (7*res - 1)) - 1);
683 684 685 686

    return res;
}

687 688
static int ebml_parse_elem(MatroskaDemuxContext *matroska,
                           EbmlSyntax *syntax, void *data);
689

690 691
static int ebml_parse_id(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
                         uint32_t id, void *data)
692 693
{
    int i;
694 695 696
    for (i=0; syntax[i].id; i++)
        if (id == syntax[i].id)
            break;
697
    if (!syntax[i].id && id != EBML_ID_VOID && id != EBML_ID_CRC32)
698 699
        av_log(matroska->ctx, AV_LOG_INFO, "Unknown entry 0x%X\n", id);
    return ebml_parse_elem(matroska, &syntax[i], data);
700 701
}

702 703
static int ebml_parse(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
                      void *data)
704
{
705 706 707
    uint64_t id;
    int res = ebml_read_num(matroska, matroska->ctx->pb, 4, &id);
    id |= 1 << 7*res;
708
    return res < 0 ? res : ebml_parse_id(matroska, syntax, id, data);
709 710
}

711 712
static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
                           void *data)
713
{
714
    int i, res = 0;
715

716 717 718 719 720 721 722 723 724 725 726 727
    for (i=0; syntax[i].id; i++)
        switch (syntax[i].type) {
        case EBML_UINT:
            *(uint64_t *)((char *)data+syntax[i].data_offset) = syntax[i].def.u;
            break;
        case EBML_FLOAT:
            *(double   *)((char *)data+syntax[i].data_offset) = syntax[i].def.f;
            break;
        case EBML_STR:
        case EBML_UTF8:
            *(char    **)((char *)data+syntax[i].data_offset) = av_strdup(syntax[i].def.s);
            break;
728
        }
729

730 731
    while (!res && !ebml_level_end(matroska))
        res = ebml_parse(matroska, syntax, data);
732

733
    return res;
734 735
}

736 737 738
static int ebml_parse_elem(MatroskaDemuxContext *matroska,
                           EbmlSyntax *syntax, void *data)
{
739
    ByteIOContext *pb = matroska->ctx->pb;
740
    uint32_t id = syntax->id;
741
    uint64_t length;
742 743 744 745 746 747 748 749 750 751 752
    int res;

    data = (char *)data + syntax->data_offset;
    if (syntax->list_elem_size) {
        EbmlList *list = data;
        list->elem = av_realloc(list->elem, (list->nb_elem+1)*syntax->list_elem_size);
        data = (char*)list->elem + list->nb_elem*syntax->list_elem_size;
        memset(data, 0, syntax->list_elem_size);
        list->nb_elem++;
    }

753
    if (syntax->type != EBML_PASS && syntax->type != EBML_STOP)
754
        if ((res = ebml_read_num(matroska, pb, 8, &length)) < 0)
755 756
            return res;

757
    switch (syntax->type) {
758 759
    case EBML_UINT:  res = ebml_read_uint  (pb, length, data);  break;
    case EBML_FLOAT: res = ebml_read_float (pb, length, data);  break;
760
    case EBML_STR:
761
    case EBML_UTF8:  res = ebml_read_ascii (pb, length, data);  break;
762
    case EBML_BIN:   res = ebml_read_binary(pb, length, data);  break;
763
    case EBML_NEST:  if ((res=ebml_read_master(matroska, length)) < 0)
764 765 766
                         return res;
                     if (id == MATROSKA_ID_SEGMENT)
                         matroska->segment_start = url_ftell(matroska->ctx->pb);
767
                     return ebml_parse_nest(matroska, syntax->def.n, data);
768
    case EBML_PASS:  return ebml_parse_id(matroska, syntax->def.n, id, data);
769
    case EBML_STOP:  *(int *)data = 1;      return 1;
770
    default:         return url_fseek(pb,length,SEEK_CUR)<0 ? AVERROR(EIO) : 0;
771
    }
772 773 774 775 776
    if (res == AVERROR_INVALIDDATA)
        av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
    else if (res == AVERROR(EIO))
        av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
    return res;
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
}

static void ebml_free(EbmlSyntax *syntax, void *data)
{
    int i, j;
    for (i=0; syntax[i].id; i++) {
        void *data_off = (char *)data + syntax[i].data_offset;
        switch (syntax[i].type) {
        case EBML_STR:
        case EBML_UTF8:  av_freep(data_off);                      break;
        case EBML_BIN:   av_freep(&((EbmlBin *)data_off)->data);  break;
        case EBML_NEST:
            if (syntax[i].list_elem_size) {
                EbmlList *list = data_off;
                char *ptr = list->elem;
                for (j=0; j<list->nb_elem; j++, ptr+=syntax[i].list_elem_size)
                    ebml_free(syntax[i].def.n, ptr);
                av_free(list->elem);
            } else
                ebml_free(syntax[i].def.n, data_off);
        default:  break;
        }
    }
}

802 803 804 805 806 807 808 809

/*
 * Autodetecting...
 */
static int matroska_probe(AVProbeData *p)
{
    uint64_t total = 0;
    int len_mask = 0x80, size = 1, n = 1;
810
    static const char probe_data[] = "matroska";
811

Diego Biurrun's avatar
Diego Biurrun committed
812
    /* EBML header? */
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
    if (AV_RB32(p->buf) != EBML_ID_HEADER)
        return 0;

    /* length of header */
    total = p->buf[4];
    while (size <= 8 && !(total & len_mask)) {
        size++;
        len_mask >>= 1;
    }
    if (size > 8)
      return 0;
    total &= (len_mask - 1);
    while (n < size)
        total = (total << 8) | p->buf[4 + n++];

Diego Biurrun's avatar
Diego Biurrun committed
828
    /* Does the probe data contain the whole header? */
829 830 831
    if (p->buf_size < 4 + size + total)
      return 0;

Diego Biurrun's avatar
Diego Biurrun committed
832
    /* The header must contain the document type 'matroska'. For now,
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
     * we don't parse the whole header but simply check for the
     * availability of that array of characters inside the header.
     * Not fully fool-proof, but good enough. */
    for (n = 4+size; n <= 4+size+total-(sizeof(probe_data)-1); n++)
        if (!memcmp(p->buf+n, probe_data, sizeof(probe_data)-1))
            return AVPROBE_SCORE_MAX;

    return 0;
}

static MatroskaTrack *matroska_find_track_by_num(MatroskaDemuxContext *matroska,
                                                 int num)
{
    MatroskaTrack *tracks = matroska->tracks.elem;
    int i;

    for (i=0; i < matroska->tracks.nb_elem; i++)
        if (tracks[i].num == num)
            return &tracks[i];

    av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %d\n", num);
    return NULL;
}

857 858
static int matroska_decode_buffer(uint8_t** buf, int* buf_size,
                                  MatroskaTrack *track)
859
{
860
    MatroskaTrackEncoding *encodings = track->encodings.elem;
861 862 863 864 865 866 867
    uint8_t* data = *buf;
    int isize = *buf_size;
    uint8_t* pkt_data = NULL;
    int pkt_size = isize;
    int result = 0;
    int olen;

868
    switch (encodings[0].compression.algo) {
869
    case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP:
870
        return encodings[0].compression.settings.size;
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
    case MATROSKA_TRACK_ENCODING_COMP_LZO:
        do {
            olen = pkt_size *= 3;
            pkt_data = av_realloc(pkt_data,
                                  pkt_size+LZO_OUTPUT_PADDING);
            result = lzo1x_decode(pkt_data, &olen, data, &isize);
        } while (result==LZO_OUTPUT_FULL && pkt_size<10000000);
        if (result)
            goto failed;
        pkt_size -= olen;
        break;
#ifdef CONFIG_ZLIB
    case MATROSKA_TRACK_ENCODING_COMP_ZLIB: {
        z_stream zstream = {0};
        if (inflateInit(&zstream) != Z_OK)
            return -1;
        zstream.next_in = data;
        zstream.avail_in = isize;
        do {
            pkt_size *= 3;
            pkt_data = av_realloc(pkt_data, pkt_size);
            zstream.avail_out = pkt_size - zstream.total_out;
            zstream.next_out = pkt_data + zstream.total_out;
            result = inflate(&zstream, Z_NO_FLUSH);
        } while (result==Z_OK && pkt_size<10000000);
        pkt_size = zstream.total_out;
        inflateEnd(&zstream);
        if (result != Z_STREAM_END)
            goto failed;
        break;
    }
#endif
#ifdef CONFIG_BZLIB
    case MATROSKA_TRACK_ENCODING_COMP_BZLIB: {
        bz_stream bzstream = {0};
        if (BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
            return -1;
        bzstream.next_in = data;
        bzstream.avail_in = isize;
        do {
            pkt_size *= 3;
            pkt_data = av_realloc(pkt_data, pkt_size);
            bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
            bzstream.next_out = pkt_data + bzstream.total_out_lo32;
            result = BZ2_bzDecompress(&bzstream);
        } while (result==BZ_OK && pkt_size<10000000);
        pkt_size = bzstream.total_out_lo32;
        BZ2_bzDecompressEnd(&bzstream);
        if (result != BZ_STREAM_END)
            goto failed;
        break;
    }
#endif
924 925
    default:
        return -1;
926 927 928 929 930 931 932 933 934 935
    }

    *buf = pkt_data;
    *buf_size = pkt_size;
    return 0;
 failed:
    av_free(pkt_data);
    return -1;
}

936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
static void matroska_fix_ass_packet(MatroskaDemuxContext *matroska,
                                    AVPacket *pkt)
{
    char *line, *layer, *ptr = pkt->data, *end = ptr+pkt->size;
    for (; *ptr!=',' && ptr<end-1; ptr++);
    if (*ptr == ',')
        layer = ++ptr;
    for (; *ptr!=',' && ptr<end-1; ptr++);
    if (*ptr == ',') {
        int64_t end_pts = pkt->pts + pkt->convergence_duration;
        int sc = matroska->time_scale * pkt->pts / 10000000;
        int ec = matroska->time_scale * end_pts  / 10000000;
        int sh, sm, ss, eh, em, es, len;
        sh = sc/360000;  sc -= 360000*sh;
        sm = sc/  6000;  sc -=   6000*sm;
        ss = sc/   100;  sc -=    100*ss;
        eh = ec/360000;  ec -= 360000*eh;
        em = ec/  6000;  ec -=   6000*em;
        es = ec/   100;  ec -=    100*es;
        *ptr++ = '\0';
        len = 50 + end-ptr + FF_INPUT_BUFFER_PADDING_SIZE;
        if (!(line = av_malloc(len)))
            return;
        snprintf(line,len,"Dialogue: %s,%d:%02d:%02d.%02d,%d:%02d:%02d.%02d,%s",
                 layer, sh, sm, ss, sc, eh, em, es, ec, ptr);
        av_free(pkt->data);
        pkt->data = line;
        pkt->size = strlen(line);
    }
}

967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
static void matroska_convert_tags(AVFormatContext *s, EbmlList *list)
{
    MatroskaTag *tags = list->elem;
    int i, j;

    for (i=0; i < list->nb_elem; i++) {
        for (j=0; j < ARRAY_SIZE(metadata); j++){
            if (!strcmp(tags[i].name, metadata[j].name)) {
                int *ptr = (int *)((char *)s + metadata[j].offset);
                if (*ptr)  continue;
                if (metadata[j].size > sizeof(int))
                    av_strlcpy((char *)ptr, tags[i].string, metadata[j].size);
                else
                    *ptr = atoi(tags[i].string);
            }
        }
        if (tags[i].sub.nb_elem)
            matroska_convert_tags(s, &tags[i].sub);
    }
}

988
static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
989 990 991 992 993 994
{
    EbmlList *seekhead_list = &matroska->seekhead;
    MatroskaSeekhead *seekhead = seekhead_list->elem;
    uint32_t level_up = matroska->level_up;
    offset_t before_pos = url_ftell(matroska->ctx->pb);
    MatroskaLevel level;
995
    int i;
996

997
    for (i=0; i<seekhead_list->nb_elem; i++) {
998 999
        offset_t offset = seekhead[i].pos + matroska->segment_start;

1000 1001 1002 1003
        if (seekhead[i].pos <= before_pos
            || seekhead[i].id == MATROSKA_ID_SEEKHEAD
            || seekhead[i].id == MATROSKA_ID_CLUSTER)
            continue;
1004

1005
        /* seek */
1006
        if (url_fseek(matroska->ctx->pb, offset, SEEK_SET) != offset)
1007 1008
            continue;

Diego Biurrun's avatar
Diego Biurrun committed
1009
        /* We don't want to lose our seekhead level, so we add
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
         * a dummy. This is a crude hack. */
        if (matroska->num_levels == EBML_MAX_DEPTH) {
            av_log(matroska->ctx, AV_LOG_INFO,
                   "Max EBML element depth (%d) reached, "
                   "cannot parse further.\n", EBML_MAX_DEPTH);
            break;
        }

        level.start = 0;
        level.length = (uint64_t)-1;
        matroska->levels[matroska->num_levels] = level;
        matroska->num_levels++;

1023
        ebml_parse(matroska, matroska_segment, matroska);
1024 1025 1026 1027 1028 1029 1030

        /* remove dummy level */
        while (matroska->num_levels) {
            uint64_t length = matroska->levels[--matroska->num_levels].length;
            if (length == (uint64_t)-1)
                break;
        }
1031
    }
1032

1033
    /* seek back */
1034
    url_fseek(matroska->ctx->pb, before_pos, SEEK_SET);
1035
    matroska->level_up = level_up;
1036 1037
}

1038
static int matroska_aac_profile(char *codec_id)
1039
{
1040
    static const char * const aac_profiles[] = { "MAIN", "LC", "SSR" };
1041 1042 1043 1044 1045 1046 1047 1048
    int profile;

    for (profile=0; profile<ARRAY_SIZE(aac_profiles); profile++)
        if (strstr(codec_id, aac_profiles[profile]))
            break;
    return profile + 1;
}

1049
static int matroska_aac_sri(int samplerate)
1050 1051 1052
{
    int sri;

1053 1054
    for (sri=0; sri<ARRAY_SIZE(ff_mpeg4audio_sample_rates); sri++)
        if (ff_mpeg4audio_sample_rates[sri] == samplerate)
1055 1056 1057 1058
            break;
    return sri;
}

1059
static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
1060 1061
{
    MatroskaDemuxContext *matroska = s->priv_data;
1062 1063 1064 1065
    EbmlList *attachements_list = &matroska->attachments;
    MatroskaAttachement *attachements;
    EbmlList *chapters_list = &matroska->chapters;
    MatroskaChapter *chapters;
1066
    MatroskaTrack *tracks;
1067 1068
    EbmlList *index_list;
    MatroskaIndex *index;
1069
    Ebml ebml = { 0 };
1070
    AVStream *st;
1071
    int i, j;
1072 1073 1074 1075

    matroska->ctx = s;

    /* First read the EBML header. */
1076
    if (ebml_parse(matroska, ebml_syntax, &ebml)
1077 1078 1079
        || ebml.version > EBML_VERSION       || ebml.max_size > sizeof(uint64_t)
        || ebml.id_length > sizeof(uint32_t) || strcmp(ebml.doctype, "matroska")
        || ebml.doctype_version > 2) {
1080
        av_log(matroska->ctx, AV_LOG_ERROR,
1081 1082 1083
               "EBML header using unsupported features\n"
               "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
               ebml.version, ebml.doctype, ebml.doctype_version);
1084 1085
        return AVERROR_NOFMT;
    }
1086
    ebml_free(ebml_syntax, &ebml);
1087 1088

    /* The next thing is a segment. */
1089
    if (ebml_parse(matroska, matroska_segments, matroska) < 0)
1090
        return -1;
1091
    matroska_execute_seekhead(matroska);
1092

1093 1094 1095 1096 1097 1098
    if (matroska->duration)
        matroska->ctx->duration = matroska->duration * matroska->time_scale
                                  * 1000 / AV_TIME_BASE;
    if (matroska->title)
        strncpy(matroska->ctx->title, matroska->title,
                sizeof(matroska->ctx->title)-1);