FFmpeg: libavformat/matroskadec.c Source File

00001 /*
00002  * Matroska file demuxer
00003  * Copyright (c) 2003-2008 The FFmpeg Project
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00031 #include <stdio.h>
00032 #include "avformat.h"
00033 #include "internal.h"
00034 /* For ff_codec_get_id(). */
00035 #include "riff.h"
00036 #include "isom.h"
00037 #include "rm.h"
00038 #include "matroska.h"
00039 #include "libavcodec/mpeg4audio.h"
00040 #include "libavutil/intfloat_readwrite.h"
00041 #include "libavutil/intreadwrite.h"
00042 #include "libavutil/avstring.h"
00043 #include "libavutil/lzo.h"
00044 #if CONFIG_ZLIB
00045 #include <zlib.h>
00046 #endif
00047 #if CONFIG_BZLIB
00048 #include <bzlib.h>
00049 #endif
00050 
00051 typedef enum {
00052     EBML_NONE,
00053     EBML_UINT,
00054     EBML_FLOAT,
00055     EBML_STR,
00056     EBML_UTF8,
00057     EBML_BIN,
00058     EBML_NEST,
00059     EBML_PASS,
00060     EBML_STOP,
00061 } EbmlType;
00062 
00063 typedef const struct EbmlSyntax {
00064     uint32_t id;
00065     EbmlType type;
00066     int list_elem_size;
00067     int data_offset;
00068     union {
00069         uint64_t    u;
00070         double      f;
00071         const char *s;
00072         const struct EbmlSyntax *n;
00073     } def;
00074 } EbmlSyntax;
00075 
00076 typedef struct {
00077     int nb_elem;
00078     void *elem;
00079 } EbmlList;
00080 
00081 typedef struct {
00082     int      size;
00083     uint8_t *data;
00084     int64_t  pos;
00085 } EbmlBin;
00086 
00087 typedef struct {
00088     uint64_t version;
00089     uint64_t max_size;
00090     uint64_t id_length;
00091     char    *doctype;
00092     uint64_t doctype_version;
00093 } Ebml;
00094 
00095 typedef struct {
00096     uint64_t algo;
00097     EbmlBin  settings;
00098 } MatroskaTrackCompression;
00099 
00100 typedef struct {
00101     uint64_t scope;
00102     uint64_t type;
00103     MatroskaTrackCompression compression;
00104 } MatroskaTrackEncoding;
00105 
00106 typedef struct {
00107     double   frame_rate;
00108     uint64_t display_width;
00109     uint64_t display_height;
00110     uint64_t pixel_width;
00111     uint64_t pixel_height;
00112     uint64_t fourcc;
00113 } MatroskaTrackVideo;
00114 
00115 typedef struct {
00116     double   samplerate;
00117     double   out_samplerate;
00118     uint64_t bitdepth;
00119     uint64_t channels;
00120 
00121     /* real audio header (extracted from extradata) */
00122     int      coded_framesize;
00123     int      sub_packet_h;
00124     int      frame_size;
00125     int      sub_packet_size;
00126     int      sub_packet_cnt;
00127     int      pkt_cnt;
00128     uint8_t *buf;
00129 } MatroskaTrackAudio;
00130 
00131 typedef struct {
00132     uint64_t num;
00133     uint64_t uid;
00134     uint64_t type;
00135     char    *name;
00136     char    *codec_id;
00137     EbmlBin  codec_priv;
00138     char    *language;
00139     double time_scale;
00140     uint64_t default_duration;
00141     uint64_t flag_default;
00142     uint64_t flag_forced;
00143     MatroskaTrackVideo video;
00144     MatroskaTrackAudio audio;
00145     EbmlList encodings;
00146 
00147     AVStream *stream;
00148     int64_t end_timecode;
00149     int ms_compat;
00150 } MatroskaTrack;
00151 
00152 typedef struct {
00153     uint64_t uid;
00154     char *filename;
00155     char *mime;
00156     EbmlBin bin;
00157 
00158     AVStream *stream;
00159 } MatroskaAttachement;
00160 
00161 typedef struct {
00162     uint64_t start;
00163     uint64_t end;
00164     uint64_t uid;
00165     char    *title;
00166 
00167     AVChapter *chapter;
00168 } MatroskaChapter;
00169 
00170 typedef struct {
00171     uint64_t track;
00172     uint64_t pos;
00173 } MatroskaIndexPos;
00174 
00175 typedef struct {
00176     uint64_t time;
00177     EbmlList pos;
00178 } MatroskaIndex;
00179 
00180 typedef struct {
00181     char *name;
00182     char *string;
00183     char *lang;
00184     uint64_t def;
00185     EbmlList sub;
00186 } MatroskaTag;
00187 
00188 typedef struct {
00189     char    *type;
00190     uint64_t typevalue;
00191     uint64_t trackuid;
00192     uint64_t chapteruid;
00193     uint64_t attachuid;
00194 } MatroskaTagTarget;
00195 
00196 typedef struct {
00197     MatroskaTagTarget target;
00198     EbmlList tag;
00199 } MatroskaTags;
00200 
00201 typedef struct {
00202     uint64_t id;
00203     uint64_t pos;
00204 } MatroskaSeekhead;
00205 
00206 typedef struct {
00207     uint64_t start;
00208     uint64_t length;
00209 } MatroskaLevel;
00210 
00211 typedef struct {
00212     AVFormatContext *ctx;
00213 
00214     /* EBML stuff */
00215     int num_levels;
00216     MatroskaLevel levels[EBML_MAX_DEPTH];
00217     int level_up;
00218     uint32_t current_id;
00219 
00220     uint64_t time_scale;
00221     double   duration;
00222     char    *title;
00223     EbmlList tracks;
00224     EbmlList attachments;
00225     EbmlList chapters;
00226     EbmlList index;
00227     EbmlList tags;
00228     EbmlList seekhead;
00229 
00230     /* byte position of the segment inside the stream */
00231     int64_t segment_start;
00232 
00233     /* the packet queue */
00234     AVPacket **packets;
00235     int num_packets;
00236     AVPacket *prev_pkt;
00237 
00238     int done;
00239 
00240     /* What to skip before effectively reading a packet. */
00241     int skip_to_keyframe;
00242     uint64_t skip_to_timecode;
00243 } MatroskaDemuxContext;
00244 
00245 typedef struct {
00246     uint64_t duration;
00247     int64_t  reference;
00248     uint64_t non_simple;
00249     EbmlBin  bin;
00250 } MatroskaBlock;
00251 
00252 typedef struct {
00253     uint64_t timecode;
00254     EbmlList blocks;
00255 } MatroskaCluster;
00256 
00257 static EbmlSyntax ebml_header[] = {
00258     { EBML_ID_EBMLREADVERSION,        EBML_UINT, 0, offsetof(Ebml,version), {.u=EBML_VERSION} },
00259     { EBML_ID_EBMLMAXSIZELENGTH,      EBML_UINT, 0, offsetof(Ebml,max_size), {.u=8} },
00260     { EBML_ID_EBMLMAXIDLENGTH,        EBML_UINT, 0, offsetof(Ebml,id_length), {.u=4} },
00261     { EBML_ID_DOCTYPE,                EBML_STR,  0, offsetof(Ebml,doctype), {.s="(none)"} },
00262     { EBML_ID_DOCTYPEREADVERSION,     EBML_UINT, 0, offsetof(Ebml,doctype_version), {.u=1} },
00263     { EBML_ID_EBMLVERSION,            EBML_NONE },
00264     { EBML_ID_DOCTYPEVERSION,         EBML_NONE },
00265     { 0 }
00266 };
00267 
00268 static EbmlSyntax ebml_syntax[] = {
00269     { EBML_ID_HEADER,                 EBML_NEST, 0, 0, {.n=ebml_header} },
00270     { 0 }
00271 };
00272 
00273 static EbmlSyntax matroska_info[] = {
00274     { MATROSKA_ID_TIMECODESCALE,      EBML_UINT,  0, offsetof(MatroskaDemuxContext,time_scale), {.u=1000000} },
00275     { MATROSKA_ID_DURATION,           EBML_FLOAT, 0, offsetof(MatroskaDemuxContext,duration) },
00276     { MATROSKA_ID_TITLE,              EBML_UTF8,  0, offsetof(MatroskaDemuxContext,title) },
00277     { MATROSKA_ID_WRITINGAPP,         EBML_NONE },
00278     { MATROSKA_ID_MUXINGAPP,          EBML_NONE },
00279     { MATROSKA_ID_DATEUTC,            EBML_NONE },
00280     { MATROSKA_ID_SEGMENTUID,         EBML_NONE },
00281     { 0 }
00282 };
00283 
00284 static EbmlSyntax matroska_track_video[] = {
00285     { MATROSKA_ID_VIDEOFRAMERATE,     EBML_FLOAT,0, offsetof(MatroskaTrackVideo,frame_rate) },
00286     { MATROSKA_ID_VIDEODISPLAYWIDTH,  EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_width) },
00287     { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_height) },
00288     { MATROSKA_ID_VIDEOPIXELWIDTH,    EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_width) },
00289     { MATROSKA_ID_VIDEOPIXELHEIGHT,   EBML_UINT, 0, offsetof(MatroskaTrackVideo,pixel_height) },
00290     { MATROSKA_ID_VIDEOCOLORSPACE,    EBML_UINT, 0, offsetof(MatroskaTrackVideo,fourcc) },
00291     { MATROSKA_ID_VIDEOPIXELCROPB,    EBML_NONE },
00292     { MATROSKA_ID_VIDEOPIXELCROPT,    EBML_NONE },
00293     { MATROSKA_ID_VIDEOPIXELCROPL,    EBML_NONE },
00294     { MATROSKA_ID_VIDEOPIXELCROPR,    EBML_NONE },
00295     { MATROSKA_ID_VIDEODISPLAYUNIT,   EBML_NONE },
00296     { MATROSKA_ID_VIDEOFLAGINTERLACED,EBML_NONE },
00297     { MATROSKA_ID_VIDEOSTEREOMODE,    EBML_NONE },
00298     { MATROSKA_ID_VIDEOASPECTRATIO,   EBML_NONE },
00299     { 0 }
00300 };
00301 
00302 static EbmlSyntax matroska_track_audio[] = {
00303     { MATROSKA_ID_AUDIOSAMPLINGFREQ,  EBML_FLOAT,0, offsetof(MatroskaTrackAudio,samplerate), {.f=8000.0} },
00304     { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ,EBML_FLOAT,0,offsetof(MatroskaTrackAudio,out_samplerate) },
00305     { MATROSKA_ID_AUDIOBITDEPTH,      EBML_UINT, 0, offsetof(MatroskaTrackAudio,bitdepth) },
00306     { MATROSKA_ID_AUDIOCHANNELS,      EBML_UINT, 0, offsetof(MatroskaTrackAudio,channels), {.u=1} },
00307     { 0 }
00308 };
00309 
00310 static EbmlSyntax matroska_track_encoding_compression[] = {
00311     { MATROSKA_ID_ENCODINGCOMPALGO,   EBML_UINT, 0, offsetof(MatroskaTrackCompression,algo), {.u=0} },
00312     { MATROSKA_ID_ENCODINGCOMPSETTINGS,EBML_BIN, 0, offsetof(MatroskaTrackCompression,settings) },
00313     { 0 }
00314 };
00315 
00316 static EbmlSyntax matroska_track_encoding[] = {
00317     { MATROSKA_ID_ENCODINGSCOPE,      EBML_UINT, 0, offsetof(MatroskaTrackEncoding,scope), {.u=1} },
00318     { MATROSKA_ID_ENCODINGTYPE,       EBML_UINT, 0, offsetof(MatroskaTrackEncoding,type), {.u=0} },
00319     { MATROSKA_ID_ENCODINGCOMPRESSION,EBML_NEST, 0, offsetof(MatroskaTrackEncoding,compression), {.n=matroska_track_encoding_compression} },
00320     { MATROSKA_ID_ENCODINGORDER,      EBML_NONE },
00321     { 0 }
00322 };
00323 
00324 static EbmlSyntax matroska_track_encodings[] = {
00325     { MATROSKA_ID_TRACKCONTENTENCODING, EBML_NEST, sizeof(MatroskaTrackEncoding), offsetof(MatroskaTrack,encodings), {.n=matroska_track_encoding} },
00326     { 0 }
00327 };
00328 
00329 static EbmlSyntax matroska_track[] = {
00330     { MATROSKA_ID_TRACKNUMBER,          EBML_UINT, 0, offsetof(MatroskaTrack,num) },
00331     { MATROSKA_ID_TRACKNAME,            EBML_UTF8, 0, offsetof(MatroskaTrack,name) },
00332     { MATROSKA_ID_TRACKUID,             EBML_UINT, 0, offsetof(MatroskaTrack,uid) },
00333     { MATROSKA_ID_TRACKTYPE,            EBML_UINT, 0, offsetof(MatroskaTrack,type) },
00334     { MATROSKA_ID_CODECID,              EBML_STR,  0, offsetof(MatroskaTrack,codec_id) },
00335     { MATROSKA_ID_CODECPRIVATE,         EBML_BIN,  0, offsetof(MatroskaTrack,codec_priv) },
00336     { MATROSKA_ID_TRACKLANGUAGE,        EBML_UTF8, 0, offsetof(MatroskaTrack,language), {.s="eng"} },
00337     { MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, offsetof(MatroskaTrack,default_duration) },
00338     { MATROSKA_ID_TRACKTIMECODESCALE,   EBML_FLOAT,0, offsetof(MatroskaTrack,time_scale), {.f=1.0} },
00339     { MATROSKA_ID_TRACKFLAGDEFAULT,     EBML_UINT, 0, offsetof(MatroskaTrack,flag_default), {.u=1} },
00340     { MATROSKA_ID_TRACKFLAGFORCED,      EBML_UINT, 0, offsetof(MatroskaTrack,flag_forced), {.u=0} },
00341     { MATROSKA_ID_TRACKVIDEO,           EBML_NEST, 0, offsetof(MatroskaTrack,video), {.n=matroska_track_video} },
00342     { MATROSKA_ID_TRACKAUDIO,           EBML_NEST, 0, offsetof(MatroskaTrack,audio), {.n=matroska_track_audio} },
00343     { MATROSKA_ID_TRACKCONTENTENCODINGS,EBML_NEST, 0, 0, {.n=matroska_track_encodings} },
00344     { MATROSKA_ID_TRACKFLAGENABLED,     EBML_NONE },
00345     { MATROSKA_ID_TRACKFLAGLACING,      EBML_NONE },
00346     { MATROSKA_ID_CODECNAME,            EBML_NONE },
00347     { MATROSKA_ID_CODECDECODEALL,       EBML_NONE },
00348     { MATROSKA_ID_CODECINFOURL,         EBML_NONE },
00349     { MATROSKA_ID_CODECDOWNLOADURL,     EBML_NONE },
00350     { MATROSKA_ID_TRACKMINCACHE,        EBML_NONE },
00351     { MATROSKA_ID_TRACKMAXCACHE,        EBML_NONE },
00352     { MATROSKA_ID_TRACKMAXBLKADDID,     EBML_NONE },
00353     { 0 }
00354 };
00355 
00356 static EbmlSyntax matroska_tracks[] = {
00357     { MATROSKA_ID_TRACKENTRY,         EBML_NEST, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext,tracks), {.n=matroska_track} },
00358     { 0 }
00359 };
00360 
00361 static EbmlSyntax matroska_attachment[] = {
00362     { MATROSKA_ID_FILEUID,            EBML_UINT, 0, offsetof(MatroskaAttachement,uid) },
00363     { MATROSKA_ID_FILENAME,           EBML_UTF8, 0, offsetof(MatroskaAttachement,filename) },
00364     { MATROSKA_ID_FILEMIMETYPE,       EBML_STR,  0, offsetof(MatroskaAttachement,mime) },
00365     { MATROSKA_ID_FILEDATA,           EBML_BIN,  0, offsetof(MatroskaAttachement,bin) },
00366     { MATROSKA_ID_FILEDESC,           EBML_NONE },
00367     { 0 }
00368 };
00369 
00370 static EbmlSyntax matroska_attachments[] = {
00371     { MATROSKA_ID_ATTACHEDFILE,       EBML_NEST, sizeof(MatroskaAttachement), offsetof(MatroskaDemuxContext,attachments), {.n=matroska_attachment} },
00372     { 0 }
00373 };
00374 
00375 static EbmlSyntax matroska_chapter_display[] = {
00376     { MATROSKA_ID_CHAPSTRING,         EBML_UTF8, 0, offsetof(MatroskaChapter,title) },
00377     { MATROSKA_ID_CHAPLANG,           EBML_NONE },
00378     { 0 }
00379 };
00380 
00381 static EbmlSyntax matroska_chapter_entry[] = {
00382     { MATROSKA_ID_CHAPTERTIMESTART,   EBML_UINT, 0, offsetof(MatroskaChapter,start), {.u=AV_NOPTS_VALUE} },
00383     { MATROSKA_ID_CHAPTERTIMEEND,     EBML_UINT, 0, offsetof(MatroskaChapter,end), {.u=AV_NOPTS_VALUE} },
00384     { MATROSKA_ID_CHAPTERUID,         EBML_UINT, 0, offsetof(MatroskaChapter,uid) },
00385     { MATROSKA_ID_CHAPTERDISPLAY,     EBML_NEST, 0, 0, {.n=matroska_chapter_display} },
00386     { MATROSKA_ID_CHAPTERFLAGHIDDEN,  EBML_NONE },
00387     { MATROSKA_ID_CHAPTERFLAGENABLED, EBML_NONE },
00388     { MATROSKA_ID_CHAPTERPHYSEQUIV,   EBML_NONE },
00389     { MATROSKA_ID_CHAPTERATOM,        EBML_NONE },
00390     { 0 }
00391 };
00392 
00393 static EbmlSyntax matroska_chapter[] = {
00394     { MATROSKA_ID_CHAPTERATOM,        EBML_NEST, sizeof(MatroskaChapter), offsetof(MatroskaDemuxContext,chapters), {.n=matroska_chapter_entry} },
00395     { MATROSKA_ID_EDITIONUID,         EBML_NONE },
00396     { MATROSKA_ID_EDITIONFLAGHIDDEN,  EBML_NONE },
00397     { MATROSKA_ID_EDITIONFLAGDEFAULT, EBML_NONE },
00398     { MATROSKA_ID_EDITIONFLAGORDERED, EBML_NONE },
00399     { 0 }
00400 };
00401 
00402 static EbmlSyntax matroska_chapters[] = {
00403     { MATROSKA_ID_EDITIONENTRY,       EBML_NEST, 0, 0, {.n=matroska_chapter} },
00404     { 0 }
00405 };
00406 
00407 static EbmlSyntax matroska_index_pos[] = {
00408     { MATROSKA_ID_CUETRACK,           EBML_UINT, 0, offsetof(MatroskaIndexPos,track) },
00409     { MATROSKA_ID_CUECLUSTERPOSITION, EBML_UINT, 0, offsetof(MatroskaIndexPos,pos)   },
00410     { MATROSKA_ID_CUEBLOCKNUMBER,     EBML_NONE },
00411     { 0 }
00412 };
00413 
00414 static EbmlSyntax matroska_index_entry[] = {
00415     { MATROSKA_ID_CUETIME,            EBML_UINT, 0, offsetof(MatroskaIndex,time) },
00416     { MATROSKA_ID_CUETRACKPOSITION,   EBML_NEST, sizeof(MatroskaIndexPos), offsetof(MatroskaIndex,pos), {.n=matroska_index_pos} },
00417     { 0 }
00418 };
00419 
00420 static EbmlSyntax matroska_index[] = {
00421     { MATROSKA_ID_POINTENTRY,         EBML_NEST, sizeof(MatroskaIndex), offsetof(MatroskaDemuxContext,index), {.n=matroska_index_entry} },
00422     { 0 }
00423 };
00424 
00425 static EbmlSyntax matroska_simpletag[] = {
00426     { MATROSKA_ID_TAGNAME,            EBML_UTF8, 0, offsetof(MatroskaTag,name) },
00427     { MATROSKA_ID_TAGSTRING,          EBML_UTF8, 0, offsetof(MatroskaTag,string) },
00428     { MATROSKA_ID_TAGLANG,            EBML_STR,  0, offsetof(MatroskaTag,lang), {.s="und"} },
00429     { MATROSKA_ID_TAGDEFAULT,         EBML_UINT, 0, offsetof(MatroskaTag,def) },
00430     { MATROSKA_ID_TAGDEFAULT_BUG,     EBML_UINT, 0, offsetof(MatroskaTag,def) },
00431     { MATROSKA_ID_SIMPLETAG,          EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTag,sub), {.n=matroska_simpletag} },
00432     { 0 }
00433 };
00434 
00435 static EbmlSyntax matroska_tagtargets[] = {
00436     { MATROSKA_ID_TAGTARGETS_TYPE,      EBML_STR,  0, offsetof(MatroskaTagTarget,type) },
00437     { MATROSKA_ID_TAGTARGETS_TYPEVALUE, EBML_UINT, 0, offsetof(MatroskaTagTarget,typevalue), {.u=50} },
00438     { MATROSKA_ID_TAGTARGETS_TRACKUID,  EBML_UINT, 0, offsetof(MatroskaTagTarget,trackuid) },
00439     { MATROSKA_ID_TAGTARGETS_CHAPTERUID,EBML_UINT, 0, offsetof(MatroskaTagTarget,chapteruid) },
00440     { MATROSKA_ID_TAGTARGETS_ATTACHUID, EBML_UINT, 0, offsetof(MatroskaTagTarget,attachuid) },
00441     { 0 }
00442 };
00443 
00444 static EbmlSyntax matroska_tag[] = {
00445     { MATROSKA_ID_SIMPLETAG,          EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTags,tag), {.n=matroska_simpletag} },
00446     { MATROSKA_ID_TAGTARGETS,         EBML_NEST, 0, offsetof(MatroskaTags,target), {.n=matroska_tagtargets} },
00447     { 0 }
00448 };
00449 
00450 static EbmlSyntax matroska_tags[] = {
00451     { MATROSKA_ID_TAG,                EBML_NEST, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext,tags), {.n=matroska_tag} },
00452     { 0 }
00453 };
00454 
00455 static EbmlSyntax matroska_seekhead_entry[] = {
00456     { MATROSKA_ID_SEEKID,             EBML_UINT, 0, offsetof(MatroskaSeekhead,id) },
00457     { MATROSKA_ID_SEEKPOSITION,       EBML_UINT, 0, offsetof(MatroskaSeekhead,pos), {.u=-1} },
00458     { 0 }
00459 };
00460 
00461 static EbmlSyntax matroska_seekhead[] = {
00462     { MATROSKA_ID_SEEKENTRY,          EBML_NEST, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext,seekhead), {.n=matroska_seekhead_entry} },
00463     { 0 }
00464 };
00465 
00466 static EbmlSyntax matroska_segment[] = {
00467     { MATROSKA_ID_INFO,           EBML_NEST, 0, 0, {.n=matroska_info       } },
00468     { MATROSKA_ID_TRACKS,         EBML_NEST, 0, 0, {.n=matroska_tracks     } },
00469     { MATROSKA_ID_ATTACHMENTS,    EBML_NEST, 0, 0, {.n=matroska_attachments} },
00470     { MATROSKA_ID_CHAPTERS,       EBML_NEST, 0, 0, {.n=matroska_chapters   } },
00471     { MATROSKA_ID_CUES,           EBML_NEST, 0, 0, {.n=matroska_index      } },
00472     { MATROSKA_ID_TAGS,           EBML_NEST, 0, 0, {.n=matroska_tags       } },
00473     { MATROSKA_ID_SEEKHEAD,       EBML_NEST, 0, 0, {.n=matroska_seekhead   } },
00474     { MATROSKA_ID_CLUSTER,        EBML_STOP },
00475     { 0 }
00476 };
00477 
00478 static EbmlSyntax matroska_segments[] = {
00479     { MATROSKA_ID_SEGMENT,        EBML_NEST, 0, 0, {.n=matroska_segment    } },
00480     { 0 }
00481 };
00482 
00483 static EbmlSyntax matroska_blockgroup[] = {
00484     { MATROSKA_ID_BLOCK,          EBML_BIN,  0, offsetof(MatroskaBlock,bin) },
00485     { MATROSKA_ID_SIMPLEBLOCK,    EBML_BIN,  0, offsetof(MatroskaBlock,bin) },
00486     { MATROSKA_ID_BLOCKDURATION,  EBML_UINT, 0, offsetof(MatroskaBlock,duration), {.u=AV_NOPTS_VALUE} },
00487     { MATROSKA_ID_BLOCKREFERENCE, EBML_UINT, 0, offsetof(MatroskaBlock,reference) },
00488     { 1,                          EBML_UINT, 0, offsetof(MatroskaBlock,non_simple), {.u=1} },
00489     { 0 }
00490 };
00491 
00492 static EbmlSyntax matroska_cluster[] = {
00493     { MATROSKA_ID_CLUSTERTIMECODE,EBML_UINT,0, offsetof(MatroskaCluster,timecode) },
00494     { MATROSKA_ID_BLOCKGROUP,     EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
00495     { MATROSKA_ID_SIMPLEBLOCK,    EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster,blocks), {.n=matroska_blockgroup} },
00496     { MATROSKA_ID_CLUSTERPOSITION,EBML_NONE },
00497     { MATROSKA_ID_CLUSTERPREVSIZE,EBML_NONE },
00498     { 0 }
00499 };
00500 
00501 static EbmlSyntax matroska_clusters[] = {
00502     { MATROSKA_ID_CLUSTER,        EBML_NEST, 0, 0, {.n=matroska_cluster} },
00503     { MATROSKA_ID_INFO,           EBML_NONE },
00504     { MATROSKA_ID_CUES,           EBML_NONE },
00505     { MATROSKA_ID_TAGS,           EBML_NONE },
00506     { MATROSKA_ID_SEEKHEAD,       EBML_NONE },
00507     { 0 }
00508 };
00509 
00510 static const char *matroska_doctypes[] = { "matroska", "webm" };
00511 
00512 /*
00513  * Return: Whether we reached the end of a level in the hierarchy or not.
00514  */
00515 static int ebml_level_end(MatroskaDemuxContext *matroska)
00516 {
00517     ByteIOContext *pb = matroska->ctx->pb;
00518     int64_t pos = url_ftell(pb);
00519 
00520     if (matroska->num_levels > 0) {
00521         MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
00522         if (pos - level->start >= level->length || matroska->current_id) {
00523             matroska->num_levels--;
00524             return 1;
00525         }
00526     }
00527     return 0;
00528 }
00529 
00530 /*
00531  * Read: an "EBML number", which is defined as a variable-length
00532  * array of bytes. The first byte indicates the length by giving a
00533  * number of 0-bits followed by a one. The position of the first
00534  * "one" bit inside the first byte indicates the length of this
00535  * number.
00536  * Returns: number of bytes read, < 0 on error
00537  */
00538 static int ebml_read_num(MatroskaDemuxContext *matroska, ByteIOContext *pb,
00539                          int max_size, uint64_t *number)
00540 {
00541     int read = 1, n = 1;
00542     uint64_t total = 0;
00543 
00544     /* The first byte tells us the length in bytes - get_byte() can normally
00545      * return 0, but since that's not a valid first ebmlID byte, we can
00546      * use it safely here to catch EOS. */
00547     if (!(total = get_byte(pb))) {
00548         /* we might encounter EOS here */
00549         if (!url_feof(pb)) {
00550             int64_t pos = url_ftell(pb);
00551             av_log(matroska->ctx, AV_LOG_ERROR,
00552                    "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
00553                    pos, pos);
00554         }
00555         return AVERROR(EIO); /* EOS or actual I/O error */
00556     }
00557 
00558     /* get the length of the EBML number */
00559     read = 8 - ff_log2_tab[total];
00560     if (read > max_size) {
00561         int64_t pos = url_ftell(pb) - 1;
00562         av_log(matroska->ctx, AV_LOG_ERROR,
00563                "Invalid EBML number size tag 0x%02x at pos %"PRIu64" (0x%"PRIx64")\n",
00564                (uint8_t) total, pos, pos);
00565         return AVERROR_INVALIDDATA;
00566     }
00567 
00568     /* read out length */
00569     total ^= 1 << ff_log2_tab[total];
00570     while (n++ < read)
00571         total = (total << 8) | get_byte(pb);
00572 
00573     *number = total;
00574 
00575     return read;
00576 }
00577 
00583 static int ebml_read_length(MatroskaDemuxContext *matroska, ByteIOContext *pb,
00584                             uint64_t *number)
00585 {
00586     int res = ebml_read_num(matroska, pb, 8, number);
00587     if (res > 0 && *number + 1 == 1ULL << (7 * res))
00588         *number = 0xffffffffffffffULL;
00589     return res;
00590 }
00591 
00592 /*
00593  * Read the next element as an unsigned int.
00594  * 0 is success, < 0 is failure.
00595  */
00596 static int ebml_read_uint(ByteIOContext *pb, int size, uint64_t *num)
00597 {
00598     int n = 0;
00599 
00600     if (size > 8)
00601         return AVERROR_INVALIDDATA;
00602 
00603     /* big-endian ordering; build up number */
00604     *num = 0;
00605     while (n++ < size)
00606         *num = (*num << 8) | get_byte(pb);
00607 
00608     return 0;
00609 }
00610 
00611 /*
00612  * Read the next element as a float.
00613  * 0 is success, < 0 is failure.
00614  */
00615 static int ebml_read_float(ByteIOContext *pb, int size, double *num)
00616 {
00617     if (size == 0) {
00618         *num = 0;
00619     } else if (size == 4) {
00620         *num= av_int2flt(get_be32(pb));
00621     } else if(size==8){
00622         *num= av_int2dbl(get_be64(pb));
00623     } else
00624         return AVERROR_INVALIDDATA;
00625 
00626     return 0;
00627 }
00628 
00629 /*
00630  * Read the next element as an ASCII string.
00631  * 0 is success, < 0 is failure.
00632  */
00633 static int ebml_read_ascii(ByteIOContext *pb, int size, char **str)
00634 {
00635     av_free(*str);
00636     /* EBML strings are usually not 0-terminated, so we allocate one
00637      * byte more, read the string and NULL-terminate it ourselves. */
00638     if (!(*str = av_malloc(size + 1)))
00639         return AVERROR(ENOMEM);
00640     if (get_buffer(pb, (uint8_t *) *str, size) != size) {
00641         av_freep(str);
00642         return AVERROR(EIO);
00643     }
00644     (*str)[size] = '\0';
00645 
00646     return 0;
00647 }
00648 
00649 /*
00650  * Read the next element as binary data.
00651  * 0 is success, < 0 is failure.
00652  */
00653 static int ebml_read_binary(ByteIOContext *pb, int length, EbmlBin *bin)
00654 {
00655     av_free(bin->data);
00656     if (!(bin->data = av_malloc(length)))
00657         return AVERROR(ENOMEM);
00658 
00659     bin->size = length;
00660     bin->pos  = url_ftell(pb);
00661     if (get_buffer(pb, bin->data, length) != length) {
00662         av_freep(&bin->data);
00663         return AVERROR(EIO);
00664     }
00665 
00666     return 0;
00667 }
00668 
00669 /*
00670  * Read the next element, but only the header. The contents
00671  * are supposed to be sub-elements which can be read separately.
00672  * 0 is success, < 0 is failure.
00673  */
00674 static int ebml_read_master(MatroskaDemuxContext *matroska, uint64_t length)
00675 {
00676     ByteIOContext *pb = matroska->ctx->pb;
00677     MatroskaLevel *level;
00678 
00679     if (matroska->num_levels >= EBML_MAX_DEPTH) {
00680         av_log(matroska->ctx, AV_LOG_ERROR,
00681                "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
00682         return AVERROR(ENOSYS);
00683     }
00684 
00685     level = &matroska->levels[matroska->num_levels++];
00686     level->start = url_ftell(pb);
00687     level->length = length;
00688 
00689     return 0;
00690 }
00691 
00692 /*
00693  * Read signed/unsigned "EBML" numbers.
00694  * Return: number of bytes processed, < 0 on error
00695  */
00696 static int matroska_ebmlnum_uint(MatroskaDemuxContext *matroska,
00697                                  uint8_t *data, uint32_t size, uint64_t *num)
00698 {
00699     ByteIOContext pb;
00700     init_put_byte(&pb, data, size, 0, NULL, NULL, NULL, NULL);
00701     return ebml_read_num(matroska, &pb, FFMIN(size, 8), num);
00702 }
00703 
00704 /*
00705  * Same as above, but signed.
00706  */
00707 static int matroska_ebmlnum_sint(MatroskaDemuxContext *matroska,
00708                                  uint8_t *data, uint32_t size, int64_t *num)
00709 {
00710     uint64_t unum;
00711     int res;
00712 
00713     /* read as unsigned number first */
00714     if ((res = matroska_ebmlnum_uint(matroska, data, size, &unum)) < 0)
00715         return res;
00716 
00717     /* make signed (weird way) */
00718     *num = unum - ((1LL << (7*res - 1)) - 1);
00719 
00720     return res;
00721 }
00722 
00723 static int ebml_parse_elem(MatroskaDemuxContext *matroska,
00724                            EbmlSyntax *syntax, void *data);
00725 
00726 static int ebml_parse_id(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
00727                          uint32_t id, void *data)
00728 {
00729     int i;
00730     for (i=0; syntax[i].id; i++)
00731         if (id == syntax[i].id)
00732             break;
00733     if (!syntax[i].id && id == MATROSKA_ID_CLUSTER &&
00734         matroska->num_levels > 0 &&
00735         matroska->levels[matroska->num_levels-1].length == 0xffffffffffffff)
00736         return 0;  // we reached the end of an unknown size cluster
00737     if (!syntax[i].id && id != EBML_ID_VOID && id != EBML_ID_CRC32)
00738         av_log(matroska->ctx, AV_LOG_INFO, "Unknown entry 0x%X\n", id);
00739     return ebml_parse_elem(matroska, &syntax[i], data);
00740 }
00741 
00742 static int ebml_parse(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
00743                       void *data)
00744 {
00745     if (!matroska->current_id) {
00746         uint64_t id;
00747         int res = ebml_read_num(matroska, matroska->ctx->pb, 4, &id);
00748         if (res < 0)
00749             return res;
00750         matroska->current_id = id | 1 << 7*res;
00751     }
00752     return ebml_parse_id(matroska, syntax, matroska->current_id, data);
00753 }
00754 
00755 static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
00756                            void *data)
00757 {
00758     int i, res = 0;
00759 
00760     for (i=0; syntax[i].id; i++)
00761         switch (syntax[i].type) {
00762         case EBML_UINT:
00763             *(uint64_t *)((char *)data+syntax[i].data_offset) = syntax[i].def.u;
00764             break;
00765         case EBML_FLOAT:
00766             *(double   *)((char *)data+syntax[i].data_offset) = syntax[i].def.f;
00767             break;
00768         case EBML_STR:
00769         case EBML_UTF8:
00770             *(char    **)((char *)data+syntax[i].data_offset) = av_strdup(syntax[i].def.s);
00771             break;
00772         }
00773 
00774     while (!res && !ebml_level_end(matroska))
00775         res = ebml_parse(matroska, syntax, data);
00776 
00777     return res;
00778 }
00779 
00780 static int ebml_parse_elem(MatroskaDemuxContext *matroska,
00781                            EbmlSyntax *syntax, void *data)
00782 {
00783     ByteIOContext *pb = matroska->ctx->pb;
00784     uint32_t id = syntax->id;
00785     uint64_t length;
00786     int res;
00787 
00788     data = (char *)data + syntax->data_offset;
00789     if (syntax->list_elem_size) {
00790         EbmlList *list = data;
00791         list->elem = av_realloc(list->elem, (list->nb_elem+1)*syntax->list_elem_size);
00792         data = (char*)list->elem + list->nb_elem*syntax->list_elem_size;
00793         memset(data, 0, syntax->list_elem_size);
00794         list->nb_elem++;
00795     }
00796 
00797     if (syntax->type != EBML_PASS && syntax->type != EBML_STOP) {
00798         matroska->current_id = 0;
00799         if ((res = ebml_read_length(matroska, pb, &length)) < 0)
00800             return res;
00801     }
00802 
00803     switch (syntax->type) {
00804     case EBML_UINT:  res = ebml_read_uint  (pb, length, data);  break;
00805     case EBML_FLOAT: res = ebml_read_float (pb, length, data);  break;
00806     case EBML_STR:
00807     case EBML_UTF8:  res = ebml_read_ascii (pb, length, data);  break;
00808     case EBML_BIN:   res = ebml_read_binary(pb, length, data);  break;
00809     case EBML_NEST:  if ((res=ebml_read_master(matroska, length)) < 0)
00810                          return res;
00811                      if (id == MATROSKA_ID_SEGMENT)
00812                          matroska->segment_start = url_ftell(matroska->ctx->pb);
00813                      return ebml_parse_nest(matroska, syntax->def.n, data);
00814     case EBML_PASS:  return ebml_parse_id(matroska, syntax->def.n, id, data);
00815     case EBML_STOP:  return 1;
00816     default:         return url_fseek(pb,length,SEEK_CUR)<0 ? AVERROR(EIO) : 0;
00817     }
00818     if (res == AVERROR_INVALIDDATA)
00819         av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
00820     else if (res == AVERROR(EIO))
00821         av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
00822     return res;
00823 }
00824 
00825 static void ebml_free(EbmlSyntax *syntax, void *data)
00826 {
00827     int i, j;
00828     for (i=0; syntax[i].id; i++) {
00829         void *data_off = (char *)data + syntax[i].data_offset;
00830         switch (syntax[i].type) {
00831         case EBML_STR:
00832         case EBML_UTF8:  av_freep(data_off);                      break;
00833         case EBML_BIN:   av_freep(&((EbmlBin *)data_off)->data);  break;
00834         case EBML_NEST:
00835             if (syntax[i].list_elem_size) {
00836                 EbmlList *list = data_off;
00837                 char *ptr = list->elem;
00838                 for (j=0; j<list->nb_elem; j++, ptr+=syntax[i].list_elem_size)
00839                     ebml_free(syntax[i].def.n, ptr);
00840                 av_free(list->elem);
00841             } else
00842                 ebml_free(syntax[i].def.n, data_off);
00843         default:  break;
00844         }
00845     }
00846 }
00847 
00848 
00849 /*
00850  * Autodetecting...
00851  */
00852 static int matroska_probe(AVProbeData *p)
00853 {
00854     uint64_t total = 0;
00855     int len_mask = 0x80, size = 1, n = 1, i;
00856 
00857     /* EBML header? */
00858     if (AV_RB32(p->buf) != EBML_ID_HEADER)
00859         return 0;
00860 
00861     /* length of header */
00862     total = p->buf[4];
00863     while (size <= 8 && !(total & len_mask)) {
00864         size++;
00865         len_mask >>= 1;
00866     }
00867     if (size > 8)
00868       return 0;
00869     total &= (len_mask - 1);
00870     while (n < size)
00871         total = (total << 8) | p->buf[4 + n++];
00872 
00873     /* Does the probe data contain the whole header? */
00874     if (p->buf_size < 4 + size + total)
00875       return 0;
00876 
00877     /* The header should contain a known document type. For now,
00878      * we don't parse the whole header but simply check for the
00879      * availability of that array of characters inside the header.
00880      * Not fully fool-proof, but good enough. */
00881     for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++) {
00882         int probelen = strlen(matroska_doctypes[i]);
00883         for (n = 4+size; n <= 4+size+total-probelen; n++)
00884             if (!memcmp(p->buf+n, matroska_doctypes[i], probelen))
00885                 return AVPROBE_SCORE_MAX;
00886     }
00887 
00888     // probably valid EBML header but no recognized doctype
00889     return AVPROBE_SCORE_MAX/2;
00890 }
00891 
00892 static MatroskaTrack *matroska_find_track_by_num(MatroskaDemuxContext *matroska,
00893                                                  int num)
00894 {
00895     MatroskaTrack *tracks = matroska->tracks.elem;
00896     int i;
00897 
00898     for (i=0; i < matroska->tracks.nb_elem; i++)
00899         if (tracks[i].num == num)
00900             return &tracks[i];
00901 
00902     av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %d\n", num);
00903     return NULL;
00904 }
00905 
00906 static int matroska_decode_buffer(uint8_t** buf, int* buf_size,
00907                                   MatroskaTrack *track)
00908 {
00909     MatroskaTrackEncoding *encodings = track->encodings.elem;
00910     uint8_t* data = *buf;
00911     int isize = *buf_size;
00912     uint8_t* pkt_data = NULL;
00913     int pkt_size = isize;
00914     int result = 0;
00915     int olen;
00916 
00917     if (pkt_size >= 10000000)
00918         return -1;
00919 
00920     switch (encodings[0].compression.algo) {
00921     case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP:
00922         return encodings[0].compression.settings.size;
00923     case MATROSKA_TRACK_ENCODING_COMP_LZO:
00924         do {
00925             olen = pkt_size *= 3;
00926             pkt_data = av_realloc(pkt_data, pkt_size+AV_LZO_OUTPUT_PADDING);
00927             result = av_lzo1x_decode(pkt_data, &olen, data, &isize);
00928         } while (result==AV_LZO_OUTPUT_FULL && pkt_size<10000000);
00929         if (result)
00930             goto failed;
00931         pkt_size -= olen;
00932         break;
00933 #if CONFIG_ZLIB
00934     case MATROSKA_TRACK_ENCODING_COMP_ZLIB: {
00935         z_stream zstream = {0};
00936         if (inflateInit(&zstream) != Z_OK)
00937             return -1;
00938         zstream.next_in = data;
00939         zstream.avail_in = isize;
00940         do {
00941             pkt_size *= 3;
00942             pkt_data = av_realloc(pkt_data, pkt_size);
00943             zstream.avail_out = pkt_size - zstream.total_out;
00944             zstream.next_out = pkt_data + zstream.total_out;
00945             result = inflate(&zstream, Z_NO_FLUSH);
00946         } while (result==Z_OK && pkt_size<10000000);
00947         pkt_size = zstream.total_out;
00948         inflateEnd(&zstream);
00949         if (result != Z_STREAM_END)
00950             goto failed;
00951         break;
00952     }
00953 #endif
00954 #if CONFIG_BZLIB
00955     case MATROSKA_TRACK_ENCODING_COMP_BZLIB: {
00956         bz_stream bzstream = {0};
00957         if (BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
00958             return -1;
00959         bzstream.next_in = data;
00960         bzstream.avail_in = isize;
00961         do {
00962             pkt_size *= 3;
00963             pkt_data = av_realloc(pkt_data, pkt_size);
00964             bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
00965             bzstream.next_out = pkt_data + bzstream.total_out_lo32;
00966             result = BZ2_bzDecompress(&bzstream);
00967         } while (result==BZ_OK && pkt_size<10000000);
00968         pkt_size = bzstream.total_out_lo32;
00969         BZ2_bzDecompressEnd(&bzstream);
00970         if (result != BZ_STREAM_END)
00971             goto failed;
00972         break;
00973     }
00974 #endif
00975     default:
00976         return -1;
00977     }
00978 
00979     *buf = pkt_data;
00980     *buf_size = pkt_size;
00981     return 0;
00982  failed:
00983     av_free(pkt_data);
00984     return -1;
00985 }
00986 
00987 static void matroska_fix_ass_packet(MatroskaDemuxContext *matroska,
00988                                     AVPacket *pkt, uint64_t display_duration)
00989 {
00990     char *line, *layer, *ptr = pkt->data, *end = ptr+pkt->size;
00991     for (; *ptr!=',' && ptr<end-1; ptr++);
00992     if (*ptr == ',')
00993         layer = ++ptr;
00994     for (; *ptr!=',' && ptr<end-1; ptr++);
00995     if (*ptr == ',') {
00996         int64_t end_pts = pkt->pts + display_duration;
00997         int sc = matroska->time_scale * pkt->pts / 10000000;
00998         int ec = matroska->time_scale * end_pts  / 10000000;
00999         int sh, sm, ss, eh, em, es, len;
01000         sh = sc/360000;  sc -= 360000*sh;
01001         sm = sc/  6000;  sc -=   6000*sm;
01002         ss = sc/   100;  sc -=    100*ss;
01003         eh = ec/360000;  ec -= 360000*eh;
01004         em = ec/  6000;  ec -=   6000*em;
01005         es = ec/   100;  ec -=    100*es;
01006         *ptr++ = '\0';
01007         len = 50 + end-ptr + FF_INPUT_BUFFER_PADDING_SIZE;
01008         if (!(line = av_malloc(len)))
01009             return;
01010         snprintf(line,len,"Dialogue: %s,%d:%02d:%02d.%02d,%d:%02d:%02d.%02d,%s\r\n",
01011                  layer, sh, sm, ss, sc, eh, em, es, ec, ptr);
01012         av_free(pkt->data);
01013         pkt->data = line;
01014         pkt->size = strlen(line);
01015     }
01016 }
01017 
01018 static void matroska_merge_packets(AVPacket *out, AVPacket *in)
01019 {
01020     out->data = av_realloc(out->data, out->size+in->size);
01021     memcpy(out->data+out->size, in->data, in->size);
01022     out->size += in->size;
01023     av_destruct_packet(in);
01024     av_free(in);
01025 }
01026 
01027 static void matroska_convert_tag(AVFormatContext *s, EbmlList *list,
01028                                  AVMetadata **metadata, char *prefix)
01029 {
01030     MatroskaTag *tags = list->elem;
01031     char key[1024];
01032     int i;
01033 
01034     for (i=0; i < list->nb_elem; i++) {
01035         const char *lang = strcmp(tags[i].lang, "und") ? tags[i].lang : NULL;
01036 
01037         if (!tags[i].name) {
01038             av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no TagName.\n");
01039             continue;
01040         }
01041         if (prefix)  snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
01042         else         av_strlcpy(key, tags[i].name, sizeof(key));
01043         if (tags[i].def || !lang) {
01044         av_metadata_set2(metadata, key, tags[i].string, 0);
01045         if (tags[i].sub.nb_elem)
01046             matroska_convert_tag(s, &tags[i].sub, metadata, key);
01047         }
01048         if (lang) {
01049             av_strlcat(key, "-", sizeof(key));
01050             av_strlcat(key, lang, sizeof(key));
01051             av_metadata_set2(metadata, key, tags[i].string, 0);
01052             if (tags[i].sub.nb_elem)
01053                 matroska_convert_tag(s, &tags[i].sub, metadata, key);
01054         }
01055     }
01056     ff_metadata_conv(metadata, NULL, ff_mkv_metadata_conv);
01057 }
01058 
01059 static void matroska_convert_tags(AVFormatContext *s)
01060 {
01061     MatroskaDemuxContext *matroska = s->priv_data;
01062     MatroskaTags *tags = matroska->tags.elem;
01063     int i, j;
01064 
01065     for (i=0; i < matroska->tags.nb_elem; i++) {
01066         if (tags[i].target.attachuid) {
01067             MatroskaAttachement *attachment = matroska->attachments.elem;
01068             for (j=0; j<matroska->attachments.nb_elem; j++)
01069                 if (attachment[j].uid == tags[i].target.attachuid)
01070                     matroska_convert_tag(s, &tags[i].tag,
01071                                          &attachment[j].stream->metadata, NULL);
01072         } else if (tags[i].target.chapteruid) {
01073             MatroskaChapter *chapter = matroska->chapters.elem;
01074             for (j=0; j<matroska->chapters.nb_elem; j++)
01075                 if (chapter[j].uid == tags[i].target.chapteruid)
01076                     matroska_convert_tag(s, &tags[i].tag,
01077                                          &chapter[j].chapter->metadata, NULL);
01078         } else if (tags[i].target.trackuid) {
01079             MatroskaTrack *track = matroska->tracks.elem;
01080             for (j=0; j<matroska->tracks.nb_elem; j++)
01081                 if (track[j].uid == tags[i].target.trackuid)
01082                     matroska_convert_tag(s, &tags[i].tag,
01083                                          &track[j].stream->metadata, NULL);
01084         } else {
01085             matroska_convert_tag(s, &tags[i].tag, &s->metadata,
01086                                  tags[i].target.type);
01087         }
01088     }
01089 }
01090 
01091 static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
01092 {
01093     EbmlList *seekhead_list = &matroska->seekhead;
01094     MatroskaSeekhead *seekhead = seekhead_list->elem;
01095     uint32_t level_up = matroska->level_up;
01096     int64_t before_pos = url_ftell(matroska->ctx->pb);
01097     uint32_t saved_id = matroska->current_id;
01098     MatroskaLevel level;
01099     int i;
01100 
01101     // we should not do any seeking in the streaming case
01102     if (url_is_streamed(matroska->ctx->pb) ||
01103         (matroska->ctx->flags & AVFMT_FLAG_IGNIDX))
01104         return;
01105 
01106     for (i=0; i<seekhead_list->nb_elem; i++) {
01107         int64_t offset = seekhead[i].pos + matroska->segment_start;
01108 
01109         if (seekhead[i].pos <= before_pos
01110             || seekhead[i].id == MATROSKA_ID_SEEKHEAD
01111             || seekhead[i].id == MATROSKA_ID_CLUSTER)
01112             continue;
01113 
01114         /* seek */
01115         if (url_fseek(matroska->ctx->pb, offset, SEEK_SET) != offset)
01116             continue;
01117 
01118         /* We don't want to lose our seekhead level, so we add
01119          * a dummy. This is a crude hack. */
01120         if (matroska->num_levels == EBML_MAX_DEPTH) {
01121             av_log(matroska->ctx, AV_LOG_INFO,
01122                    "Max EBML element depth (%d) reached, "
01123                    "cannot parse further.\n", EBML_MAX_DEPTH);
01124             break;
01125         }
01126 
01127         level.start = 0;
01128         level.length = (uint64_t)-1;
01129         matroska->levels[matroska->num_levels] = level;
01130         matroska->num_levels++;
01131         matroska->current_id = 0;
01132 
01133         ebml_parse(matroska, matroska_segment, matroska);
01134 
01135         /* remove dummy level */
01136         while (matroska->num_levels) {
01137             uint64_t length = matroska->levels[--matroska->num_levels].length;
01138             if (length == (uint64_t)-1)
01139                 break;
01140         }
01141     }
01142 
01143     /* seek back */
01144     url_fseek(matroska->ctx->pb, before_pos, SEEK_SET);
01145     matroska->level_up = level_up;
01146     matroska->current_id = saved_id;
01147 }
01148 
01149 static int matroska_aac_profile(char *codec_id)
01150 {
01151     static const char * const aac_profiles[] = { "MAIN", "LC", "SSR" };
01152     int profile;
01153 
01154     for (profile=0; profile<FF_ARRAY_ELEMS(aac_profiles); profile++)
01155         if (strstr(codec_id, aac_profiles[profile]))
01156             break;
01157     return profile + 1;
01158 }
01159 
01160 static int matroska_aac_sri(int samplerate)
01161 {
01162     int sri;
01163 
01164     for (sri=0; sri<FF_ARRAY_ELEMS(ff_mpeg4audio_sample_rates); sri++)
01165         if (ff_mpeg4audio_sample_rates[sri] == samplerate)
01166             break;
01167     return sri;
01168 }
01169 
01170 static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
01171 {
01172     MatroskaDemuxContext *matroska = s->priv_data;
01173     EbmlList *attachements_list = &matroska->attachments;
01174     MatroskaAttachement *attachements;
01175     EbmlList *chapters_list = &matroska->chapters;
01176     MatroskaChapter *chapters;
01177     MatroskaTrack *tracks;
01178     EbmlList *index_list;
01179     MatroskaIndex *index;
01180     int index_scale = 1;
01181     uint64_t max_start = 0;
01182     Ebml ebml = { 0 };
01183     AVStream *st;
01184     int i, j, res;
01185 
01186     matroska->ctx = s;
01187 
01188     /* First read the EBML header. */
01189     if (ebml_parse(matroska, ebml_syntax, &ebml)
01190         || ebml.version > EBML_VERSION       || ebml.max_size > sizeof(uint64_t)
01191         || ebml.id_length > sizeof(uint32_t) || ebml.doctype_version > 2) {
01192         av_log(matroska->ctx, AV_LOG_ERROR,
01193                "EBML header using unsupported features\n"
01194                "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
01195                ebml.version, ebml.doctype, ebml.doctype_version);
01196         ebml_free(ebml_syntax, &ebml);
01197         return AVERROR_PATCHWELCOME;
01198     }
01199     for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++)
01200         if (!strcmp(ebml.doctype, matroska_doctypes[i]))
01201             break;
01202     if (i >= FF_ARRAY_ELEMS(matroska_doctypes)) {
01203         av_log(s, AV_LOG_WARNING, "Unknown EBML doctype '%s'\n", ebml.doctype);
01204     }
01205     ebml_free(ebml_syntax, &ebml);
01206 
01207     /* The next thing is a segment. */
01208     if ((res = ebml_parse(matroska, matroska_segments, matroska)) < 0)
01209         return res;
01210     matroska_execute_seekhead(matroska);
01211 
01212     if (!matroska->time_scale)
01213         matroska->time_scale = 1000000;
01214     if (matroska->duration)
01215         matroska->ctx->duration = matroska->duration * matroska->time_scale
01216                                   * 1000 / AV_TIME_BASE;
01217     av_metadata_set2(&s->metadata, "title", matroska->title, 0);
01218 
01219     tracks = matroska->tracks.elem;
01220     for (i=0; i < matroska->tracks.nb_elem; i++) {
01221         MatroskaTrack *track = &tracks[i];
01222         enum CodecID codec_id = CODEC_ID_NONE;
01223         EbmlList *encodings_list = &tracks->encodings;
01224         MatroskaTrackEncoding *encodings = encodings_list->elem;
01225         uint8_t *extradata = NULL;
01226         int extradata_size = 0;
01227         int extradata_offset = 0;
01228         ByteIOContext b;
01229 
01230         /* Apply some sanity checks. */
01231         if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
01232             track->type != MATROSKA_TRACK_TYPE_AUDIO &&
01233             track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
01234             av_log(matroska->ctx, AV_LOG_INFO,
01235                    "Unknown or unsupported track type %"PRIu64"\n",
01236                    track->type);
01237             continue;
01238         }
01239         if (track->codec_id == NULL)
01240             continue;
01241 
01242         if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
01243             if (!track->default_duration)
01244                 track->default_duration = 1000000000/track->video.frame_rate;
01245             if (!track->video.display_width)
01246                 track->video.display_width = track->video.pixel_width;
01247             if (!track->video.display_height)
01248                 track->video.display_height = track->video.pixel_height;
01249         } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
01250             if (!track->audio.out_samplerate)
01251                 track->audio.out_samplerate = track->audio.samplerate;
01252         }
01253         if (encodings_list->nb_elem > 1) {
01254             av_log(matroska->ctx, AV_LOG_ERROR,
01255                    "Multiple combined encodings no supported");
01256         } else if (encodings_list->nb_elem == 1) {
01257             if (encodings[0].type ||
01258                 (encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP &&
01259 #if CONFIG_ZLIB
01260                  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB &&
01261 #endif
01262 #if CONFIG_BZLIB
01263                  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_BZLIB &&
01264 #endif
01265                  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_LZO)) {
01266                 encodings[0].scope = 0;
01267                 av_log(matroska->ctx, AV_LOG_ERROR,
01268                        "Unsupported encoding type");
01269             } else if (track->codec_priv.size && encodings[0].scope&2) {
01270                 uint8_t *codec_priv = track->codec_priv.data;
01271                 int offset = matroska_decode_buffer(&track->codec_priv.data,
01272                                                     &track->codec_priv.size,
01273                                                     track);
01274                 if (offset < 0) {
01275                     track->codec_priv.data = NULL;
01276                     track->codec_priv.size = 0;
01277                     av_log(matroska->ctx, AV_LOG_ERROR,
01278                            "Failed to decode codec private data\n");
01279                 } else if (offset > 0) {
01280                     track->codec_priv.data = av_malloc(track->codec_priv.size + offset);
01281                     memcpy(track->codec_priv.data,
01282                            encodings[0].compression.settings.data, offset);
01283                     memcpy(track->codec_priv.data+offset, codec_priv,
01284                            track->codec_priv.size);
01285                     track->codec_priv.size += offset;
01286                 }
01287                 if (codec_priv != track->codec_priv.data)
01288                     av_free(codec_priv);
01289             }
01290         }
01291 
01292         for(j=0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++){
01293             if(!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
01294                         strlen(ff_mkv_codec_tags[j].str))){
01295                 codec_id= ff_mkv_codec_tags[j].id;
01296                 break;
01297             }
01298         }
01299 
01300         st = track->stream = av_new_stream(s, 0);
01301         if (st == NULL)
01302             return AVERROR(ENOMEM);
01303 
01304         if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC")
01305             && track->codec_priv.size >= 40
01306             && track->codec_priv.data != NULL) {
01307             track->ms_compat = 1;
01308             track->video.fourcc = AV_RL32(track->codec_priv.data + 16);
01309             codec_id = ff_codec_get_id(ff_codec_bmp_tags, track->video.fourcc);
01310             extradata_offset = 40;
01311         } else if (!strcmp(track->codec_id, "A_MS/ACM")
01312                    && track->codec_priv.size >= 14
01313                    && track->codec_priv.data != NULL) {
01314             init_put_byte(&b, track->codec_priv.data, track->codec_priv.size,
01315                           URL_RDONLY, NULL, NULL, NULL, NULL);
01316             ff_get_wav_header(&b, st->codec, track->codec_priv.size);
01317             codec_id = st->codec->codec_id;
01318             extradata_offset = FFMIN(track->codec_priv.size, 18);
01319         } else if (!strcmp(track->codec_id, "V_QUICKTIME")
01320                    && (track->codec_priv.size >= 86)
01321                    && (track->codec_priv.data != NULL)) {
01322             track->video.fourcc = AV_RL32(track->codec_priv.data);
01323             codec_id=ff_codec_get_id(codec_movvideo_tags, track->video.fourcc);
01324         } else if (codec_id == CODEC_ID_PCM_S16BE) {
01325             switch (track->audio.bitdepth) {
01326             case  8:  codec_id = CODEC_ID_PCM_U8;     break;
01327             case 24:  codec_id = CODEC_ID_PCM_S24BE;  break;
01328             case 32:  codec_id = CODEC_ID_PCM_S32BE;  break;
01329             }
01330         } else if (codec_id == CODEC_ID_PCM_S16LE) {
01331             switch (track->audio.bitdepth) {
01332             case  8:  codec_id = CODEC_ID_PCM_U8;     break;
01333             case 24:  codec_id = CODEC_ID_PCM_S24LE;  break;
01334             case 32:  codec_id = CODEC_ID_PCM_S32LE;  break;
01335             }
01336         } else if (codec_id==CODEC_ID_PCM_F32LE && track->audio.bitdepth==64) {
01337             codec_id = CODEC_ID_PCM_F64LE;
01338         } else if (codec_id == CODEC_ID_AAC && !track->codec_priv.size) {
01339             int profile = matroska_aac_profile(track->codec_id);
01340             int sri = matroska_aac_sri(track->audio.samplerate);
01341             extradata = av_malloc(5);
01342             if (extradata == NULL)
01343                 return AVERROR(ENOMEM);
01344             extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
01345             extradata[1] = ((sri&0x01) << 7) | (track->audio.channels<<3);
01346             if (strstr(track->codec_id, "SBR")) {
01347                 sri = matroska_aac_sri(track->audio.out_samplerate);
01348                 extradata[2] = 0x56;
01349                 extradata[3] = 0xE5;
01350                 extradata[4] = 0x80 | (sri<<3);
01351                 extradata_size = 5;
01352             } else
01353                 extradata_size = 2;
01354         } else if (codec_id == CODEC_ID_TTA) {
01355             extradata_size = 30;
01356             extradata = av_mallocz(extradata_size);
01357             if (extradata == NULL)
01358                 return AVERROR(ENOMEM);
01359             init_put_byte(&b, extradata, extradata_size, 1,
01360                           NULL, NULL, NULL, NULL);
01361             put_buffer(&b, "TTA1", 4);
01362             put_le16(&b, 1);
01363             put_le16(&b, track->audio.channels);
01364             put_le16(&b, track->audio.bitdepth);
01365             put_le32(&b, track->audio.out_samplerate);
01366             put_le32(&b, matroska->ctx->duration * track->audio.out_samplerate);
01367         } else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
01368                    codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
01369             extradata_offset = 26;
01370         } else if (codec_id == CODEC_ID_RA_144) {
01371             track->audio.out_samplerate = 8000;
01372             track->audio.channels = 1;
01373         } else if (codec_id == CODEC_ID_RA_288 || codec_id == CODEC_ID_COOK ||
01374                    codec_id == CODEC_ID_ATRAC3 || codec_id == CODEC_ID_SIPR) {
01375             int flavor;
01376             init_put_byte(&b, track->codec_priv.data,track->codec_priv.size,
01377                           0, NULL, NULL, NULL, NULL);
01378             url_fskip(&b, 22);
01379             flavor                       = get_be16(&b);
01380             track->audio.coded_framesize = get_be32(&b);
01381             url_fskip(&b, 12);
01382             track->audio.sub_packet_h    = get_be16(&b);
01383             track->audio.frame_size      = get_be16(&b);
01384             track->audio.sub_packet_size = get_be16(&b);
01385             track->audio.buf = av_malloc(track->audio.frame_size * track->audio.sub_packet_h);
01386             if (codec_id == CODEC_ID_RA_288) {
01387                 st->codec->block_align = track->audio.coded_framesize;
01388                 track->codec_priv.size = 0;
01389             } else {
01390                 if (codec_id == CODEC_ID_SIPR && flavor < 4) {
01391                     const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
01392                     track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
01393                     st->codec->bit_rate = sipr_bit_rate[flavor];
01394                 }
01395                 st->codec->block_align = track->audio.sub_packet_size;
01396                 extradata_offset = 78;
01397             }
01398         }
01399         track->codec_priv.size -= extradata_offset;
01400 
01401         if (codec_id == CODEC_ID_NONE)
01402             av_log(matroska->ctx, AV_LOG_INFO,
01403                    "Unknown/unsupported CodecID %s.\n", track->codec_id);
01404 
01405         if (track->time_scale < 0.01)
01406             track->time_scale = 1.0;
01407         av_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
01408 
01409         st->codec->codec_id = codec_id;
01410         st->start_time = 0;
01411         if (strcmp(track->language, "und"))
01412             av_metadata_set2(&st->metadata, "language", track->language, 0);
01413         av_metadata_set2(&st->metadata, "title", track->name, 0);
01414 
01415         if (track->flag_default)
01416             st->disposition |= AV_DISPOSITION_DEFAULT;
01417         if (track->flag_forced)
01418             st->disposition |= AV_DISPOSITION_FORCED;
01419 
01420         if (track->default_duration)
01421             av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
01422                       track->default_duration, 1000000000, 30000);
01423 
01424         if (!st->codec->extradata) {
01425             if(extradata){
01426                 st->codec->extradata = extradata;
01427                 st->codec->extradata_size = extradata_size;
01428             } else if(track->codec_priv.data && track->codec_priv.size > 0){
01429                 st->codec->extradata = av_mallocz(track->codec_priv.size +
01430                                                   FF_INPUT_BUFFER_PADDING_SIZE);
01431                 if(st->codec->extradata == NULL)
01432                     return AVERROR(ENOMEM);
01433                 st->codec->extradata_size = track->codec_priv.size;
01434                 memcpy(st->codec->extradata,
01435                        track->codec_priv.data + extradata_offset,
01436                        track->codec_priv.size);
01437             }
01438         }
01439 
01440         if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
01441             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
01442             st->codec->codec_tag  = track->video.fourcc;
01443             st->codec->width  = track->video.pixel_width;
01444             st->codec->height = track->video.pixel_height;
01445             av_reduce(&st->sample_aspect_ratio.num,
01446                       &st->sample_aspect_ratio.den,
01447                       st->codec->height * track->video.display_width,
01448                       st->codec-> width * track->video.display_height,
01449                       255);
01450             if (st->codec->codec_id != CODEC_ID_H264)
01451             st->need_parsing = AVSTREAM_PARSE_HEADERS;
01452             if (track->default_duration)
01453                 st->avg_frame_rate = av_d2q(1000000000.0/track->default_duration, INT_MAX);
01454         } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
01455             st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
01456             st->codec->sample_rate = track->audio.out_samplerate;
01457             st->codec->channels = track->audio.channels;
01458             if (st->codec->codec_id != CODEC_ID_AAC)
01459             st->need_parsing = AVSTREAM_PARSE_HEADERS;
01460         } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
01461             st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
01462         }
01463     }
01464 
01465     attachements = attachements_list->elem;
01466     for (j=0; j<attachements_list->nb_elem; j++) {
01467         if (!(attachements[j].filename && attachements[j].mime &&
01468               attachements[j].bin.data && attachements[j].bin.size > 0)) {
01469             av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
01470         } else {
01471             AVStream *st = av_new_stream(s, 0);
01472             if (st == NULL)
01473                 break;
01474             av_metadata_set2(&st->metadata, "filename",attachements[j].filename, 0);
01475             st->codec->codec_id = CODEC_ID_NONE;
01476             st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
01477             st->codec->extradata  = av_malloc(attachements[j].bin.size);
01478             if(st->codec->extradata == NULL)
01479                 break;
01480             st->codec->extradata_size = attachements[j].bin.size;
01481             memcpy(st->codec->extradata, attachements[j].bin.data, attachements[j].bin.size);
01482 
01483             for (i=0; ff_mkv_mime_tags[i].id != CODEC_ID_NONE; i++) {
01484                 if (!strncmp(ff_mkv_mime_tags[i].str, attachements[j].mime,
01485                              strlen(ff_mkv_mime_tags[i].str))) {
01486                     st->codec->codec_id = ff_mkv_mime_tags[i].id;
01487                     break;
01488                 }
01489             }
01490             attachements[j].stream = st;
01491         }
01492     }
01493 
01494     chapters = chapters_list->elem;
01495     for (i=0; i<chapters_list->nb_elem; i++)
01496         if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid
01497             && (max_start==0 || chapters[i].start > max_start)) {
01498             chapters[i].chapter =
01499             ff_new_chapter(s, chapters[i].uid, (AVRational){1, 1000000000},
01500                            chapters[i].start, chapters[i].end,
01501                            chapters[i].title);
01502             av_metadata_set2(&chapters[i].chapter->metadata,
01503                              "title", chapters[i].title, 0);
01504             max_start = chapters[i].start;
01505         }
01506 
01507     index_list = &matroska->index;
01508     index = index_list->elem;
01509     if (index_list->nb_elem
01510         && index[0].time > 100000000000000/matroska->time_scale) {
01511         av_log(matroska->ctx, AV_LOG_WARNING, "Working around broken index.\n");
01512         index_scale = matroska->time_scale;
01513     }
01514     for (i=0; i<index_list->nb_elem; i++) {
01515         EbmlList *pos_list = &index[i].pos;
01516         MatroskaIndexPos *pos = pos_list->elem;
01517         for (j=0; j<pos_list->nb_elem; j++) {
01518             MatroskaTrack *track = matroska_find_track_by_num(matroska,
01519                                                               pos[j].track);
01520             if (track && track->stream)
01521                 av_add_index_entry(track->stream,
01522                                    pos[j].pos + matroska->segment_start,
01523                                    index[i].time/index_scale, 0, 0,
01524                                    AVINDEX_KEYFRAME);
01525         }
01526     }
01527 
01528     matroska_convert_tags(s);
01529 
01530     return 0;
01531 }
01532 
01533 /*
01534  * Put one packet in an application-supplied AVPacket struct.
01535  * Returns 0 on success or -1 on failure.
01536  */
01537 static int matroska_deliver_packet(MatroskaDemuxContext *matroska,
01538                                    AVPacket *pkt)
01539 {
01540     if (matroska->num_packets > 0) {
01541         memcpy(pkt, matroska->packets[0], sizeof(AVPacket));
01542         av_free(matroska->packets[0]);
01543         if (matroska->num_packets > 1) {
01544             memmove(&matroska->packets[0], &matroska->packets[1],
01545                     (matroska->num_packets - 1) * sizeof(AVPacket *));
01546             matroska->packets =
01547                 av_realloc(matroska->packets, (matroska->num_packets - 1) *
01548                            sizeof(AVPacket *));
01549         } else {
01550             av_freep(&matroska->packets);
01551         }
01552         matroska->num_packets--;
01553         return 0;
01554     }
01555 
01556     return -1;
01557 }
01558 
01559 /*
01560  * Free all packets in our internal queue.
01561  */
01562 static void matroska_clear_queue(MatroskaDemuxContext *matroska)
01563 {
01564     if (matroska->packets) {
01565         int n;
01566         for (n = 0; n < matroska->num_packets; n++) {
01567             av_free_packet(matroska->packets[n]);
01568             av_free(matroska->packets[n]);
01569         }
01570         av_freep(&matroska->packets);
01571         matroska->num_packets = 0;
01572     }
01573 }
01574 
01575 static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
01576                                 int size, int64_t pos, uint64_t cluster_time,
01577                                 uint64_t duration, int is_keyframe,
01578                                 int64_t cluster_pos)
01579 {
01580     uint64_t timecode = AV_NOPTS_VALUE;
01581     MatroskaTrack *track;
01582     int res = 0;
01583     AVStream *st;
01584     AVPacket *pkt;
01585     int16_t block_time;
01586     uint32_t *lace_size = NULL;
01587     int n, flags, laces = 0;
01588     uint64_t num;
01589 
01590     if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
01591         av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
01592         return res;
01593     }
01594     data += n;
01595     size -= n;
01596 
01597     track = matroska_find_track_by_num(matroska, num);
01598     if (size <= 3 || !track || !track->stream) {
01599         av_log(matroska->ctx, AV_LOG_INFO,
01600                "Invalid stream %"PRIu64" or size %u\n", num, size);
01601         return res;
01602     }
01603     st = track->stream;
01604     if (st->discard >= AVDISCARD_ALL)
01605         return res;
01606     if (duration == AV_NOPTS_VALUE)
01607         duration = track->default_duration / matroska->time_scale;
01608 
01609     block_time = AV_RB16(data);
01610     data += 2;
01611     flags = *data++;
01612     size -= 3;
01613     if (is_keyframe == -1)
01614         is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
01615 
01616     if (cluster_time != (uint64_t)-1
01617         && (block_time >= 0 || cluster_time >= -block_time)) {
01618         timecode = cluster_time + block_time;
01619         if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE
01620             && timecode < track->end_timecode)
01621             is_keyframe = 0;  /* overlapping subtitles are not key frame */
01622         if (is_keyframe)
01623             av_add_index_entry(st, cluster_pos, timecode, 0,0,AVINDEX_KEYFRAME);
01624         track->end_timecode = FFMAX(track->end_timecode, timecode+duration);
01625     }
01626 
01627     if (matroska->skip_to_keyframe && track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
01628         if (!is_keyframe || timecode < matroska->skip_to_timecode)
01629             return res;
01630         matroska->skip_to_keyframe = 0;
01631     }
01632 
01633     switch ((flags & 0x06) >> 1) {
01634         case 0x0: /* no lacing */
01635             laces = 1;
01636             lace_size = av_mallocz(sizeof(int));
01637             lace_size[0] = size;
01638             break;
01639 
01640         case 0x1: /* Xiph lacing */
01641         case 0x2: /* fixed-size lacing */
01642         case 0x3: /* EBML lacing */
01643             assert(size>0); // size <=3 is checked before size-=3 above
01644             laces = (*data) + 1;
01645             data += 1;
01646             size -= 1;
01647             lace_size = av_mallocz(laces * sizeof(int));
01648 
01649             switch ((flags & 0x06) >> 1) {
01650                 case 0x1: /* Xiph lacing */ {
01651                     uint8_t temp;
01652                     uint32_t total = 0;
01653                     for (n = 0; res == 0 && n < laces - 1; n++) {
01654                         while (1) {
01655                             if (size == 0) {
01656                                 res = -1;
01657                                 break;
01658                             }
01659                             temp = *data;
01660                             lace_size[n] += temp;
01661                             data += 1;
01662                             size -= 1;
01663                             if (temp != 0xff)
01664                                 break;
01665                         }
01666                         total += lace_size[n];
01667                     }
01668                     lace_size[n] = size - total;
01669                     break;
01670                 }
01671 
01672                 case 0x2: /* fixed-size lacing */
01673                     for (n = 0; n < laces; n++)
01674                         lace_size[n] = size / laces;
01675                     break;
01676 
01677                 case 0x3: /* EBML lacing */ {
01678                     uint32_t total;
01679                     n = matroska_ebmlnum_uint(matroska, data, size, &num);
01680                     if (n < 0) {
01681                         av_log(matroska->ctx, AV_LOG_INFO,
01682                                "EBML block data error\n");
01683                         break;
01684                     }
01685                     data += n;
01686                     size -= n;
01687                     total = lace_size[0] = num;
01688                     for (n = 1; res == 0 && n < laces - 1; n++) {
01689                         int64_t snum;
01690                         int r;
01691                         r = matroska_ebmlnum_sint(matroska, data, size, &snum);
01692                         if (r < 0) {
01693                             av_log(matroska->ctx, AV_LOG_INFO,
01694                                    "EBML block data error\n");
01695                             break;
01696                         }
01697                         data += r;
01698                         size -= r;
01699                         lace_size[n] = lace_size[n - 1] + snum;
01700                         total += lace_size[n];
01701                     }
01702                     lace_size[n] = size - total;
01703                     break;
01704                 }
01705             }
01706             break;
01707     }
01708 
01709     if (res == 0) {
01710         for (n = 0; n < laces; n++) {
01711             if ((st->codec->codec_id == CODEC_ID_RA_288 ||
01712                  st->codec->codec_id == CODEC_ID_COOK ||
01713                  st->codec->codec_id == CODEC_ID_SIPR ||
01714                  st->codec->codec_id == CODEC_ID_ATRAC3) &&
01715                  st->codec->block_align && track->audio.sub_packet_size) {
01716                 int a = st->codec->block_align;
01717                 int sps = track->audio.sub_packet_size;
01718                 int cfs = track->audio.coded_framesize;
01719                 int h = track->audio.sub_packet_h;
01720                 int y = track->audio.sub_packet_cnt;
01721                 int w = track->audio.frame_size;
01722                 int x;
01723 
01724                 if (!track->audio.pkt_cnt) {
01725                     if (st->codec->codec_id == CODEC_ID_RA_288)
01726                         for (x=0; x<h/2; x++)
01727                             memcpy(track->audio.buf+x*2*w+y*cfs,
01728                                    data+x*cfs, cfs);
01729                     else if (st->codec->codec_id == CODEC_ID_SIPR)
01730                         memcpy(track->audio.buf + y*w, data, w);
01731                     else
01732                         for (x=0; x<w/sps; x++)
01733                             memcpy(track->audio.buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps);
01734 
01735                     if (++track->audio.sub_packet_cnt >= h) {
01736                         if (st->codec->codec_id == CODEC_ID_SIPR)
01737                             ff_rm_reorder_sipr_data(track->audio.buf, h, w);
01738                         track->audio.sub_packet_cnt = 0;
01739                         track->audio.pkt_cnt = h*w / a;
01740                     }
01741                 }
01742                 while (track->audio.pkt_cnt) {
01743                     pkt = av_mallocz(sizeof(AVPacket));
01744                     av_new_packet(pkt, a);
01745                     memcpy(pkt->data, track->audio.buf
01746                            + a * (h*w / a - track->audio.pkt_cnt--), a);
01747                     pkt->pos = pos;
01748                     pkt->stream_index = st->index;
01749                     dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
01750                 }
01751             } else {
01752                 MatroskaTrackEncoding *encodings = track->encodings.elem;
01753                 int offset = 0, pkt_size = lace_size[n];
01754                 uint8_t *pkt_data = data;
01755 
01756                 if (pkt_size > size) {
01757                     av_log(matroska->ctx, AV_LOG_ERROR, "Invalid packet size\n");
01758                     break;
01759                 }
01760 
01761                 if (encodings && encodings->scope & 1) {
01762                     offset = matroska_decode_buffer(&pkt_data,&pkt_size, track);
01763                     if (offset < 0)
01764                         continue;
01765                 }
01766 
01767                 pkt = av_mallocz(sizeof(AVPacket));
01768                 /* XXX: prevent data copy... */
01769                 if (av_new_packet(pkt, pkt_size+offset) < 0) {
01770                     av_free(pkt);
01771                     res = AVERROR(ENOMEM);
01772                     break;
01773                 }
01774                 if (offset)
01775                     memcpy (pkt->data, encodings->compression.settings.data, offset);
01776                 memcpy (pkt->data+offset, pkt_data, pkt_size);
01777 
01778                 if (pkt_data != data)
01779                     av_free(pkt_data);
01780 
01781                 if (n == 0)
01782                     pkt->flags = is_keyframe;
01783                 pkt->stream_index = st->index;
01784 
01785                 if (track->ms_compat)
01786                     pkt->dts = timecode;
01787                 else
01788                     pkt->pts = timecode;
01789                 pkt->pos = pos;
01790                 if (st->codec->codec_id == CODEC_ID_TEXT)
01791                     pkt->convergence_duration = duration;
01792                 else if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE)
01793                     pkt->duration = duration;
01794 
01795                 if (st->codec->codec_id == CODEC_ID_SSA)
01796                     matroska_fix_ass_packet(matroska, pkt, duration);
01797 
01798                 if (matroska->prev_pkt &&
01799                     timecode != AV_NOPTS_VALUE &&
01800                     matroska->prev_pkt->pts == timecode &&
01801                     matroska->prev_pkt->stream_index == st->index &&
01802                     st->codec->codec_id == CODEC_ID_SSA)
01803                     matroska_merge_packets(matroska->prev_pkt, pkt);
01804                 else {
01805                     dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
01806                     matroska->prev_pkt = pkt;
01807                 }
01808             }
01809 
01810             if (timecode != AV_NOPTS_VALUE)
01811                 timecode = duration ? timecode + duration : AV_NOPTS_VALUE;
01812             data += lace_size[n];
01813             size -= lace_size[n];
01814         }
01815     }
01816 
01817     av_free(lace_size);
01818     return res;
01819 }
01820 
01821 static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
01822 {
01823     MatroskaCluster cluster = { 0 };
01824     EbmlList *blocks_list;
01825     MatroskaBlock *blocks;
01826     int i, res;
01827     int64_t pos = url_ftell(matroska->ctx->pb);
01828     matroska->prev_pkt = NULL;
01829     if (matroska->current_id)
01830         pos -= 4;  /* sizeof the ID which was already read */
01831     res = ebml_parse(matroska, matroska_clusters, &cluster);
01832     blocks_list = &cluster.blocks;
01833     blocks = blocks_list->elem;
01834     for (i=0; i<blocks_list->nb_elem; i++)
01835         if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
01836             int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
01837             res=matroska_parse_block(matroska,
01838                                      blocks[i].bin.data, blocks[i].bin.size,
01839                                      blocks[i].bin.pos,  cluster.timecode,
01840                                      blocks[i].duration, is_keyframe,
01841                                      pos);
01842         }
01843     ebml_free(matroska_cluster, &cluster);
01844     if (res < 0)  matroska->done = 1;
01845     return res;
01846 }
01847 
01848 static int matroska_read_packet(AVFormatContext *s, AVPacket *pkt)
01849 {
01850     MatroskaDemuxContext *matroska = s->priv_data;
01851 
01852     while (matroska_deliver_packet(matroska, pkt)) {
01853         if (matroska->done)
01854             return AVERROR_EOF;
01855         matroska_parse_cluster(matroska);
01856     }
01857 
01858     return 0;
01859 }
01860 
01861 static int matroska_read_seek(AVFormatContext *s, int stream_index,
01862                               int64_t timestamp, int flags)
01863 {
01864     MatroskaDemuxContext *matroska = s->priv_data;
01865     MatroskaTrack *tracks = matroska->tracks.elem;
01866     AVStream *st = s->streams[stream_index];
01867     int i, index, index_sub, index_min;
01868 
01869     if (!st->nb_index_entries)
01870         return 0;
01871     timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
01872 
01873     if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
01874         url_fseek(s->pb, st->index_entries[st->nb_index_entries-1].pos, SEEK_SET);
01875         while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
01876             matroska_clear_queue(matroska);
01877             if (matroska_parse_cluster(matroska) < 0)
01878                 break;
01879         }
01880     }
01881 
01882     matroska_clear_queue(matroska);
01883     if (index < 0)
01884         return 0;
01885 
01886     index_min = index;
01887     for (i=0; i < matroska->tracks.nb_elem; i++) {
01888         tracks[i].end_timecode = 0;
01889         if (tracks[i].type == MATROSKA_TRACK_TYPE_SUBTITLE
01890             && !tracks[i].stream->discard != AVDISCARD_ALL) {
01891             index_sub = av_index_search_timestamp(tracks[i].stream, st->index_entries[index].timestamp, AVSEEK_FLAG_BACKWARD);
01892             if (index_sub >= 0
01893                 && st->index_entries[index_sub].pos < st->index_entries[index_min].pos
01894                 && st->index_entries[index].timestamp - st->index_entries[index_sub].timestamp < 30000000000/matroska->time_scale)
01895                 index_min = index_sub;
01896         }
01897     }
01898 
01899     url_fseek(s->pb, st->index_entries[index_min].pos, SEEK_SET);
01900     matroska->skip_to_keyframe = !(flags & AVSEEK_FLAG_ANY);
01901     matroska->skip_to_timecode = st->index_entries[index].timestamp;
01902     matroska->done = 0;
01903     av_update_cur_dts(s, st, st->index_entries[index].timestamp);
01904     return 0;
01905 }
01906 
01907 static int matroska_read_close(AVFormatContext *s)
01908 {
01909     MatroskaDemuxContext *matroska = s->priv_data;
01910     MatroskaTrack *tracks = matroska->tracks.elem;
01911     int n;
01912 
01913     matroska_clear_queue(matroska);
01914 
01915     for (n=0; n < matroska->tracks.nb_elem; n++)
01916         if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
01917             av_free(tracks[n].audio.buf);
01918     ebml_free(matroska_segment, matroska);
01919 
01920     return 0;
01921 }
01922 
01923 AVInputFormat matroska_demuxer = {
01924     "matroska,webm",
01925     NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
01926     sizeof(MatroskaDemuxContext),
01927     matroska_probe,
01928     matroska_read_header,
01929     matroska_read_packet,
01930     matroska_read_close,
01931     matroska_read_seek,
01932 };