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