2 * Matroska file demuxer
3 * Copyright (c) 2003-2008 The FFmpeg Project
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * Matroska file demuxer
25 * @author Ronald Bultje <rbultje@ronald.bitfreak.net>
26 * @author with a little help from Moritz Bunkus <moritz@bunkus.org>
27 * @author totally reworked by Aurelien Jacobs <aurel@gnuage.org>
28 * @see specs available on the Matroska project page: http://www.matroska.org/
42 #include "libavutil/avstring.h"
43 #include "libavutil/base64.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/intfloat.h"
46 #include "libavutil/intreadwrite.h"
47 #include "libavutil/lzo.h"
48 #include "libavutil/mathematics.h"
50 #include "libavcodec/bytestream.h"
51 #include "libavcodec/flac.h"
52 #include "libavcodec/mpeg4audio.h"
55 #include "avio_internal.h"
60 /* For ff_codec_get_id(). */
78 typedef const struct EbmlSyntax
{
87 const struct EbmlSyntax
*n
;
107 uint64_t doctype_version
;
113 } MatroskaTrackCompression
;
118 } MatroskaTrackEncryption
;
123 MatroskaTrackCompression compression
;
124 MatroskaTrackEncryption encryption
;
125 } MatroskaTrackEncoding
;
129 uint64_t display_width
;
130 uint64_t display_height
;
131 uint64_t pixel_width
;
132 uint64_t pixel_height
;
134 uint64_t stereo_mode
;
136 } MatroskaTrackVideo
;
140 double out_samplerate
;
144 /* real audio header (extracted from extradata) */
151 uint64_t buf_timecode
;
153 } MatroskaTrackAudio
;
158 } MatroskaTrackPlane
;
161 EbmlList combine_planes
;
162 } MatroskaTrackOperation
;
173 uint64_t default_duration
;
174 uint64_t flag_default
;
175 uint64_t flag_forced
;
176 uint64_t seek_preroll
;
177 MatroskaTrackVideo video
;
178 MatroskaTrackAudio audio
;
179 MatroskaTrackOperation operation
;
181 uint64_t codec_delay
;
184 int64_t end_timecode
;
186 uint64_t max_block_additional_id
;
196 } MatroskaAttachment
;
234 MatroskaTagTarget target
;
254 AVFormatContext
*ctx
;
258 MatroskaLevel levels
[EBML_MAX_DEPTH
];
268 EbmlList attachments
;
274 /* byte position of the segment inside the stream */
275 int64_t segment_start
;
277 /* the packet queue */
284 /* What to skip before effectively reading a packet. */
285 int skip_to_keyframe
;
286 uint64_t skip_to_timecode
;
288 /* File has a CUES element, but we defer parsing until it is needed. */
289 int cues_parsing_deferred
;
291 int current_cluster_num_blocks
;
292 int64_t current_cluster_pos
;
293 MatroskaCluster current_cluster
;
295 /* File has SSA subtitles which prevent incremental cluster parsing. */
297 } MatroskaDemuxContext
;
304 uint64_t additional_id
;
306 int64_t discard_padding
;
309 static EbmlSyntax ebml_header
[] = {
310 { EBML_ID_EBMLREADVERSION
, EBML_UINT
, 0, offsetof(Ebml
, version
), { .u
= EBML_VERSION
} },
311 { EBML_ID_EBMLMAXSIZELENGTH
, EBML_UINT
, 0, offsetof(Ebml
, max_size
), { .u
= 8 } },
312 { EBML_ID_EBMLMAXIDLENGTH
, EBML_UINT
, 0, offsetof(Ebml
, id_length
), { .u
= 4 } },
313 { EBML_ID_DOCTYPE
, EBML_STR
, 0, offsetof(Ebml
, doctype
), { .s
= "(none)" } },
314 { EBML_ID_DOCTYPEREADVERSION
, EBML_UINT
, 0, offsetof(Ebml
, doctype_version
), { .u
= 1 } },
315 { EBML_ID_EBMLVERSION
, EBML_NONE
},
316 { EBML_ID_DOCTYPEVERSION
, EBML_NONE
},
320 static EbmlSyntax ebml_syntax
[] = {
321 { EBML_ID_HEADER
, EBML_NEST
, 0, 0, { .n
= ebml_header
} },
325 static EbmlSyntax matroska_info
[] = {
326 { MATROSKA_ID_TIMECODESCALE
, EBML_UINT
, 0, offsetof(MatroskaDemuxContext
, time_scale
), { .u
= 1000000 } },
327 { MATROSKA_ID_DURATION
, EBML_FLOAT
, 0, offsetof(MatroskaDemuxContext
, duration
) },
328 { MATROSKA_ID_TITLE
, EBML_UTF8
, 0, offsetof(MatroskaDemuxContext
, title
) },
329 { MATROSKA_ID_WRITINGAPP
, EBML_NONE
},
330 { MATROSKA_ID_MUXINGAPP
, EBML_UTF8
, 0, offsetof(MatroskaDemuxContext
, muxingapp
) },
331 { MATROSKA_ID_DATEUTC
, EBML_BIN
, 0, offsetof(MatroskaDemuxContext
, date_utc
) },
332 { MATROSKA_ID_SEGMENTUID
, EBML_NONE
},
336 static EbmlSyntax matroska_track_video
[] = {
337 { MATROSKA_ID_VIDEOFRAMERATE
, EBML_FLOAT
, 0, offsetof(MatroskaTrackVideo
, frame_rate
) },
338 { MATROSKA_ID_VIDEODISPLAYWIDTH
, EBML_UINT
, 0, offsetof(MatroskaTrackVideo
, display_width
), { .u
=-1 } },
339 { MATROSKA_ID_VIDEODISPLAYHEIGHT
, EBML_UINT
, 0, offsetof(MatroskaTrackVideo
, display_height
), { .u
=-1 } },
340 { MATROSKA_ID_VIDEOPIXELWIDTH
, EBML_UINT
, 0, offsetof(MatroskaTrackVideo
, pixel_width
) },
341 { MATROSKA_ID_VIDEOPIXELHEIGHT
, EBML_UINT
, 0, offsetof(MatroskaTrackVideo
, pixel_height
) },
342 { MATROSKA_ID_VIDEOCOLORSPACE
, EBML_BIN
, 0, offsetof(MatroskaTrackVideo
, color_space
) },
343 { MATROSKA_ID_VIDEOALPHAMODE
, EBML_UINT
, 0, offsetof(MatroskaTrackVideo
, alpha_mode
) },
344 { MATROSKA_ID_VIDEOPIXELCROPB
, EBML_NONE
},
345 { MATROSKA_ID_VIDEOPIXELCROPT
, EBML_NONE
},
346 { MATROSKA_ID_VIDEOPIXELCROPL
, EBML_NONE
},
347 { MATROSKA_ID_VIDEOPIXELCROPR
, EBML_NONE
},
348 { MATROSKA_ID_VIDEODISPLAYUNIT
, EBML_NONE
},
349 { MATROSKA_ID_VIDEOFLAGINTERLACED
, EBML_NONE
},
350 { MATROSKA_ID_VIDEOSTEREOMODE
, EBML_UINT
, 0, offsetof(MatroskaTrackVideo
, stereo_mode
), { .u
= MATROSKA_VIDEO_STEREOMODE_TYPE_NB
} },
351 { MATROSKA_ID_VIDEOASPECTRATIO
, EBML_NONE
},
355 static EbmlSyntax matroska_track_audio
[] = {
356 { MATROSKA_ID_AUDIOSAMPLINGFREQ
, EBML_FLOAT
, 0, offsetof(MatroskaTrackAudio
, samplerate
), { .f
= 8000.0 } },
357 { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
, EBML_FLOAT
, 0, offsetof(MatroskaTrackAudio
, out_samplerate
) },
358 { MATROSKA_ID_AUDIOBITDEPTH
, EBML_UINT
, 0, offsetof(MatroskaTrackAudio
, bitdepth
) },
359 { MATROSKA_ID_AUDIOCHANNELS
, EBML_UINT
, 0, offsetof(MatroskaTrackAudio
, channels
), { .u
= 1 } },
363 static EbmlSyntax matroska_track_encoding_compression
[] = {
364 { MATROSKA_ID_ENCODINGCOMPALGO
, EBML_UINT
, 0, offsetof(MatroskaTrackCompression
, algo
), { .u
= 0 } },
365 { MATROSKA_ID_ENCODINGCOMPSETTINGS
, EBML_BIN
, 0, offsetof(MatroskaTrackCompression
, settings
) },
369 static EbmlSyntax matroska_track_encoding_encryption
[] = {
370 { MATROSKA_ID_ENCODINGENCALGO
, EBML_UINT
, 0, offsetof(MatroskaTrackEncryption
,algo
), {.u
= 0} },
371 { MATROSKA_ID_ENCODINGENCKEYID
, EBML_BIN
, 0, offsetof(MatroskaTrackEncryption
,key_id
) },
372 { MATROSKA_ID_ENCODINGENCAESSETTINGS
, EBML_NONE
},
373 { MATROSKA_ID_ENCODINGSIGALGO
, EBML_NONE
},
374 { MATROSKA_ID_ENCODINGSIGHASHALGO
, EBML_NONE
},
375 { MATROSKA_ID_ENCODINGSIGKEYID
, EBML_NONE
},
376 { MATROSKA_ID_ENCODINGSIGNATURE
, EBML_NONE
},
379 static EbmlSyntax matroska_track_encoding
[] = {
380 { MATROSKA_ID_ENCODINGSCOPE
, EBML_UINT
, 0, offsetof(MatroskaTrackEncoding
, scope
), { .u
= 1 } },
381 { MATROSKA_ID_ENCODINGTYPE
, EBML_UINT
, 0, offsetof(MatroskaTrackEncoding
, type
), { .u
= 0 } },
382 { MATROSKA_ID_ENCODINGCOMPRESSION
, EBML_NEST
, 0, offsetof(MatroskaTrackEncoding
, compression
), { .n
= matroska_track_encoding_compression
} },
383 { MATROSKA_ID_ENCODINGENCRYPTION
, EBML_NEST
, 0, offsetof(MatroskaTrackEncoding
, encryption
), { .n
= matroska_track_encoding_encryption
} },
384 { MATROSKA_ID_ENCODINGORDER
, EBML_NONE
},
388 static EbmlSyntax matroska_track_encodings
[] = {
389 { MATROSKA_ID_TRACKCONTENTENCODING
, EBML_NEST
, sizeof(MatroskaTrackEncoding
), offsetof(MatroskaTrack
, encodings
), { .n
= matroska_track_encoding
} },
393 static EbmlSyntax matroska_track_plane
[] = {
394 { MATROSKA_ID_TRACKPLANEUID
, EBML_UINT
, 0, offsetof(MatroskaTrackPlane
,uid
) },
395 { MATROSKA_ID_TRACKPLANETYPE
, EBML_UINT
, 0, offsetof(MatroskaTrackPlane
,type
) },
399 static EbmlSyntax matroska_track_combine_planes
[] = {
400 { MATROSKA_ID_TRACKPLANE
, EBML_NEST
, sizeof(MatroskaTrackPlane
), offsetof(MatroskaTrackOperation
,combine_planes
), {.n
= matroska_track_plane
} },
404 static EbmlSyntax matroska_track_operation
[] = {
405 { MATROSKA_ID_TRACKCOMBINEPLANES
, EBML_NEST
, 0, 0, {.n
= matroska_track_combine_planes
} },
409 static EbmlSyntax matroska_track
[] = {
410 { MATROSKA_ID_TRACKNUMBER
, EBML_UINT
, 0, offsetof(MatroskaTrack
, num
) },
411 { MATROSKA_ID_TRACKNAME
, EBML_UTF8
, 0, offsetof(MatroskaTrack
, name
) },
412 { MATROSKA_ID_TRACKUID
, EBML_UINT
, 0, offsetof(MatroskaTrack
, uid
) },
413 { MATROSKA_ID_TRACKTYPE
, EBML_UINT
, 0, offsetof(MatroskaTrack
, type
) },
414 { MATROSKA_ID_CODECID
, EBML_STR
, 0, offsetof(MatroskaTrack
, codec_id
) },
415 { MATROSKA_ID_CODECPRIVATE
, EBML_BIN
, 0, offsetof(MatroskaTrack
, codec_priv
) },
416 { MATROSKA_ID_CODECDELAY
, EBML_UINT
, 0, offsetof(MatroskaTrack
, codec_delay
) },
417 { MATROSKA_ID_TRACKLANGUAGE
, EBML_UTF8
, 0, offsetof(MatroskaTrack
, language
), { .s
= "eng" } },
418 { MATROSKA_ID_TRACKDEFAULTDURATION
, EBML_UINT
, 0, offsetof(MatroskaTrack
, default_duration
) },
419 { MATROSKA_ID_TRACKTIMECODESCALE
, EBML_FLOAT
, 0, offsetof(MatroskaTrack
, time_scale
), { .f
= 1.0 } },
420 { MATROSKA_ID_TRACKFLAGDEFAULT
, EBML_UINT
, 0, offsetof(MatroskaTrack
, flag_default
), { .u
= 1 } },
421 { MATROSKA_ID_TRACKFLAGFORCED
, EBML_UINT
, 0, offsetof(MatroskaTrack
, flag_forced
), { .u
= 0 } },
422 { MATROSKA_ID_TRACKVIDEO
, EBML_NEST
, 0, offsetof(MatroskaTrack
, video
), { .n
= matroska_track_video
} },
423 { MATROSKA_ID_TRACKAUDIO
, EBML_NEST
, 0, offsetof(MatroskaTrack
, audio
), { .n
= matroska_track_audio
} },
424 { MATROSKA_ID_TRACKOPERATION
, EBML_NEST
, 0, offsetof(MatroskaTrack
, operation
), { .n
= matroska_track_operation
} },
425 { MATROSKA_ID_TRACKCONTENTENCODINGS
, EBML_NEST
, 0, 0, { .n
= matroska_track_encodings
} },
426 { MATROSKA_ID_TRACKMAXBLKADDID
, EBML_UINT
, 0, offsetof(MatroskaTrack
, max_block_additional_id
) },
427 { MATROSKA_ID_SEEKPREROLL
, EBML_UINT
, 0, offsetof(MatroskaTrack
, seek_preroll
) },
428 { MATROSKA_ID_TRACKFLAGENABLED
, EBML_NONE
},
429 { MATROSKA_ID_TRACKFLAGLACING
, EBML_NONE
},
430 { MATROSKA_ID_CODECNAME
, EBML_NONE
},
431 { MATROSKA_ID_CODECDECODEALL
, EBML_NONE
},
432 { MATROSKA_ID_CODECINFOURL
, EBML_NONE
},
433 { MATROSKA_ID_CODECDOWNLOADURL
, EBML_NONE
},
434 { MATROSKA_ID_TRACKMINCACHE
, EBML_NONE
},
435 { MATROSKA_ID_TRACKMAXCACHE
, EBML_NONE
},
439 static EbmlSyntax matroska_tracks
[] = {
440 { MATROSKA_ID_TRACKENTRY
, EBML_NEST
, sizeof(MatroskaTrack
), offsetof(MatroskaDemuxContext
, tracks
), { .n
= matroska_track
} },
444 static EbmlSyntax matroska_attachment
[] = {
445 { MATROSKA_ID_FILEUID
, EBML_UINT
, 0, offsetof(MatroskaAttachment
, uid
) },
446 { MATROSKA_ID_FILENAME
, EBML_UTF8
, 0, offsetof(MatroskaAttachment
, filename
) },
447 { MATROSKA_ID_FILEMIMETYPE
, EBML_STR
, 0, offsetof(MatroskaAttachment
, mime
) },
448 { MATROSKA_ID_FILEDATA
, EBML_BIN
, 0, offsetof(MatroskaAttachment
, bin
) },
449 { MATROSKA_ID_FILEDESC
, EBML_NONE
},
453 static EbmlSyntax matroska_attachments
[] = {
454 { MATROSKA_ID_ATTACHEDFILE
, EBML_NEST
, sizeof(MatroskaAttachment
), offsetof(MatroskaDemuxContext
, attachments
), { .n
= matroska_attachment
} },
458 static EbmlSyntax matroska_chapter_display
[] = {
459 { MATROSKA_ID_CHAPSTRING
, EBML_UTF8
, 0, offsetof(MatroskaChapter
, title
) },
460 { MATROSKA_ID_CHAPLANG
, EBML_NONE
},
464 static EbmlSyntax matroska_chapter_entry
[] = {
465 { MATROSKA_ID_CHAPTERTIMESTART
, EBML_UINT
, 0, offsetof(MatroskaChapter
, start
), { .u
= AV_NOPTS_VALUE
} },
466 { MATROSKA_ID_CHAPTERTIMEEND
, EBML_UINT
, 0, offsetof(MatroskaChapter
, end
), { .u
= AV_NOPTS_VALUE
} },
467 { MATROSKA_ID_CHAPTERUID
, EBML_UINT
, 0, offsetof(MatroskaChapter
, uid
) },
468 { MATROSKA_ID_CHAPTERDISPLAY
, EBML_NEST
, 0, 0, { .n
= matroska_chapter_display
} },
469 { MATROSKA_ID_CHAPTERFLAGHIDDEN
, EBML_NONE
},
470 { MATROSKA_ID_CHAPTERFLAGENABLED
, EBML_NONE
},
471 { MATROSKA_ID_CHAPTERPHYSEQUIV
, EBML_NONE
},
472 { MATROSKA_ID_CHAPTERATOM
, EBML_NONE
},
476 static EbmlSyntax matroska_chapter
[] = {
477 { MATROSKA_ID_CHAPTERATOM
, EBML_NEST
, sizeof(MatroskaChapter
), offsetof(MatroskaDemuxContext
, chapters
), { .n
= matroska_chapter_entry
} },
478 { MATROSKA_ID_EDITIONUID
, EBML_NONE
},
479 { MATROSKA_ID_EDITIONFLAGHIDDEN
, EBML_NONE
},
480 { MATROSKA_ID_EDITIONFLAGDEFAULT
, EBML_NONE
},
481 { MATROSKA_ID_EDITIONFLAGORDERED
, EBML_NONE
},
485 static EbmlSyntax matroska_chapters
[] = {
486 { MATROSKA_ID_EDITIONENTRY
, EBML_NEST
, 0, 0, { .n
= matroska_chapter
} },
490 static EbmlSyntax matroska_index_pos
[] = {
491 { MATROSKA_ID_CUETRACK
, EBML_UINT
, 0, offsetof(MatroskaIndexPos
, track
) },
492 { MATROSKA_ID_CUECLUSTERPOSITION
, EBML_UINT
, 0, offsetof(MatroskaIndexPos
, pos
) },
493 { MATROSKA_ID_CUERELATIVEPOSITION
,EBML_NONE
},
494 { MATROSKA_ID_CUEDURATION
, EBML_NONE
},
495 { MATROSKA_ID_CUEBLOCKNUMBER
, EBML_NONE
},
499 static EbmlSyntax matroska_index_entry
[] = {
500 { MATROSKA_ID_CUETIME
, EBML_UINT
, 0, offsetof(MatroskaIndex
, time
) },
501 { MATROSKA_ID_CUETRACKPOSITION
, EBML_NEST
, sizeof(MatroskaIndexPos
), offsetof(MatroskaIndex
, pos
), { .n
= matroska_index_pos
} },
505 static EbmlSyntax matroska_index
[] = {
506 { MATROSKA_ID_POINTENTRY
, EBML_NEST
, sizeof(MatroskaIndex
), offsetof(MatroskaDemuxContext
, index
), { .n
= matroska_index_entry
} },
510 static EbmlSyntax matroska_simpletag
[] = {
511 { MATROSKA_ID_TAGNAME
, EBML_UTF8
, 0, offsetof(MatroskaTag
, name
) },
512 { MATROSKA_ID_TAGSTRING
, EBML_UTF8
, 0, offsetof(MatroskaTag
, string
) },
513 { MATROSKA_ID_TAGLANG
, EBML_STR
, 0, offsetof(MatroskaTag
, lang
), { .s
= "und" } },
514 { MATROSKA_ID_TAGDEFAULT
, EBML_UINT
, 0, offsetof(MatroskaTag
, def
) },
515 { MATROSKA_ID_TAGDEFAULT_BUG
, EBML_UINT
, 0, offsetof(MatroskaTag
, def
) },
516 { MATROSKA_ID_SIMPLETAG
, EBML_NEST
, sizeof(MatroskaTag
), offsetof(MatroskaTag
, sub
), { .n
= matroska_simpletag
} },
520 static EbmlSyntax matroska_tagtargets
[] = {
521 { MATROSKA_ID_TAGTARGETS_TYPE
, EBML_STR
, 0, offsetof(MatroskaTagTarget
, type
) },
522 { MATROSKA_ID_TAGTARGETS_TYPEVALUE
, EBML_UINT
, 0, offsetof(MatroskaTagTarget
, typevalue
), { .u
= 50 } },
523 { MATROSKA_ID_TAGTARGETS_TRACKUID
, EBML_UINT
, 0, offsetof(MatroskaTagTarget
, trackuid
) },
524 { MATROSKA_ID_TAGTARGETS_CHAPTERUID
, EBML_UINT
, 0, offsetof(MatroskaTagTarget
, chapteruid
) },
525 { MATROSKA_ID_TAGTARGETS_ATTACHUID
, EBML_UINT
, 0, offsetof(MatroskaTagTarget
, attachuid
) },
529 static EbmlSyntax matroska_tag
[] = {
530 { MATROSKA_ID_SIMPLETAG
, EBML_NEST
, sizeof(MatroskaTag
), offsetof(MatroskaTags
, tag
), { .n
= matroska_simpletag
} },
531 { MATROSKA_ID_TAGTARGETS
, EBML_NEST
, 0, offsetof(MatroskaTags
, target
), { .n
= matroska_tagtargets
} },
535 static EbmlSyntax matroska_tags
[] = {
536 { MATROSKA_ID_TAG
, EBML_NEST
, sizeof(MatroskaTags
), offsetof(MatroskaDemuxContext
, tags
), { .n
= matroska_tag
} },
540 static EbmlSyntax matroska_seekhead_entry
[] = {
541 { MATROSKA_ID_SEEKID
, EBML_UINT
, 0, offsetof(MatroskaSeekhead
, id
) },
542 { MATROSKA_ID_SEEKPOSITION
, EBML_UINT
, 0, offsetof(MatroskaSeekhead
, pos
), { .u
= -1 } },
546 static EbmlSyntax matroska_seekhead
[] = {
547 { MATROSKA_ID_SEEKENTRY
, EBML_NEST
, sizeof(MatroskaSeekhead
), offsetof(MatroskaDemuxContext
, seekhead
), { .n
= matroska_seekhead_entry
} },
551 static EbmlSyntax matroska_segment
[] = {
552 { MATROSKA_ID_INFO
, EBML_NEST
, 0, 0, { .n
= matroska_info
} },
553 { MATROSKA_ID_TRACKS
, EBML_NEST
, 0, 0, { .n
= matroska_tracks
} },
554 { MATROSKA_ID_ATTACHMENTS
, EBML_NEST
, 0, 0, { .n
= matroska_attachments
} },
555 { MATROSKA_ID_CHAPTERS
, EBML_NEST
, 0, 0, { .n
= matroska_chapters
} },
556 { MATROSKA_ID_CUES
, EBML_NEST
, 0, 0, { .n
= matroska_index
} },
557 { MATROSKA_ID_TAGS
, EBML_NEST
, 0, 0, { .n
= matroska_tags
} },
558 { MATROSKA_ID_SEEKHEAD
, EBML_NEST
, 0, 0, { .n
= matroska_seekhead
} },
559 { MATROSKA_ID_CLUSTER
, EBML_STOP
},
563 static EbmlSyntax matroska_segments
[] = {
564 { MATROSKA_ID_SEGMENT
, EBML_NEST
, 0, 0, { .n
= matroska_segment
} },
568 static EbmlSyntax matroska_blockmore
[] = {
569 { MATROSKA_ID_BLOCKADDID
, EBML_UINT
, 0, offsetof(MatroskaBlock
,additional_id
) },
570 { MATROSKA_ID_BLOCKADDITIONAL
, EBML_BIN
, 0, offsetof(MatroskaBlock
,additional
) },
574 static EbmlSyntax matroska_blockadditions
[] = {
575 { MATROSKA_ID_BLOCKMORE
, EBML_NEST
, 0, 0, {.n
= matroska_blockmore
} },
579 static EbmlSyntax matroska_blockgroup
[] = {
580 { MATROSKA_ID_BLOCK
, EBML_BIN
, 0, offsetof(MatroskaBlock
, bin
) },
581 { MATROSKA_ID_BLOCKADDITIONS
, EBML_NEST
, 0, 0, { .n
= matroska_blockadditions
} },
582 { MATROSKA_ID_SIMPLEBLOCK
, EBML_BIN
, 0, offsetof(MatroskaBlock
, bin
) },
583 { MATROSKA_ID_BLOCKDURATION
, EBML_UINT
, 0, offsetof(MatroskaBlock
, duration
) },
584 { MATROSKA_ID_DISCARDPADDING
, EBML_SINT
, 0, offsetof(MatroskaBlock
, discard_padding
) },
585 { MATROSKA_ID_BLOCKREFERENCE
, EBML_SINT
, 0, offsetof(MatroskaBlock
, reference
) },
586 { MATROSKA_ID_CODECSTATE
, EBML_NONE
},
587 { 1, EBML_UINT
, 0, offsetof(MatroskaBlock
, non_simple
), { .u
= 1 } },
591 static EbmlSyntax matroska_cluster
[] = {
592 { MATROSKA_ID_CLUSTERTIMECODE
, EBML_UINT
, 0, offsetof(MatroskaCluster
, timecode
) },
593 { MATROSKA_ID_BLOCKGROUP
, EBML_NEST
, sizeof(MatroskaBlock
), offsetof(MatroskaCluster
, blocks
), { .n
= matroska_blockgroup
} },
594 { MATROSKA_ID_SIMPLEBLOCK
, EBML_PASS
, sizeof(MatroskaBlock
), offsetof(MatroskaCluster
, blocks
), { .n
= matroska_blockgroup
} },
595 { MATROSKA_ID_CLUSTERPOSITION
, EBML_NONE
},
596 { MATROSKA_ID_CLUSTERPREVSIZE
, EBML_NONE
},
600 static EbmlSyntax matroska_clusters
[] = {
601 { MATROSKA_ID_CLUSTER
, EBML_NEST
, 0, 0, { .n
= matroska_cluster
} },
602 { MATROSKA_ID_INFO
, EBML_NONE
},
603 { MATROSKA_ID_CUES
, EBML_NONE
},
604 { MATROSKA_ID_TAGS
, EBML_NONE
},
605 { MATROSKA_ID_SEEKHEAD
, EBML_NONE
},
609 static EbmlSyntax matroska_cluster_incremental_parsing
[] = {
610 { MATROSKA_ID_CLUSTERTIMECODE
, EBML_UINT
, 0, offsetof(MatroskaCluster
, timecode
) },
611 { MATROSKA_ID_BLOCKGROUP
, EBML_NEST
, sizeof(MatroskaBlock
), offsetof(MatroskaCluster
, blocks
), { .n
= matroska_blockgroup
} },
612 { MATROSKA_ID_SIMPLEBLOCK
, EBML_PASS
, sizeof(MatroskaBlock
), offsetof(MatroskaCluster
, blocks
), { .n
= matroska_blockgroup
} },
613 { MATROSKA_ID_CLUSTERPOSITION
, EBML_NONE
},
614 { MATROSKA_ID_CLUSTERPREVSIZE
, EBML_NONE
},
615 { MATROSKA_ID_INFO
, EBML_NONE
},
616 { MATROSKA_ID_CUES
, EBML_NONE
},
617 { MATROSKA_ID_TAGS
, EBML_NONE
},
618 { MATROSKA_ID_SEEKHEAD
, EBML_NONE
},
619 { MATROSKA_ID_CLUSTER
, EBML_STOP
},
623 static EbmlSyntax matroska_cluster_incremental
[] = {
624 { MATROSKA_ID_CLUSTERTIMECODE
, EBML_UINT
, 0, offsetof(MatroskaCluster
, timecode
) },
625 { MATROSKA_ID_BLOCKGROUP
, EBML_STOP
},
626 { MATROSKA_ID_SIMPLEBLOCK
, EBML_STOP
},
627 { MATROSKA_ID_CLUSTERPOSITION
, EBML_NONE
},
628 { MATROSKA_ID_CLUSTERPREVSIZE
, EBML_NONE
},
632 static EbmlSyntax matroska_clusters_incremental
[] = {
633 { MATROSKA_ID_CLUSTER
, EBML_NEST
, 0, 0, { .n
= matroska_cluster_incremental
} },
634 { MATROSKA_ID_INFO
, EBML_NONE
},
635 { MATROSKA_ID_CUES
, EBML_NONE
},
636 { MATROSKA_ID_TAGS
, EBML_NONE
},
637 { MATROSKA_ID_SEEKHEAD
, EBML_NONE
},
641 static const char *const matroska_doctypes
[] = { "matroska", "webm" };
643 static int matroska_resync(MatroskaDemuxContext
*matroska
, int64_t last_pos
)
645 AVIOContext
*pb
= matroska
->ctx
->pb
;
647 matroska
->current_id
= 0;
648 matroska
->num_levels
= 0;
650 /* seek to next position to resync from */
651 if (avio_seek(pb
, last_pos
+ 1, SEEK_SET
) < 0)
656 // try to find a toplevel element
657 while (!avio_feof(pb
)) {
658 if (id
== MATROSKA_ID_INFO
|| id
== MATROSKA_ID_TRACKS
||
659 id
== MATROSKA_ID_CUES
|| id
== MATROSKA_ID_TAGS
||
660 id
== MATROSKA_ID_SEEKHEAD
|| id
== MATROSKA_ID_ATTACHMENTS
||
661 id
== MATROSKA_ID_CLUSTER
|| id
== MATROSKA_ID_CHAPTERS
) {
662 matroska
->current_id
= id
;
665 id
= (id
<< 8) | avio_r8(pb
);
674 * Return: Whether we reached the end of a level in the hierarchy or not.
676 static int ebml_level_end(MatroskaDemuxContext
*matroska
)
678 AVIOContext
*pb
= matroska
->ctx
->pb
;
679 int64_t pos
= avio_tell(pb
);
681 if (matroska
->num_levels
> 0) {
682 MatroskaLevel
*level
= &matroska
->levels
[matroska
->num_levels
- 1];
683 if (pos
- level
->start
>= level
->length
|| matroska
->current_id
) {
684 matroska
->num_levels
--;
692 * Read: an "EBML number", which is defined as a variable-length
693 * array of bytes. The first byte indicates the length by giving a
694 * number of 0-bits followed by a one. The position of the first
695 * "one" bit inside the first byte indicates the length of this
697 * Returns: number of bytes read, < 0 on error
699 static int ebml_read_num(MatroskaDemuxContext
*matroska
, AVIOContext
*pb
,
700 int max_size
, uint64_t *number
)
705 /* The first byte tells us the length in bytes - avio_r8() can normally
706 * return 0, but since that's not a valid first ebmlID byte, we can
707 * use it safely here to catch EOS. */
708 if (!(total
= avio_r8(pb
))) {
709 /* we might encounter EOS here */
710 if (!avio_feof(pb
)) {
711 int64_t pos
= avio_tell(pb
);
712 av_log(matroska
->ctx
, AV_LOG_ERROR
,
713 "Read error at pos. %"PRIu64
" (0x%"PRIx64
")\n",
715 return pb
->error
? pb
->error
: AVERROR(EIO
);
720 /* get the length of the EBML number */
721 read
= 8 - ff_log2_tab
[total
];
722 if (read
> max_size
) {
723 int64_t pos
= avio_tell(pb
) - 1;
724 av_log(matroska
->ctx
, AV_LOG_ERROR
,
725 "Invalid EBML number size tag 0x%02x at pos %"PRIu64
" (0x%"PRIx64
")\n",
726 (uint8_t) total
, pos
, pos
);
727 return AVERROR_INVALIDDATA
;
730 /* read out length */
731 total
^= 1 << ff_log2_tab
[total
];
733 total
= (total
<< 8) | avio_r8(pb
);
741 * Read a EBML length value.
742 * This needs special handling for the "unknown length" case which has multiple
745 static int ebml_read_length(MatroskaDemuxContext
*matroska
, AVIOContext
*pb
,
748 int res
= ebml_read_num(matroska
, pb
, 8, number
);
749 if (res
> 0 && *number
+ 1 == 1ULL << (7 * res
))
750 *number
= 0xffffffffffffffULL
;
755 * Read the next element as an unsigned int.
756 * 0 is success, < 0 is failure.
758 static int ebml_read_uint(AVIOContext
*pb
, int size
, uint64_t *num
)
763 return AVERROR_INVALIDDATA
;
765 /* big-endian ordering; build up number */
768 *num
= (*num
<< 8) | avio_r8(pb
);
774 * Read the next element as a signed int.
775 * 0 is success, < 0 is failure.
777 static int ebml_read_sint(AVIOContext
*pb
, int size
, int64_t *num
)
782 return AVERROR_INVALIDDATA
;
787 *num
= sign_extend(avio_r8(pb
), 8);
789 /* big-endian ordering; build up number */
791 *num
= (*num
<< 8) | avio_r8(pb
);
798 * Read the next element as a float.
799 * 0 is success, < 0 is failure.
801 static int ebml_read_float(AVIOContext
*pb
, int size
, double *num
)
806 *num
= av_int2float(avio_rb32(pb
));
808 *num
= av_int2double(avio_rb64(pb
));
810 return AVERROR_INVALIDDATA
;
816 * Read the next element as an ASCII string.
817 * 0 is success, < 0 is failure.
819 static int ebml_read_ascii(AVIOContext
*pb
, int size
, char **str
)
823 /* EBML strings are usually not 0-terminated, so we allocate one
824 * byte more, read the string and NULL-terminate it ourselves. */
825 if (!(res
= av_malloc(size
+ 1)))
826 return AVERROR(ENOMEM
);
827 if (avio_read(pb
, (uint8_t *) res
, size
) != size
) {
839 * Read the next element as binary data.
840 * 0 is success, < 0 is failure.
842 static int ebml_read_binary(AVIOContext
*pb
, int length
, EbmlBin
*bin
)
844 av_fast_padded_malloc(&bin
->data
, &bin
->size
, length
);
846 return AVERROR(ENOMEM
);
849 bin
->pos
= avio_tell(pb
);
850 if (avio_read(pb
, bin
->data
, length
) != length
) {
851 av_freep(&bin
->data
);
860 * Read the next element, but only the header. The contents
861 * are supposed to be sub-elements which can be read separately.
862 * 0 is success, < 0 is failure.
864 static int ebml_read_master(MatroskaDemuxContext
*matroska
, uint64_t length
)
866 AVIOContext
*pb
= matroska
->ctx
->pb
;
867 MatroskaLevel
*level
;
869 if (matroska
->num_levels
>= EBML_MAX_DEPTH
) {
870 av_log(matroska
->ctx
, AV_LOG_ERROR
,
871 "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH
);
872 return AVERROR(ENOSYS
);
875 level
= &matroska
->levels
[matroska
->num_levels
++];
876 level
->start
= avio_tell(pb
);
877 level
->length
= length
;
883 * Read signed/unsigned "EBML" numbers.
884 * Return: number of bytes processed, < 0 on error
886 static int matroska_ebmlnum_uint(MatroskaDemuxContext
*matroska
,
887 uint8_t *data
, uint32_t size
, uint64_t *num
)
890 ffio_init_context(&pb
, data
, size
, 0, NULL
, NULL
, NULL
, NULL
);
891 return ebml_read_num(matroska
, &pb
, FFMIN(size
, 8), num
);
895 * Same as above, but signed.
897 static int matroska_ebmlnum_sint(MatroskaDemuxContext
*matroska
,
898 uint8_t *data
, uint32_t size
, int64_t *num
)
903 /* read as unsigned number first */
904 if ((res
= matroska_ebmlnum_uint(matroska
, data
, size
, &unum
)) < 0)
907 /* make signed (weird way) */
908 *num
= unum
- ((1LL << (7 * res
- 1)) - 1);
913 static int ebml_parse_elem(MatroskaDemuxContext
*matroska
,
914 EbmlSyntax
*syntax
, void *data
);
916 static int ebml_parse_id(MatroskaDemuxContext
*matroska
, EbmlSyntax
*syntax
,
917 uint32_t id
, void *data
)
920 for (i
= 0; syntax
[i
].id
; i
++)
921 if (id
== syntax
[i
].id
)
923 if (!syntax
[i
].id
&& id
== MATROSKA_ID_CLUSTER
&&
924 matroska
->num_levels
> 0 &&
925 matroska
->levels
[matroska
->num_levels
- 1].length
== 0xffffffffffffff)
926 return 0; // we reached the end of an unknown size cluster
927 if (!syntax
[i
].id
&& id
!= EBML_ID_VOID
&& id
!= EBML_ID_CRC32
) {
928 av_log(matroska
->ctx
, AV_LOG_INFO
, "Unknown entry 0x%"PRIX32
"\n", id
);
929 if (matroska
->ctx
->error_recognition
& AV_EF_EXPLODE
)
930 return AVERROR_INVALIDDATA
;
932 return ebml_parse_elem(matroska
, &syntax
[i
], data
);
935 static int ebml_parse(MatroskaDemuxContext
*matroska
, EbmlSyntax
*syntax
,
938 if (!matroska
->current_id
) {
940 int res
= ebml_read_num(matroska
, matroska
->ctx
->pb
, 4, &id
);
943 matroska
->current_id
= id
| 1 << 7 * res
;
945 return ebml_parse_id(matroska
, syntax
, matroska
->current_id
, data
);
948 static int ebml_parse_nest(MatroskaDemuxContext
*matroska
, EbmlSyntax
*syntax
,
953 for (i
= 0; syntax
[i
].id
; i
++)
954 switch (syntax
[i
].type
) {
956 *(uint64_t *) ((char *) data
+ syntax
[i
].data_offset
) = syntax
[i
].def
.u
;
959 *(double *) ((char *) data
+ syntax
[i
].data_offset
) = syntax
[i
].def
.f
;
963 // the default may be NULL
964 if (syntax
[i
].def
.s
) {
965 uint8_t **dst
= (uint8_t **) ((uint8_t *) data
+ syntax
[i
].data_offset
);
966 *dst
= av_strdup(syntax
[i
].def
.s
);
968 return AVERROR(ENOMEM
);
973 while (!res
&& !ebml_level_end(matroska
))
974 res
= ebml_parse(matroska
, syntax
, data
);
979 static int ebml_parse_elem(MatroskaDemuxContext
*matroska
,
980 EbmlSyntax
*syntax
, void *data
)
982 static const uint64_t max_lengths
[EBML_TYPE_COUNT
] = {
985 // max. 16 MB for strings
986 [EBML_STR
] = 0x1000000,
987 [EBML_UTF8
] = 0x1000000,
988 // max. 256 MB for binary data
989 [EBML_BIN
] = 0x10000000,
990 // no limits for anything else
992 AVIOContext
*pb
= matroska
->ctx
->pb
;
993 uint32_t id
= syntax
->id
;
998 data
= (char *) data
+ syntax
->data_offset
;
999 if (syntax
->list_elem_size
) {
1000 EbmlList
*list
= data
;
1001 newelem
= av_realloc_array(list
->elem
, list
->nb_elem
+ 1, syntax
->list_elem_size
);
1003 return AVERROR(ENOMEM
);
1004 list
->elem
= newelem
;
1005 data
= (char *) list
->elem
+ list
->nb_elem
* syntax
->list_elem_size
;
1006 memset(data
, 0, syntax
->list_elem_size
);
1010 if (syntax
->type
!= EBML_PASS
&& syntax
->type
!= EBML_STOP
) {
1011 matroska
->current_id
= 0;
1012 if ((res
= ebml_read_length(matroska
, pb
, &length
)) < 0)
1014 if (max_lengths
[syntax
->type
] && length
> max_lengths
[syntax
->type
]) {
1015 av_log(matroska
->ctx
, AV_LOG_ERROR
,
1016 "Invalid length 0x%"PRIx64
" > 0x%"PRIx64
" for syntax element %i\n",
1017 length
, max_lengths
[syntax
->type
], syntax
->type
);
1018 return AVERROR_INVALIDDATA
;
1022 switch (syntax
->type
) {
1024 res
= ebml_read_uint(pb
, length
, data
);
1027 res
= ebml_read_sint(pb
, length
, data
);
1030 res
= ebml_read_float(pb
, length
, data
);
1034 res
= ebml_read_ascii(pb
, length
, data
);
1037 res
= ebml_read_binary(pb
, length
, data
);
1040 if ((res
= ebml_read_master(matroska
, length
)) < 0)
1042 if (id
== MATROSKA_ID_SEGMENT
)
1043 matroska
->segment_start
= avio_tell(matroska
->ctx
->pb
);
1044 return ebml_parse_nest(matroska
, syntax
->def
.n
, data
);
1046 return ebml_parse_id(matroska
, syntax
->def
.n
, id
, data
);
1050 if (ffio_limit(pb
, length
) != length
)
1051 return AVERROR(EIO
);
1052 return avio_skip(pb
, length
) < 0 ? AVERROR(EIO
) : 0;
1054 if (res
== AVERROR_INVALIDDATA
)
1055 av_log(matroska
->ctx
, AV_LOG_ERROR
, "Invalid element\n");
1056 else if (res
== AVERROR(EIO
))
1057 av_log(matroska
->ctx
, AV_LOG_ERROR
, "Read error\n");
1061 static void ebml_free(EbmlSyntax
*syntax
, void *data
)
1064 for (i
= 0; syntax
[i
].id
; i
++) {
1065 void *data_off
= (char *) data
+ syntax
[i
].data_offset
;
1066 switch (syntax
[i
].type
) {
1072 av_freep(&((EbmlBin
*) data_off
)->data
);
1075 if (syntax
[i
].list_elem_size
) {
1076 EbmlList
*list
= data_off
;
1077 char *ptr
= list
->elem
;
1078 for (j
= 0; j
< list
->nb_elem
;
1079 j
++, ptr
+= syntax
[i
].list_elem_size
)
1080 ebml_free(syntax
[i
].def
.n
, ptr
);
1081 av_free(list
->elem
);
1083 ebml_free(syntax
[i
].def
.n
, data_off
);
1093 static int matroska_probe(AVProbeData
*p
)
1096 int len_mask
= 0x80, size
= 1, n
= 1, i
;
1099 if (AV_RB32(p
->buf
) != EBML_ID_HEADER
)
1102 /* length of header */
1104 while (size
<= 8 && !(total
& len_mask
)) {
1110 total
&= (len_mask
- 1);
1112 total
= (total
<< 8) | p
->buf
[4 + n
++];
1114 /* Does the probe data contain the whole header? */
1115 if (p
->buf_size
< 4 + size
+ total
)
1118 /* The header should contain a known document type. For now,
1119 * we don't parse the whole header but simply check for the
1120 * availability of that array of characters inside the header.
1121 * Not fully fool-proof, but good enough. */
1122 for (i
= 0; i
< FF_ARRAY_ELEMS(matroska_doctypes
); i
++) {
1123 int probelen
= strlen(matroska_doctypes
[i
]);
1124 if (total
< probelen
)
1126 for (n
= 4 + size
; n
<= 4 + size
+ total
- probelen
; n
++)
1127 if (!memcmp(p
->buf
+ n
, matroska_doctypes
[i
], probelen
))
1128 return AVPROBE_SCORE_MAX
;
1131 // probably valid EBML header but no recognized doctype
1132 return AVPROBE_SCORE_EXTENSION
;
1135 static MatroskaTrack
*matroska_find_track_by_num(MatroskaDemuxContext
*matroska
,
1138 MatroskaTrack
*tracks
= matroska
->tracks
.elem
;
1141 for (i
= 0; i
< matroska
->tracks
.nb_elem
; i
++)
1142 if (tracks
[i
].num
== num
)
1145 av_log(matroska
->ctx
, AV_LOG_ERROR
, "Invalid track number %d\n", num
);
1149 static int matroska_decode_buffer(uint8_t **buf
, int *buf_size
,
1150 MatroskaTrack
*track
)
1152 MatroskaTrackEncoding
*encodings
= track
->encodings
.elem
;
1153 uint8_t *data
= *buf
;
1154 int isize
= *buf_size
;
1155 uint8_t *pkt_data
= NULL
;
1156 uint8_t av_unused
*newpktdata
;
1157 int pkt_size
= isize
;
1161 if (pkt_size
>= 10000000U)
1162 return AVERROR_INVALIDDATA
;
1164 switch (encodings
[0].compression
.algo
) {
1165 case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP
:
1167 int header_size
= encodings
[0].compression
.settings
.size
;
1168 uint8_t *header
= encodings
[0].compression
.settings
.data
;
1170 if (header_size
&& !header
) {
1171 av_log(NULL
, AV_LOG_ERROR
, "Compression size but no data in headerstrip\n");
1178 pkt_size
= isize
+ header_size
;
1179 pkt_data
= av_malloc(pkt_size
);
1181 return AVERROR(ENOMEM
);
1183 memcpy(pkt_data
, header
, header_size
);
1184 memcpy(pkt_data
+ header_size
, data
, isize
);
1188 case MATROSKA_TRACK_ENCODING_COMP_LZO
:
1190 olen
= pkt_size
*= 3;
1191 newpktdata
= av_realloc(pkt_data
, pkt_size
+ AV_LZO_OUTPUT_PADDING
);
1193 result
= AVERROR(ENOMEM
);
1196 pkt_data
= newpktdata
;
1197 result
= av_lzo1x_decode(pkt_data
, &olen
, data
, &isize
);
1198 } while (result
== AV_LZO_OUTPUT_FULL
&& pkt_size
< 10000000);
1200 result
= AVERROR_INVALIDDATA
;
1207 case MATROSKA_TRACK_ENCODING_COMP_ZLIB
:
1209 z_stream zstream
= { 0 };
1210 if (inflateInit(&zstream
) != Z_OK
)
1212 zstream
.next_in
= data
;
1213 zstream
.avail_in
= isize
;
1216 newpktdata
= av_realloc(pkt_data
, pkt_size
);
1218 inflateEnd(&zstream
);
1221 pkt_data
= newpktdata
;
1222 zstream
.avail_out
= pkt_size
- zstream
.total_out
;
1223 zstream
.next_out
= pkt_data
+ zstream
.total_out
;
1225 result
= inflate(&zstream
, Z_NO_FLUSH
);
1227 result
= Z_MEM_ERROR
;
1228 } while (result
== Z_OK
&& pkt_size
< 10000000);
1229 pkt_size
= zstream
.total_out
;
1230 inflateEnd(&zstream
);
1231 if (result
!= Z_STREAM_END
) {
1232 if (result
== Z_MEM_ERROR
)
1233 result
= AVERROR(ENOMEM
);
1235 result
= AVERROR_INVALIDDATA
;
1242 case MATROSKA_TRACK_ENCODING_COMP_BZLIB
:
1244 bz_stream bzstream
= { 0 };
1245 if (BZ2_bzDecompressInit(&bzstream
, 0, 0) != BZ_OK
)
1247 bzstream
.next_in
= data
;
1248 bzstream
.avail_in
= isize
;
1251 newpktdata
= av_realloc(pkt_data
, pkt_size
);
1253 BZ2_bzDecompressEnd(&bzstream
);
1256 pkt_data
= newpktdata
;
1257 bzstream
.avail_out
= pkt_size
- bzstream
.total_out_lo32
;
1258 bzstream
.next_out
= pkt_data
+ bzstream
.total_out_lo32
;
1260 result
= BZ2_bzDecompress(&bzstream
);
1262 result
= BZ_MEM_ERROR
;
1263 } while (result
== BZ_OK
&& pkt_size
< 10000000);
1264 pkt_size
= bzstream
.total_out_lo32
;
1265 BZ2_bzDecompressEnd(&bzstream
);
1266 if (result
!= BZ_STREAM_END
) {
1267 if (result
== BZ_MEM_ERROR
)
1268 result
= AVERROR(ENOMEM
);
1270 result
= AVERROR_INVALIDDATA
;
1277 return AVERROR_INVALIDDATA
;
1281 *buf_size
= pkt_size
;
1289 static void matroska_convert_tag(AVFormatContext
*s
, EbmlList
*list
,
1290 AVDictionary
**metadata
, char *prefix
)
1292 MatroskaTag
*tags
= list
->elem
;
1296 for (i
= 0; i
< list
->nb_elem
; i
++) {
1297 const char *lang
= tags
[i
].lang
&&
1298 strcmp(tags
[i
].lang
, "und") ? tags
[i
].lang
: NULL
;
1300 if (!tags
[i
].name
) {
1301 av_log(s
, AV_LOG_WARNING
, "Skipping invalid tag with no TagName.\n");
1305 snprintf(key
, sizeof(key
), "%s/%s", prefix
, tags
[i
].name
);
1307 av_strlcpy(key
, tags
[i
].name
, sizeof(key
));
1308 if (tags
[i
].def
|| !lang
) {
1309 av_dict_set(metadata
, key
, tags
[i
].string
, 0);
1310 if (tags
[i
].sub
.nb_elem
)
1311 matroska_convert_tag(s
, &tags
[i
].sub
, metadata
, key
);
1314 av_strlcat(key
, "-", sizeof(key
));
1315 av_strlcat(key
, lang
, sizeof(key
));
1316 av_dict_set(metadata
, key
, tags
[i
].string
, 0);
1317 if (tags
[i
].sub
.nb_elem
)
1318 matroska_convert_tag(s
, &tags
[i
].sub
, metadata
, key
);
1321 ff_metadata_conv(metadata
, NULL
, ff_mkv_metadata_conv
);
1324 static void matroska_convert_tags(AVFormatContext
*s
)
1326 MatroskaDemuxContext
*matroska
= s
->priv_data
;
1327 MatroskaTags
*tags
= matroska
->tags
.elem
;
1330 for (i
= 0; i
< matroska
->tags
.nb_elem
; i
++) {
1331 if (tags
[i
].target
.attachuid
) {
1332 MatroskaAttachment
*attachment
= matroska
->attachments
.elem
;
1333 for (j
= 0; j
< matroska
->attachments
.nb_elem
; j
++)
1334 if (attachment
[j
].uid
== tags
[i
].target
.attachuid
&&
1335 attachment
[j
].stream
)
1336 matroska_convert_tag(s
, &tags
[i
].tag
,
1337 &attachment
[j
].stream
->metadata
, NULL
);
1338 } else if (tags
[i
].target
.chapteruid
) {
1339 MatroskaChapter
*chapter
= matroska
->chapters
.elem
;
1340 for (j
= 0; j
< matroska
->chapters
.nb_elem
; j
++)
1341 if (chapter
[j
].uid
== tags
[i
].target
.chapteruid
&&
1343 matroska_convert_tag(s
, &tags
[i
].tag
,
1344 &chapter
[j
].chapter
->metadata
, NULL
);
1345 } else if (tags
[i
].target
.trackuid
) {
1346 MatroskaTrack
*track
= matroska
->tracks
.elem
;
1347 for (j
= 0; j
< matroska
->tracks
.nb_elem
; j
++)
1348 if (track
[j
].uid
== tags
[i
].target
.trackuid
&& track
[j
].stream
)
1349 matroska_convert_tag(s
, &tags
[i
].tag
,
1350 &track
[j
].stream
->metadata
, NULL
);
1352 matroska_convert_tag(s
, &tags
[i
].tag
, &s
->metadata
,
1353 tags
[i
].target
.type
);
1358 static int matroska_parse_seekhead_entry(MatroskaDemuxContext
*matroska
,
1361 EbmlList
*seekhead_list
= &matroska
->seekhead
;
1362 uint32_t level_up
= matroska
->level_up
;
1363 uint32_t saved_id
= matroska
->current_id
;
1364 MatroskaSeekhead
*seekhead
= seekhead_list
->elem
;
1365 int64_t before_pos
= avio_tell(matroska
->ctx
->pb
);
1366 MatroskaLevel level
;
1370 if (idx
>= seekhead_list
->nb_elem
||
1371 seekhead
[idx
].id
== MATROSKA_ID_SEEKHEAD
||
1372 seekhead
[idx
].id
== MATROSKA_ID_CLUSTER
)
1376 offset
= seekhead
[idx
].pos
+ matroska
->segment_start
;
1377 if (avio_seek(matroska
->ctx
->pb
, offset
, SEEK_SET
) == offset
) {
1378 /* We don't want to lose our seekhead level, so we add
1379 * a dummy. This is a crude hack. */
1380 if (matroska
->num_levels
== EBML_MAX_DEPTH
) {
1381 av_log(matroska
->ctx
, AV_LOG_INFO
,
1382 "Max EBML element depth (%d) reached, "
1383 "cannot parse further.\n", EBML_MAX_DEPTH
);
1384 ret
= AVERROR_INVALIDDATA
;
1387 level
.length
= (uint64_t) -1;
1388 matroska
->levels
[matroska
->num_levels
] = level
;
1389 matroska
->num_levels
++;
1390 matroska
->current_id
= 0;
1392 ret
= ebml_parse(matroska
, matroska_segment
, matroska
);
1394 /* remove dummy level */
1395 while (matroska
->num_levels
) {
1396 uint64_t length
= matroska
->levels
[--matroska
->num_levels
].length
;
1397 if (length
== (uint64_t) -1)
1403 avio_seek(matroska
->ctx
->pb
, before_pos
, SEEK_SET
);
1404 matroska
->level_up
= level_up
;
1405 matroska
->current_id
= saved_id
;
1410 static void matroska_execute_seekhead(MatroskaDemuxContext
*matroska
)
1412 EbmlList
*seekhead_list
= &matroska
->seekhead
;
1413 int64_t before_pos
= avio_tell(matroska
->ctx
->pb
);
1416 // we should not do any seeking in the streaming case
1417 if (!matroska
->ctx
->pb
->seekable
||
1418 (matroska
->ctx
->flags
& AVFMT_FLAG_IGNIDX
))
1421 for (i
= 0; i
< seekhead_list
->nb_elem
; i
++) {
1422 MatroskaSeekhead
*seekhead
= seekhead_list
->elem
;
1423 if (seekhead
[i
].pos
<= before_pos
)
1426 // defer cues parsing until we actually need cue data.
1427 if (seekhead
[i
].id
== MATROSKA_ID_CUES
) {
1428 matroska
->cues_parsing_deferred
= 1;
1432 if (matroska_parse_seekhead_entry(matroska
, i
) < 0) {
1433 // mark index as broken
1434 matroska
->cues_parsing_deferred
= -1;
1440 static void matroska_add_index_entries(MatroskaDemuxContext
*matroska
)
1442 EbmlList
*index_list
;
1443 MatroskaIndex
*index
;
1444 int index_scale
= 1;
1447 index_list
= &matroska
->index
;
1448 index
= index_list
->elem
;
1449 if (index_list
->nb_elem
&&
1450 index
[0].time
> 1E14
/ matroska
->time_scale
) {
1451 av_log(matroska
->ctx
, AV_LOG_WARNING
, "Working around broken index.\n");
1452 index_scale
= matroska
->time_scale
;
1454 for (i
= 0; i
< index_list
->nb_elem
; i
++) {
1455 EbmlList
*pos_list
= &index
[i
].pos
;
1456 MatroskaIndexPos
*pos
= pos_list
->elem
;
1457 for (j
= 0; j
< pos_list
->nb_elem
; j
++) {
1458 MatroskaTrack
*track
= matroska_find_track_by_num(matroska
,
1460 if (track
&& track
->stream
)
1461 av_add_index_entry(track
->stream
,
1462 pos
[j
].pos
+ matroska
->segment_start
,
1463 index
[i
].time
/ index_scale
, 0, 0,
1469 static void matroska_parse_cues(MatroskaDemuxContext
*matroska
) {
1470 EbmlList
*seekhead_list
= &matroska
->seekhead
;
1471 MatroskaSeekhead
*seekhead
= seekhead_list
->elem
;
1474 for (i
= 0; i
< seekhead_list
->nb_elem
; i
++)
1475 if (seekhead
[i
].id
== MATROSKA_ID_CUES
)
1477 av_assert1(i
<= seekhead_list
->nb_elem
);
1479 if (matroska_parse_seekhead_entry(matroska
, i
) < 0)
1480 matroska
->cues_parsing_deferred
= -1;
1481 matroska_add_index_entries(matroska
);
1484 static int matroska_aac_profile(char *codec_id
)
1486 static const char *const aac_profiles
[] = { "MAIN", "LC", "SSR" };
1489 for (profile
= 0; profile
< FF_ARRAY_ELEMS(aac_profiles
); profile
++)
1490 if (strstr(codec_id
, aac_profiles
[profile
]))
1495 static int matroska_aac_sri(int samplerate
)
1499 for (sri
= 0; sri
< FF_ARRAY_ELEMS(avpriv_mpeg4audio_sample_rates
); sri
++)
1500 if (avpriv_mpeg4audio_sample_rates
[sri
] == samplerate
)
1505 static void matroska_metadata_creation_time(AVDictionary
**metadata
, int64_t date_utc
)
1508 /* Convert to seconds and adjust by number of seconds between 2001-01-01 and Epoch */
1509 time_t creation_time
= date_utc
/ 1000000000 + 978307200;
1510 struct tm
*ptm
= gmtime(&creation_time
);
1512 strftime(buffer
, sizeof(buffer
), "%Y-%m-%d %H:%M:%S", ptm
);
1513 av_dict_set(metadata
, "creation_time", buffer
, 0);
1516 static int matroska_parse_flac(AVFormatContext
*s
,
1517 MatroskaTrack
*track
,
1520 AVStream
*st
= track
->stream
;
1521 uint8_t *p
= track
->codec_priv
.data
;
1522 int size
= track
->codec_priv
.size
;
1524 if (size
< 8 + FLAC_STREAMINFO_SIZE
|| p
[4] & 0x7f) {
1525 av_log(s
, AV_LOG_WARNING
, "Invalid FLAC private data\n");
1526 track
->codec_priv
.size
= 0;
1530 track
->codec_priv
.size
= 8 + FLAC_STREAMINFO_SIZE
;
1532 p
+= track
->codec_priv
.size
;
1533 size
-= track
->codec_priv
.size
;
1535 /* parse the remaining metadata blocks if present */
1537 int block_last
, block_type
, block_size
;
1539 flac_parse_block_header(p
, &block_last
, &block_type
, &block_size
);
1543 if (block_size
> size
)
1546 /* check for the channel mask */
1547 if (block_type
== FLAC_METADATA_TYPE_VORBIS_COMMENT
) {
1548 AVDictionary
*dict
= NULL
;
1549 AVDictionaryEntry
*chmask
;
1551 ff_vorbis_comment(s
, &dict
, p
, block_size
, 0);
1552 chmask
= av_dict_get(dict
, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL
, 0);
1554 uint64_t mask
= strtol(chmask
->value
, NULL
, 0);
1555 if (!mask
|| mask
& ~0x3ffffULL
) {
1556 av_log(s
, AV_LOG_WARNING
,
1557 "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
1559 st
->codec
->channel_layout
= mask
;
1561 av_dict_free(&dict
);
1571 static int matroska_parse_tracks(AVFormatContext
*s
)
1573 MatroskaDemuxContext
*matroska
= s
->priv_data
;
1574 MatroskaTrack
*tracks
= matroska
->tracks
.elem
;
1579 for (i
= 0; i
< matroska
->tracks
.nb_elem
; i
++) {
1580 MatroskaTrack
*track
= &tracks
[i
];
1581 enum AVCodecID codec_id
= AV_CODEC_ID_NONE
;
1582 EbmlList
*encodings_list
= &track
->encodings
;
1583 MatroskaTrackEncoding
*encodings
= encodings_list
->elem
;
1584 uint8_t *extradata
= NULL
;
1585 int extradata_size
= 0;
1586 int extradata_offset
= 0;
1587 uint32_t fourcc
= 0;
1589 char* key_id_base64
= NULL
;
1592 /* Apply some sanity checks. */
1593 if (track
->type
!= MATROSKA_TRACK_TYPE_VIDEO
&&
1594 track
->type
!= MATROSKA_TRACK_TYPE_AUDIO
&&
1595 track
->type
!= MATROSKA_TRACK_TYPE_SUBTITLE
&&
1596 track
->type
!= MATROSKA_TRACK_TYPE_METADATA
) {
1597 av_log(matroska
->ctx
, AV_LOG_INFO
,
1598 "Unknown or unsupported track type %"PRIu64
"\n",
1602 if (!track
->codec_id
)
1605 if (track
->type
== MATROSKA_TRACK_TYPE_VIDEO
) {
1606 if (!track
->default_duration
&& track
->video
.frame_rate
> 0)
1607 track
->default_duration
= 1000000000 / track
->video
.frame_rate
;
1608 if (track
->video
.display_width
== -1)
1609 track
->video
.display_width
= track
->video
.pixel_width
;
1610 if (track
->video
.display_height
== -1)
1611 track
->video
.display_height
= track
->video
.pixel_height
;
1612 if (track
->video
.color_space
.size
== 4)
1613 fourcc
= AV_RL32(track
->video
.color_space
.data
);
1614 } else if (track
->type
== MATROSKA_TRACK_TYPE_AUDIO
) {
1615 if (!track
->audio
.out_samplerate
)
1616 track
->audio
.out_samplerate
= track
->audio
.samplerate
;
1618 if (encodings_list
->nb_elem
> 1) {
1619 av_log(matroska
->ctx
, AV_LOG_ERROR
,
1620 "Multiple combined encodings not supported");
1621 } else if (encodings_list
->nb_elem
== 1) {
1622 if (encodings
[0].type
) {
1623 if (encodings
[0].encryption
.key_id
.size
> 0) {
1624 /* Save the encryption key id to be stored later as a
1626 const int b64_size
= AV_BASE64_SIZE(encodings
[0].encryption
.key_id
.size
);
1627 key_id_base64
= av_malloc(b64_size
);
1628 if (key_id_base64
== NULL
)
1629 return AVERROR(ENOMEM
);
1631 av_base64_encode(key_id_base64
, b64_size
,
1632 encodings
[0].encryption
.key_id
.data
,
1633 encodings
[0].encryption
.key_id
.size
);
1635 encodings
[0].scope
= 0;
1636 av_log(matroska
->ctx
, AV_LOG_ERROR
,
1637 "Unsupported encoding type");
1641 encodings
[0].compression
.algo
!= MATROSKA_TRACK_ENCODING_COMP_ZLIB
&&
1644 encodings
[0].compression
.algo
!= MATROSKA_TRACK_ENCODING_COMP_BZLIB
&&
1647 encodings
[0].compression
.algo
!= MATROSKA_TRACK_ENCODING_COMP_LZO
&&
1649 encodings
[0].compression
.algo
!= MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP
) {
1650 encodings
[0].scope
= 0;
1651 av_log(matroska
->ctx
, AV_LOG_ERROR
,
1652 "Unsupported encoding type");
1653 } else if (track
->codec_priv
.size
&& encodings
[0].scope
& 2) {
1654 uint8_t *codec_priv
= track
->codec_priv
.data
;
1655 int ret
= matroska_decode_buffer(&track
->codec_priv
.data
,
1656 &track
->codec_priv
.size
,
1659 track
->codec_priv
.data
= NULL
;
1660 track
->codec_priv
.size
= 0;
1661 av_log(matroska
->ctx
, AV_LOG_ERROR
,
1662 "Failed to decode codec private data\n");
1665 if (codec_priv
!= track
->codec_priv
.data
)
1666 av_free(codec_priv
);
1670 for (j
= 0; ff_mkv_codec_tags
[j
].id
!= AV_CODEC_ID_NONE
; j
++) {
1671 if (!strncmp(ff_mkv_codec_tags
[j
].str
, track
->codec_id
,
1672 strlen(ff_mkv_codec_tags
[j
].str
))) {
1673 codec_id
= ff_mkv_codec_tags
[j
].id
;
1678 st
= track
->stream
= avformat_new_stream(s
, NULL
);
1680 av_free(key_id_base64
);
1681 return AVERROR(ENOMEM
);
1684 if (key_id_base64
) {
1685 /* export encryption key id as base64 metadata tag */
1686 av_dict_set(&st
->metadata
, "enc_key_id", key_id_base64
, 0);
1687 av_freep(&key_id_base64
);
1690 if (!strcmp(track
->codec_id
, "V_MS/VFW/FOURCC") &&
1691 track
->codec_priv
.size
>= 40 &&
1692 track
->codec_priv
.data
) {
1693 track
->ms_compat
= 1;
1694 bit_depth
= AV_RL16(track
->codec_priv
.data
+ 14);
1695 fourcc
= AV_RL32(track
->codec_priv
.data
+ 16);
1696 codec_id
= ff_codec_get_id(ff_codec_bmp_tags
,
1699 codec_id
= ff_codec_get_id(ff_codec_movvideo_tags
,
1701 extradata_offset
= 40;
1702 } else if (!strcmp(track
->codec_id
, "A_MS/ACM") &&
1703 track
->codec_priv
.size
>= 14 &&
1704 track
->codec_priv
.data
) {
1706 ffio_init_context(&b
, track
->codec_priv
.data
,
1707 track
->codec_priv
.size
,
1708 0, NULL
, NULL
, NULL
, NULL
);
1709 ret
= ff_get_wav_header(&b
, st
->codec
, track
->codec_priv
.size
);
1712 codec_id
= st
->codec
->codec_id
;
1713 extradata_offset
= FFMIN(track
->codec_priv
.size
, 18);
1714 } else if (!strcmp(track
->codec_id
, "A_QUICKTIME")
1715 && (track
->codec_priv
.size
>= 86)
1716 && (track
->codec_priv
.data
)) {
1717 fourcc
= AV_RL32(track
->codec_priv
.data
+ 4);
1718 codec_id
= ff_codec_get_id(ff_codec_movaudio_tags
, fourcc
);
1719 if (ff_codec_get_id(ff_codec_movaudio_tags
, AV_RL32(track
->codec_priv
.data
))) {
1720 fourcc
= AV_RL32(track
->codec_priv
.data
);
1721 codec_id
= ff_codec_get_id(ff_codec_movaudio_tags
, fourcc
);
1723 } else if (!strcmp(track
->codec_id
, "V_QUICKTIME") &&
1724 (track
->codec_priv
.size
>= 21) &&
1725 (track
->codec_priv
.data
)) {
1726 fourcc
= AV_RL32(track
->codec_priv
.data
+ 4);
1727 codec_id
= ff_codec_get_id(ff_codec_movvideo_tags
, fourcc
);
1728 if (ff_codec_get_id(ff_codec_movvideo_tags
, AV_RL32(track
->codec_priv
.data
))) {
1729 fourcc
= AV_RL32(track
->codec_priv
.data
);
1730 codec_id
= ff_codec_get_id(ff_codec_movvideo_tags
, fourcc
);
1732 if (codec_id
== AV_CODEC_ID_NONE
&& AV_RL32(track
->codec_priv
.data
+4) == AV_RL32("SMI "))
1733 codec_id
= AV_CODEC_ID_SVQ3
;
1734 } else if (codec_id
== AV_CODEC_ID_PCM_S16BE
) {
1735 switch (track
->audio
.bitdepth
) {
1737 codec_id
= AV_CODEC_ID_PCM_U8
;
1740 codec_id
= AV_CODEC_ID_PCM_S24BE
;
1743 codec_id
= AV_CODEC_ID_PCM_S32BE
;
1746 } else if (codec_id
== AV_CODEC_ID_PCM_S16LE
) {
1747 switch (track
->audio
.bitdepth
) {
1749 codec_id
= AV_CODEC_ID_PCM_U8
;
1752 codec_id
= AV_CODEC_ID_PCM_S24LE
;
1755 codec_id
= AV_CODEC_ID_PCM_S32LE
;
1758 } else if (codec_id
== AV_CODEC_ID_PCM_F32LE
&&
1759 track
->audio
.bitdepth
== 64) {
1760 codec_id
= AV_CODEC_ID_PCM_F64LE
;
1761 } else if (codec_id
== AV_CODEC_ID_AAC
&& !track
->codec_priv
.size
) {
1762 int profile
= matroska_aac_profile(track
->codec_id
);
1763 int sri
= matroska_aac_sri(track
->audio
.samplerate
);
1764 extradata
= av_mallocz(5 + FF_INPUT_BUFFER_PADDING_SIZE
);
1766 return AVERROR(ENOMEM
);
1767 extradata
[0] = (profile
<< 3) | ((sri
& 0x0E) >> 1);
1768 extradata
[1] = ((sri
& 0x01) << 7) | (track
->audio
.channels
<< 3);
1769 if (strstr(track
->codec_id
, "SBR")) {
1770 sri
= matroska_aac_sri(track
->audio
.out_samplerate
);
1771 extradata
[2] = 0x56;
1772 extradata
[3] = 0xE5;
1773 extradata
[4] = 0x80 | (sri
<< 3);
1777 } else if (codec_id
== AV_CODEC_ID_ALAC
&& track
->codec_priv
.size
&& track
->codec_priv
.size
< INT_MAX
- 12 - FF_INPUT_BUFFER_PADDING_SIZE
) {
1778 /* Only ALAC's magic cookie is stored in Matroska's track headers.
1779 * Create the "atom size", "tag", and "tag version" fields the
1780 * decoder expects manually. */
1781 extradata_size
= 12 + track
->codec_priv
.size
;
1782 extradata
= av_mallocz(extradata_size
+
1783 FF_INPUT_BUFFER_PADDING_SIZE
);
1785 return AVERROR(ENOMEM
);
1786 AV_WB32(extradata
, extradata_size
);
1787 memcpy(&extradata
[4], "alac", 4);
1788 AV_WB32(&extradata
[8], 0);
1789 memcpy(&extradata
[12], track
->codec_priv
.data
,
1790 track
->codec_priv
.size
);
1791 } else if (codec_id
== AV_CODEC_ID_TTA
) {
1792 extradata_size
= 30;
1793 extradata
= av_mallocz(extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
1795 return AVERROR(ENOMEM
);
1796 ffio_init_context(&b
, extradata
, extradata_size
, 1,
1797 NULL
, NULL
, NULL
, NULL
);
1798 avio_write(&b
, "TTA1", 4);
1800 avio_wl16(&b
, track
->audio
.channels
);
1801 avio_wl16(&b
, track
->audio
.bitdepth
);
1802 if (track
->audio
.out_samplerate
< 0 || track
->audio
.out_samplerate
> INT_MAX
)
1803 return AVERROR_INVALIDDATA
;
1804 avio_wl32(&b
, track
->audio
.out_samplerate
);
1805 avio_wl32(&b
, av_rescale((matroska
->duration
* matroska
->time_scale
),
1806 track
->audio
.out_samplerate
,
1807 AV_TIME_BASE
* 1000));
1808 } else if (codec_id
== AV_CODEC_ID_RV10
||
1809 codec_id
== AV_CODEC_ID_RV20
||
1810 codec_id
== AV_CODEC_ID_RV30
||
1811 codec_id
== AV_CODEC_ID_RV40
) {
1812 extradata_offset
= 26;
1813 } else if (codec_id
== AV_CODEC_ID_RA_144
) {
1814 track
->audio
.out_samplerate
= 8000;
1815 track
->audio
.channels
= 1;
1816 } else if ((codec_id
== AV_CODEC_ID_RA_288
||
1817 codec_id
== AV_CODEC_ID_COOK
||
1818 codec_id
== AV_CODEC_ID_ATRAC3
||
1819 codec_id
== AV_CODEC_ID_SIPR
)
1820 && track
->codec_priv
.data
) {
1823 ffio_init_context(&b
, track
->codec_priv
.data
,
1824 track
->codec_priv
.size
,
1825 0, NULL
, NULL
, NULL
, NULL
);
1827 flavor
= avio_rb16(&b
);
1828 track
->audio
.coded_framesize
= avio_rb32(&b
);
1830 track
->audio
.sub_packet_h
= avio_rb16(&b
);
1831 track
->audio
.frame_size
= avio_rb16(&b
);
1832 track
->audio
.sub_packet_size
= avio_rb16(&b
);
1834 track
->audio
.coded_framesize
<= 0 ||
1835 track
->audio
.sub_packet_h
<= 0 ||
1836 track
->audio
.frame_size
<= 0 ||
1837 track
->audio
.sub_packet_size
<= 0)
1838 return AVERROR_INVALIDDATA
;
1839 track
->audio
.buf
= av_malloc_array(track
->audio
.sub_packet_h
,
1840 track
->audio
.frame_size
);
1841 if (!track
->audio
.buf
)
1842 return AVERROR(ENOMEM
);
1843 if (codec_id
== AV_CODEC_ID_RA_288
) {
1844 st
->codec
->block_align
= track
->audio
.coded_framesize
;
1845 track
->codec_priv
.size
= 0;
1847 if (codec_id
== AV_CODEC_ID_SIPR
&& flavor
< 4) {
1848 static const int sipr_bit_rate
[4] = { 6504, 8496, 5000, 16000 };
1849 track
->audio
.sub_packet_size
= ff_sipr_subpk_size
[flavor
];
1850 st
->codec
->bit_rate
= sipr_bit_rate
[flavor
];
1852 st
->codec
->block_align
= track
->audio
.sub_packet_size
;
1853 extradata_offset
= 78;
1855 } else if (codec_id
== AV_CODEC_ID_FLAC
&& track
->codec_priv
.size
) {
1856 ret
= matroska_parse_flac(s
, track
, &extradata_offset
);
1859 } else if (codec_id
== AV_CODEC_ID_PRORES
&& track
->codec_priv
.size
== 4) {
1860 fourcc
= AV_RL32(track
->codec_priv
.data
);
1862 track
->codec_priv
.size
-= extradata_offset
;
1864 if (codec_id
== AV_CODEC_ID_NONE
)
1865 av_log(matroska
->ctx
, AV_LOG_INFO
,
1866 "Unknown/unsupported AVCodecID %s.\n", track
->codec_id
);
1868 if (track
->time_scale
< 0.01)
1869 track
->time_scale
= 1.0;
1870 avpriv_set_pts_info(st
, 64, matroska
->time_scale
* track
->time_scale
,
1871 1000 * 1000 * 1000); /* 64 bit pts in ns */
1873 /* convert the delay from ns to the track timebase */
1874 track
->codec_delay
= av_rescale_q(track
->codec_delay
,
1875 (AVRational
){ 1, 1000000000 },
1878 st
->codec
->codec_id
= codec_id
;
1880 if (strcmp(track
->language
, "und"))
1881 av_dict_set(&st
->metadata
, "language", track
->language
, 0);
1882 av_dict_set(&st
->metadata
, "title", track
->name
, 0);
1884 if (track
->flag_default
)
1885 st
->disposition
|= AV_DISPOSITION_DEFAULT
;
1886 if (track
->flag_forced
)
1887 st
->disposition
|= AV_DISPOSITION_FORCED
;
1889 if (!st
->codec
->extradata
) {
1891 st
->codec
->extradata
= extradata
;
1892 st
->codec
->extradata_size
= extradata_size
;
1893 } else if (track
->codec_priv
.data
&& track
->codec_priv
.size
> 0) {
1894 if (ff_alloc_extradata(st
->codec
, track
->codec_priv
.size
))
1895 return AVERROR(ENOMEM
);
1896 memcpy(st
->codec
->extradata
,
1897 track
->codec_priv
.data
+ extradata_offset
,
1898 track
->codec_priv
.size
);
1902 if (track
->type
== MATROSKA_TRACK_TYPE_VIDEO
) {
1903 MatroskaTrackPlane
*planes
= track
->operation
.combine_planes
.elem
;
1905 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
1906 st
->codec
->codec_tag
= fourcc
;
1908 st
->codec
->bits_per_coded_sample
= bit_depth
;
1909 st
->codec
->width
= track
->video
.pixel_width
;
1910 st
->codec
->height
= track
->video
.pixel_height
;
1911 av_reduce(&st
->sample_aspect_ratio
.num
,
1912 &st
->sample_aspect_ratio
.den
,
1913 st
->codec
->height
* track
->video
.display_width
,
1914 st
->codec
->width
* track
->video
.display_height
,
1916 if (st
->codec
->codec_id
!= AV_CODEC_ID_HEVC
)
1917 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
1919 if (track
->default_duration
) {
1920 av_reduce(&st
->avg_frame_rate
.num
, &st
->avg_frame_rate
.den
,
1921 1000000000, track
->default_duration
, 30000);
1922 #if FF_API_R_FRAME_RATE
1923 if ( st
->avg_frame_rate
.num
< st
->avg_frame_rate
.den
* 1000L
1924 && st
->avg_frame_rate
.num
> st
->avg_frame_rate
.den
* 5L)
1925 st
->r_frame_rate
= st
->avg_frame_rate
;
1929 /* export stereo mode flag as metadata tag */
1930 if (track
->video
.stereo_mode
&& track
->video
.stereo_mode
< MATROSKA_VIDEO_STEREOMODE_TYPE_NB
)
1931 av_dict_set(&st
->metadata
, "stereo_mode", ff_matroska_video_stereo_mode
[track
->video
.stereo_mode
], 0);
1933 /* export alpha mode flag as metadata tag */
1934 if (track
->video
.alpha_mode
)
1935 av_dict_set(&st
->metadata
, "alpha_mode", "1", 0);
1937 /* if we have virtual track, mark the real tracks */
1938 for (j
=0; j
< track
->operation
.combine_planes
.nb_elem
; j
++) {
1940 if (planes
[j
].type
>= MATROSKA_VIDEO_STEREO_PLANE_COUNT
)
1942 snprintf(buf
, sizeof(buf
), "%s_%d",
1943 ff_matroska_video_stereo_plane
[planes
[j
].type
], i
);
1944 for (k
=0; k
< matroska
->tracks
.nb_elem
; k
++)
1945 if (planes
[j
].uid
== tracks
[k
].uid
) {
1946 av_dict_set(&s
->streams
[k
]->metadata
,
1947 "stereo_mode", buf
, 0);
1951 // add stream level stereo3d side data if it is a supported format
1952 if (track
->video
.stereo_mode
< MATROSKA_VIDEO_STEREOMODE_TYPE_NB
&&
1953 track
->video
.stereo_mode
!= 10 && track
->video
.stereo_mode
!= 12) {
1954 int ret
= ff_mkv_stereo3d_conv(st
, track
->video
.stereo_mode
);
1958 } else if (track
->type
== MATROSKA_TRACK_TYPE_AUDIO
) {
1959 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
1960 st
->codec
->sample_rate
= track
->audio
.out_samplerate
;
1961 st
->codec
->channels
= track
->audio
.channels
;
1962 if (!st
->codec
->bits_per_coded_sample
)
1963 st
->codec
->bits_per_coded_sample
= track
->audio
.bitdepth
;
1964 if (st
->codec
->codec_id
!= AV_CODEC_ID_AAC
)
1965 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
1966 if (track
->codec_delay
> 0) {
1967 st
->codec
->delay
= av_rescale_q(track
->codec_delay
,
1969 (AVRational
){1, st
->codec
->sample_rate
});
1971 if (track
->seek_preroll
> 0) {
1972 av_codec_set_seek_preroll(st
->codec
,
1973 av_rescale_q(track
->seek_preroll
,
1974 (AVRational
){1, 1000000000},
1975 (AVRational
){1, st
->codec
->sample_rate
}));
1977 } else if (codec_id
== AV_CODEC_ID_WEBVTT
) {
1978 st
->codec
->codec_type
= AVMEDIA_TYPE_SUBTITLE
;
1980 if (!strcmp(track
->codec_id
, "D_WEBVTT/CAPTIONS")) {
1981 st
->disposition
|= AV_DISPOSITION_CAPTIONS
;
1982 } else if (!strcmp(track
->codec_id
, "D_WEBVTT/DESCRIPTIONS")) {
1983 st
->disposition
|= AV_DISPOSITION_DESCRIPTIONS
;
1984 } else if (!strcmp(track
->codec_id
, "D_WEBVTT/METADATA")) {
1985 st
->disposition
|= AV_DISPOSITION_METADATA
;
1987 } else if (track
->type
== MATROSKA_TRACK_TYPE_SUBTITLE
) {
1988 st
->codec
->codec_type
= AVMEDIA_TYPE_SUBTITLE
;
1989 if (st
->codec
->codec_id
== AV_CODEC_ID_ASS
)
1990 matroska
->contains_ssa
= 1;
1997 static int matroska_read_header(AVFormatContext
*s
)
1999 MatroskaDemuxContext
*matroska
= s
->priv_data
;
2000 EbmlList
*attachments_list
= &matroska
->attachments
;
2001 EbmlList
*chapters_list
= &matroska
->chapters
;
2002 MatroskaAttachment
*attachments
;
2003 MatroskaChapter
*chapters
;
2004 uint64_t max_start
= 0;
2011 /* First read the EBML header. */
2012 if (ebml_parse(matroska
, ebml_syntax
, &ebml
) ||
2013 ebml
.version
> EBML_VERSION
||
2014 ebml
.max_size
> sizeof(uint64_t) ||
2015 ebml
.id_length
> sizeof(uint32_t) ||
2016 ebml
.doctype_version
> 3 ||
2018 av_log(matroska
->ctx
, AV_LOG_ERROR
,
2019 "EBML header using unsupported features\n"
2020 "(EBML version %"PRIu64
", doctype %s, doc version %"PRIu64
")\n",
2021 ebml
.version
, ebml
.doctype
, ebml
.doctype_version
);
2022 ebml_free(ebml_syntax
, &ebml
);
2023 return AVERROR_PATCHWELCOME
;
2024 } else if (ebml
.doctype_version
== 3) {
2025 av_log(matroska
->ctx
, AV_LOG_WARNING
,
2026 "EBML header using unsupported features\n"
2027 "(EBML version %"PRIu64
", doctype %s, doc version %"PRIu64
")\n",
2028 ebml
.version
, ebml
.doctype
, ebml
.doctype_version
);
2030 for (i
= 0; i
< FF_ARRAY_ELEMS(matroska_doctypes
); i
++)
2031 if (!strcmp(ebml
.doctype
, matroska_doctypes
[i
]))
2033 if (i
>= FF_ARRAY_ELEMS(matroska_doctypes
)) {
2034 av_log(s
, AV_LOG_WARNING
, "Unknown EBML doctype '%s'\n", ebml
.doctype
);
2035 if (matroska
->ctx
->error_recognition
& AV_EF_EXPLODE
) {
2036 ebml_free(ebml_syntax
, &ebml
);
2037 return AVERROR_INVALIDDATA
;
2040 ebml_free(ebml_syntax
, &ebml
);
2042 /* The next thing is a segment. */
2043 pos
= avio_tell(matroska
->ctx
->pb
);
2044 res
= ebml_parse(matroska
, matroska_segments
, matroska
);
2045 // try resyncing until we find a EBML_STOP type element.
2047 res
= matroska_resync(matroska
, pos
);
2050 pos
= avio_tell(matroska
->ctx
->pb
);
2051 res
= ebml_parse(matroska
, matroska_segment
, matroska
);
2053 matroska_execute_seekhead(matroska
);
2055 if (!matroska
->time_scale
)
2056 matroska
->time_scale
= 1000000;
2057 if (matroska
->duration
)
2058 matroska
->ctx
->duration
= matroska
->duration
* matroska
->time_scale
*
2059 1000 / AV_TIME_BASE
;
2060 av_dict_set(&s
->metadata
, "title", matroska
->title
, 0);
2061 av_dict_set(&s
->metadata
, "encoder", matroska
->muxingapp
, 0);
2063 if (matroska
->date_utc
.size
== 8)
2064 matroska_metadata_creation_time(&s
->metadata
, AV_RB64(matroska
->date_utc
.data
));
2066 res
= matroska_parse_tracks(s
);
2070 attachments
= attachments_list
->elem
;
2071 for (j
= 0; j
< attachments_list
->nb_elem
; j
++) {
2072 if (!(attachments
[j
].filename
&& attachments
[j
].mime
&&
2073 attachments
[j
].bin
.data
&& attachments
[j
].bin
.size
> 0)) {
2074 av_log(matroska
->ctx
, AV_LOG_ERROR
, "incomplete attachment\n");
2076 AVStream
*st
= avformat_new_stream(s
, NULL
);
2079 av_dict_set(&st
->metadata
, "filename", attachments
[j
].filename
, 0);
2080 av_dict_set(&st
->metadata
, "mimetype", attachments
[j
].mime
, 0);
2081 st
->codec
->codec_id
= AV_CODEC_ID_NONE
;
2082 st
->codec
->codec_type
= AVMEDIA_TYPE_ATTACHMENT
;
2083 if (ff_alloc_extradata(st
->codec
, attachments
[j
].bin
.size
))
2085 memcpy(st
->codec
->extradata
, attachments
[j
].bin
.data
,
2086 attachments
[j
].bin
.size
);
2088 for (i
= 0; ff_mkv_mime_tags
[i
].id
!= AV_CODEC_ID_NONE
; i
++) {
2089 if (!strncmp(ff_mkv_mime_tags
[i
].str
, attachments
[j
].mime
,
2090 strlen(ff_mkv_mime_tags
[i
].str
))) {
2091 st
->codec
->codec_id
= ff_mkv_mime_tags
[i
].id
;
2095 attachments
[j
].stream
= st
;
2099 chapters
= chapters_list
->elem
;
2100 for (i
= 0; i
< chapters_list
->nb_elem
; i
++)
2101 if (chapters
[i
].start
!= AV_NOPTS_VALUE
&& chapters
[i
].uid
&&
2102 (max_start
== 0 || chapters
[i
].start
> max_start
)) {
2103 chapters
[i
].chapter
=
2104 avpriv_new_chapter(s
, chapters
[i
].uid
,
2105 (AVRational
) { 1, 1000000000 },
2106 chapters
[i
].start
, chapters
[i
].end
,
2108 if (chapters
[i
].chapter
) {
2109 av_dict_set(&chapters
[i
].chapter
->metadata
,
2110 "title", chapters
[i
].title
, 0);
2112 max_start
= chapters
[i
].start
;
2115 matroska_add_index_entries(matroska
);
2117 matroska_convert_tags(s
);
2123 * Put one packet in an application-supplied AVPacket struct.
2124 * Returns 0 on success or -1 on failure.
2126 static int matroska_deliver_packet(MatroskaDemuxContext
*matroska
,
2129 if (matroska
->num_packets
> 0) {
2130 memcpy(pkt
, matroska
->packets
[0], sizeof(AVPacket
));
2131 av_free(matroska
->packets
[0]);
2132 if (matroska
->num_packets
> 1) {
2134 memmove(&matroska
->packets
[0], &matroska
->packets
[1],
2135 (matroska
->num_packets
- 1) * sizeof(AVPacket
*));
2136 newpackets
= av_realloc(matroska
->packets
,
2137 (matroska
->num_packets
- 1) *
2138 sizeof(AVPacket
*));
2140 matroska
->packets
= newpackets
;
2142 av_freep(&matroska
->packets
);
2143 matroska
->prev_pkt
= NULL
;
2145 matroska
->num_packets
--;
2153 * Free all packets in our internal queue.
2155 static void matroska_clear_queue(MatroskaDemuxContext
*matroska
)
2157 matroska
->prev_pkt
= NULL
;
2158 if (matroska
->packets
) {
2160 for (n
= 0; n
< matroska
->num_packets
; n
++) {
2161 av_free_packet(matroska
->packets
[n
]);
2162 av_free(matroska
->packets
[n
]);
2164 av_freep(&matroska
->packets
);
2165 matroska
->num_packets
= 0;
2169 static int matroska_parse_laces(MatroskaDemuxContext
*matroska
, uint8_t **buf
,
2170 int *buf_size
, int type
,
2171 uint32_t **lace_buf
, int *laces
)
2173 int res
= 0, n
, size
= *buf_size
;
2174 uint8_t *data
= *buf
;
2175 uint32_t *lace_size
;
2179 *lace_buf
= av_mallocz(sizeof(int));
2181 return AVERROR(ENOMEM
);
2183 *lace_buf
[0] = size
;
2187 av_assert0(size
> 0);
2191 lace_size
= av_mallocz(*laces
* sizeof(int));
2193 return AVERROR(ENOMEM
);
2196 case 0x1: /* Xiph lacing */
2200 for (n
= 0; res
== 0 && n
< *laces
- 1; n
++) {
2202 if (size
<= total
) {
2203 res
= AVERROR_INVALIDDATA
;
2208 lace_size
[n
] += temp
;
2215 if (size
<= total
) {
2216 res
= AVERROR_INVALIDDATA
;
2220 lace_size
[n
] = size
- total
;
2224 case 0x2: /* fixed-size lacing */
2225 if (size
% (*laces
)) {
2226 res
= AVERROR_INVALIDDATA
;
2229 for (n
= 0; n
< *laces
; n
++)
2230 lace_size
[n
] = size
/ *laces
;
2233 case 0x3: /* EBML lacing */
2237 n
= matroska_ebmlnum_uint(matroska
, data
, size
, &num
);
2238 if (n
< 0 || num
> INT_MAX
) {
2239 av_log(matroska
->ctx
, AV_LOG_INFO
,
2240 "EBML block data error\n");
2241 res
= n
<0 ? n
: AVERROR_INVALIDDATA
;
2246 total
= lace_size
[0] = num
;
2247 for (n
= 1; res
== 0 && n
< *laces
- 1; n
++) {
2250 r
= matroska_ebmlnum_sint(matroska
, data
, size
, &snum
);
2251 if (r
< 0 || lace_size
[n
- 1] + snum
> (uint64_t)INT_MAX
) {
2252 av_log(matroska
->ctx
, AV_LOG_INFO
,
2253 "EBML block data error\n");
2254 res
= r
<0 ? r
: AVERROR_INVALIDDATA
;
2259 lace_size
[n
] = lace_size
[n
- 1] + snum
;
2260 total
+= lace_size
[n
];
2262 if (size
<= total
) {
2263 res
= AVERROR_INVALIDDATA
;
2266 lace_size
[*laces
- 1] = size
- total
;
2272 *lace_buf
= lace_size
;
2278 static int matroska_parse_rm_audio(MatroskaDemuxContext
*matroska
,
2279 MatroskaTrack
*track
, AVStream
*st
,
2280 uint8_t *data
, int size
, uint64_t timecode
,
2283 int a
= st
->codec
->block_align
;
2284 int sps
= track
->audio
.sub_packet_size
;
2285 int cfs
= track
->audio
.coded_framesize
;
2286 int h
= track
->audio
.sub_packet_h
;
2287 int y
= track
->audio
.sub_packet_cnt
;
2288 int w
= track
->audio
.frame_size
;
2291 if (!track
->audio
.pkt_cnt
) {
2292 if (track
->audio
.sub_packet_cnt
== 0)
2293 track
->audio
.buf_timecode
= timecode
;
2294 if (st
->codec
->codec_id
== AV_CODEC_ID_RA_288
) {
2295 if (size
< cfs
* h
/ 2) {
2296 av_log(matroska
->ctx
, AV_LOG_ERROR
,
2297 "Corrupt int4 RM-style audio packet size\n");
2298 return AVERROR_INVALIDDATA
;
2300 for (x
= 0; x
< h
/ 2; x
++)
2301 memcpy(track
->audio
.buf
+ x
* 2 * w
+ y
* cfs
,
2302 data
+ x
* cfs
, cfs
);
2303 } else if (st
->codec
->codec_id
== AV_CODEC_ID_SIPR
) {
2305 av_log(matroska
->ctx
, AV_LOG_ERROR
,
2306 "Corrupt sipr RM-style audio packet size\n");
2307 return AVERROR_INVALIDDATA
;
2309 memcpy(track
->audio
.buf
+ y
* w
, data
, w
);
2311 if (size
< sps
* w
/ sps
|| h
<=0 || w
%sps
) {
2312 av_log(matroska
->ctx
, AV_LOG_ERROR
,
2313 "Corrupt generic RM-style audio packet size\n");
2314 return AVERROR_INVALIDDATA
;
2316 for (x
= 0; x
< w
/ sps
; x
++)
2317 memcpy(track
->audio
.buf
+
2318 sps
* (h
* x
+ ((h
+ 1) / 2) * (y
& 1) + (y
>> 1)),
2319 data
+ x
* sps
, sps
);
2322 if (++track
->audio
.sub_packet_cnt
>= h
) {
2323 if (st
->codec
->codec_id
== AV_CODEC_ID_SIPR
)
2324 ff_rm_reorder_sipr_data(track
->audio
.buf
, h
, w
);
2325 track
->audio
.sub_packet_cnt
= 0;
2326 track
->audio
.pkt_cnt
= h
* w
/ a
;
2330 while (track
->audio
.pkt_cnt
) {
2331 AVPacket
*pkt
= NULL
;
2332 if (!(pkt
= av_mallocz(sizeof(AVPacket
))) || av_new_packet(pkt
, a
) < 0) {
2334 return AVERROR(ENOMEM
);
2337 track
->audio
.buf
+ a
* (h
* w
/ a
- track
->audio
.pkt_cnt
--),
2339 pkt
->pts
= track
->audio
.buf_timecode
;
2340 track
->audio
.buf_timecode
= AV_NOPTS_VALUE
;
2342 pkt
->stream_index
= st
->index
;
2343 dynarray_add(&matroska
->packets
, &matroska
->num_packets
, pkt
);
2349 /* reconstruct full wavpack blocks from mangled matroska ones */
2350 static int matroska_parse_wavpack(MatroskaTrack
*track
, uint8_t *src
,
2351 uint8_t **pdst
, int *size
)
2353 uint8_t *dst
= NULL
;
2358 int ret
, offset
= 0;
2360 if (srclen
< 12 || track
->stream
->codec
->extradata_size
< 2)
2361 return AVERROR_INVALIDDATA
;
2363 ver
= AV_RL16(track
->stream
->codec
->extradata
);
2365 samples
= AV_RL32(src
);
2369 while (srclen
>= 8) {
2374 uint32_t flags
= AV_RL32(src
);
2375 uint32_t crc
= AV_RL32(src
+ 4);
2379 multiblock
= (flags
& 0x1800) != 0x1800;
2382 ret
= AVERROR_INVALIDDATA
;
2385 blocksize
= AV_RL32(src
);
2391 if (blocksize
> srclen
) {
2392 ret
= AVERROR_INVALIDDATA
;
2396 tmp
= av_realloc(dst
, dstlen
+ blocksize
+ 32);
2398 ret
= AVERROR(ENOMEM
);
2402 dstlen
+= blocksize
+ 32;
2404 AV_WL32(dst
+ offset
, MKTAG('w', 'v', 'p', 'k')); // tag
2405 AV_WL32(dst
+ offset
+ 4, blocksize
+ 24); // blocksize - 8
2406 AV_WL16(dst
+ offset
+ 8, ver
); // version
2407 AV_WL16(dst
+ offset
+ 10, 0); // track/index_no
2408 AV_WL32(dst
+ offset
+ 12, 0); // total samples
2409 AV_WL32(dst
+ offset
+ 16, 0); // block index
2410 AV_WL32(dst
+ offset
+ 20, samples
); // number of samples
2411 AV_WL32(dst
+ offset
+ 24, flags
); // flags
2412 AV_WL32(dst
+ offset
+ 28, crc
); // crc
2413 memcpy(dst
+ offset
+ 32, src
, blocksize
); // block data
2416 srclen
-= blocksize
;
2417 offset
+= blocksize
+ 32;
2430 static int matroska_parse_webvtt(MatroskaDemuxContext
*matroska
,
2431 MatroskaTrack
*track
,
2433 uint8_t *data
, int data_len
,
2439 uint8_t *id
, *settings
, *text
, *buf
;
2440 int id_len
, settings_len
, text_len
;
2445 return AVERROR_INVALIDDATA
;
2448 q
= data
+ data_len
;
2453 if (*p
== '\r' || *p
== '\n') {
2462 if (p
>= q
|| *p
!= '\n')
2463 return AVERROR_INVALIDDATA
;
2469 if (*p
== '\r' || *p
== '\n') {
2470 settings_len
= p
- settings
;
2478 if (p
>= q
|| *p
!= '\n')
2479 return AVERROR_INVALIDDATA
;
2484 while (text_len
> 0) {
2485 const int len
= text_len
- 1;
2486 const uint8_t c
= p
[len
];
2487 if (c
!= '\r' && c
!= '\n')
2493 return AVERROR_INVALIDDATA
;
2495 pkt
= av_mallocz(sizeof(*pkt
));
2496 err
= av_new_packet(pkt
, text_len
);
2499 return AVERROR(err
);
2502 memcpy(pkt
->data
, text
, text_len
);
2505 buf
= av_packet_new_side_data(pkt
,
2506 AV_PKT_DATA_WEBVTT_IDENTIFIER
,
2510 return AVERROR(ENOMEM
);
2512 memcpy(buf
, id
, id_len
);
2515 if (settings_len
> 0) {
2516 buf
= av_packet_new_side_data(pkt
,
2517 AV_PKT_DATA_WEBVTT_SETTINGS
,
2521 return AVERROR(ENOMEM
);
2523 memcpy(buf
, settings
, settings_len
);
2526 // Do we need this for subtitles?
2527 // pkt->flags = AV_PKT_FLAG_KEY;
2529 pkt
->stream_index
= st
->index
;
2530 pkt
->pts
= timecode
;
2532 // Do we need this for subtitles?
2533 // pkt->dts = timecode;
2535 pkt
->duration
= duration
;
2538 dynarray_add(&matroska
->packets
, &matroska
->num_packets
, pkt
);
2539 matroska
->prev_pkt
= pkt
;
2544 static int matroska_parse_frame(MatroskaDemuxContext
*matroska
,
2545 MatroskaTrack
*track
, AVStream
*st
,
2546 uint8_t *data
, int pkt_size
,
2547 uint64_t timecode
, uint64_t lace_duration
,
2548 int64_t pos
, int is_keyframe
,
2549 uint8_t *additional
, uint64_t additional_id
, int additional_size
,
2550 int64_t discard_padding
)
2552 MatroskaTrackEncoding
*encodings
= track
->encodings
.elem
;
2553 uint8_t *pkt_data
= data
;
2554 int offset
= 0, res
;
2557 if (encodings
&& !encodings
->type
&& encodings
->scope
& 1) {
2558 res
= matroska_decode_buffer(&pkt_data
, &pkt_size
, track
);
2563 if (st
->codec
->codec_id
== AV_CODEC_ID_WAVPACK
) {
2565 res
= matroska_parse_wavpack(track
, pkt_data
, &wv_data
, &pkt_size
);
2567 av_log(matroska
->ctx
, AV_LOG_ERROR
,
2568 "Error parsing a wavpack block.\n");
2571 if (pkt_data
!= data
)
2572 av_freep(&pkt_data
);
2576 if (st
->codec
->codec_id
== AV_CODEC_ID_PRORES
&&
2577 AV_RB32(&data
[4]) != MKBETAG('i', 'c', 'p', 'f'))
2580 pkt
= av_mallocz(sizeof(AVPacket
));
2581 /* XXX: prevent data copy... */
2582 if (av_new_packet(pkt
, pkt_size
+ offset
) < 0) {
2584 res
= AVERROR(ENOMEM
);
2588 if (st
->codec
->codec_id
== AV_CODEC_ID_PRORES
&& offset
== 8) {
2589 uint8_t *buf
= pkt
->data
;
2590 bytestream_put_be32(&buf
, pkt_size
);
2591 bytestream_put_be32(&buf
, MKBETAG('i', 'c', 'p', 'f'));
2594 memcpy(pkt
->data
+ offset
, pkt_data
, pkt_size
);
2596 if (pkt_data
!= data
)
2597 av_freep(&pkt_data
);
2599 pkt
->flags
= is_keyframe
;
2600 pkt
->stream_index
= st
->index
;
2602 if (additional_size
> 0) {
2603 uint8_t *side_data
= av_packet_new_side_data(pkt
,
2604 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
,
2605 additional_size
+ 8);
2607 av_free_packet(pkt
);
2609 return AVERROR(ENOMEM
);
2611 AV_WB64(side_data
, additional_id
);
2612 memcpy(side_data
+ 8, additional
, additional_size
);
2615 if (discard_padding
) {
2616 uint8_t *side_data
= av_packet_new_side_data(pkt
,
2617 AV_PKT_DATA_SKIP_SAMPLES
,
2620 av_free_packet(pkt
);
2622 return AVERROR(ENOMEM
);
2624 AV_WL32(side_data
, 0);
2625 AV_WL32(side_data
+ 4, av_rescale_q(discard_padding
,
2626 (AVRational
){1, 1000000000},
2627 (AVRational
){1, st
->codec
->sample_rate
}));
2630 if (track
->ms_compat
)
2631 pkt
->dts
= timecode
;
2633 pkt
->pts
= timecode
;
2635 if (st
->codec
->codec_id
== AV_CODEC_ID_SUBRIP
) {
2637 * For backward compatibility.
2638 * Historically, we have put subtitle duration
2639 * in convergence_duration, on the off chance
2640 * that the time_scale is less than 1us, which
2641 * could result in a 32bit overflow on the
2642 * normal duration field.
2644 pkt
->convergence_duration
= lace_duration
;
2647 if (track
->type
!= MATROSKA_TRACK_TYPE_SUBTITLE
||
2648 lace_duration
<= INT_MAX
) {
2650 * For non subtitle tracks, just store the duration
2653 * If it's a subtitle track and duration value does
2654 * not overflow a uint32, then also store it normally.
2656 pkt
->duration
= lace_duration
;
2659 dynarray_add(&matroska
->packets
, &matroska
->num_packets
, pkt
);
2660 matroska
->prev_pkt
= pkt
;
2665 if (pkt_data
!= data
)
2666 av_freep(&pkt_data
);
2670 static int matroska_parse_block(MatroskaDemuxContext
*matroska
, uint8_t *data
,
2671 int size
, int64_t pos
, uint64_t cluster_time
,
2672 uint64_t block_duration
, int is_keyframe
,
2673 uint8_t *additional
, uint64_t additional_id
, int additional_size
,
2674 int64_t cluster_pos
, int64_t discard_padding
)
2676 uint64_t timecode
= AV_NOPTS_VALUE
;
2677 MatroskaTrack
*track
;
2681 uint32_t *lace_size
= NULL
;
2682 int n
, flags
, laces
= 0;
2684 int trust_default_duration
= 1;
2686 if ((n
= matroska_ebmlnum_uint(matroska
, data
, size
, &num
)) < 0) {
2687 av_log(matroska
->ctx
, AV_LOG_ERROR
, "EBML block data error\n");
2693 track
= matroska_find_track_by_num(matroska
, num
);
2694 if (!track
|| !track
->stream
) {
2695 av_log(matroska
->ctx
, AV_LOG_INFO
,
2696 "Invalid stream %"PRIu64
" or size %u\n", num
, size
);
2697 return AVERROR_INVALIDDATA
;
2698 } else if (size
<= 3)
2701 if (st
->discard
>= AVDISCARD_ALL
)
2703 av_assert1(block_duration
!= AV_NOPTS_VALUE
);
2705 block_time
= sign_extend(AV_RB16(data
), 16);
2709 if (is_keyframe
== -1)
2710 is_keyframe
= flags
& 0x80 ? AV_PKT_FLAG_KEY
: 0;
2712 if (cluster_time
!= (uint64_t) -1 &&
2713 (block_time
>= 0 || cluster_time
>= -block_time
)) {
2714 timecode
= cluster_time
+ block_time
- track
->codec_delay
;
2715 if (track
->type
== MATROSKA_TRACK_TYPE_SUBTITLE
&&
2716 timecode
< track
->end_timecode
)
2717 is_keyframe
= 0; /* overlapping subtitles are not key frame */
2719 av_add_index_entry(st
, cluster_pos
, timecode
, 0, 0,
2723 if (matroska
->skip_to_keyframe
&&
2724 track
->type
!= MATROSKA_TRACK_TYPE_SUBTITLE
) {
2725 if (timecode
< matroska
->skip_to_timecode
)
2728 matroska
->skip_to_keyframe
= 0;
2729 else if (!st
->skip_to_keyframe
) {
2730 av_log(matroska
->ctx
, AV_LOG_ERROR
, "File is broken, keyframes not correctly marked!\n");
2731 matroska
->skip_to_keyframe
= 0;
2735 res
= matroska_parse_laces(matroska
, &data
, &size
, (flags
& 0x06) >> 1,
2736 &lace_size
, &laces
);
2741 if (track
->audio
.samplerate
== 8000) {
2742 // If this is needed for more codecs, then add them here
2743 if (st
->codec
->codec_id
== AV_CODEC_ID_AC3
) {
2744 if (track
->audio
.samplerate
!= st
->codec
->sample_rate
|| !st
->codec
->frame_size
)
2745 trust_default_duration
= 0;
2749 if (!block_duration
&& trust_default_duration
)
2750 block_duration
= track
->default_duration
* laces
/ matroska
->time_scale
;
2752 if (cluster_time
!= (uint64_t)-1 && (block_time
>= 0 || cluster_time
>= -block_time
))
2753 track
->end_timecode
=
2754 FFMAX(track
->end_timecode
, timecode
+ block_duration
);
2756 for (n
= 0; n
< laces
; n
++) {
2757 int64_t lace_duration
= block_duration
*(n
+1) / laces
- block_duration
*n
/ laces
;
2759 if (lace_size
[n
] > size
) {
2760 av_log(matroska
->ctx
, AV_LOG_ERROR
, "Invalid packet size\n");
2764 if ((st
->codec
->codec_id
== AV_CODEC_ID_RA_288
||
2765 st
->codec
->codec_id
== AV_CODEC_ID_COOK
||
2766 st
->codec
->codec_id
== AV_CODEC_ID_SIPR
||
2767 st
->codec
->codec_id
== AV_CODEC_ID_ATRAC3
) &&
2768 st
->codec
->block_align
&& track
->audio
.sub_packet_size
) {
2769 res
= matroska_parse_rm_audio(matroska
, track
, st
, data
,
2775 } else if (st
->codec
->codec_id
== AV_CODEC_ID_WEBVTT
) {
2776 res
= matroska_parse_webvtt(matroska
, track
, st
,
2778 timecode
, lace_duration
,
2783 res
= matroska_parse_frame(matroska
, track
, st
, data
, lace_size
[n
],
2784 timecode
, lace_duration
, pos
,
2785 !n
? is_keyframe
: 0,
2786 additional
, additional_id
, additional_size
,
2792 if (timecode
!= AV_NOPTS_VALUE
)
2793 timecode
= lace_duration
? timecode
+ lace_duration
: AV_NOPTS_VALUE
;
2794 data
+= lace_size
[n
];
2795 size
-= lace_size
[n
];
2803 static int matroska_parse_cluster_incremental(MatroskaDemuxContext
*matroska
)
2805 EbmlList
*blocks_list
;
2806 MatroskaBlock
*blocks
;
2808 res
= ebml_parse(matroska
,
2809 matroska_cluster_incremental_parsing
,
2810 &matroska
->current_cluster
);
2813 if (matroska
->current_cluster_pos
)
2814 ebml_level_end(matroska
);
2815 ebml_free(matroska_cluster
, &matroska
->current_cluster
);
2816 memset(&matroska
->current_cluster
, 0, sizeof(MatroskaCluster
));
2817 matroska
->current_cluster_num_blocks
= 0;
2818 matroska
->current_cluster_pos
= avio_tell(matroska
->ctx
->pb
);
2819 matroska
->prev_pkt
= NULL
;
2820 /* sizeof the ID which was already read */
2821 if (matroska
->current_id
)
2822 matroska
->current_cluster_pos
-= 4;
2823 res
= ebml_parse(matroska
,
2824 matroska_clusters_incremental
,
2825 &matroska
->current_cluster
);
2826 /* Try parsing the block again. */
2828 res
= ebml_parse(matroska
,
2829 matroska_cluster_incremental_parsing
,
2830 &matroska
->current_cluster
);
2834 matroska
->current_cluster_num_blocks
<
2835 matroska
->current_cluster
.blocks
.nb_elem
) {
2836 blocks_list
= &matroska
->current_cluster
.blocks
;
2837 blocks
= blocks_list
->elem
;
2839 matroska
->current_cluster_num_blocks
= blocks_list
->nb_elem
;
2840 i
= blocks_list
->nb_elem
- 1;
2841 if (blocks
[i
].bin
.size
> 0 && blocks
[i
].bin
.data
) {
2842 int is_keyframe
= blocks
[i
].non_simple
? !blocks
[i
].reference
: -1;
2843 uint8_t* additional
= blocks
[i
].additional
.size
> 0 ?
2844 blocks
[i
].additional
.data
: NULL
;
2845 if (!blocks
[i
].non_simple
)
2846 blocks
[i
].duration
= 0;
2847 res
= matroska_parse_block(matroska
, blocks
[i
].bin
.data
,
2848 blocks
[i
].bin
.size
, blocks
[i
].bin
.pos
,
2849 matroska
->current_cluster
.timecode
,
2850 blocks
[i
].duration
, is_keyframe
,
2851 additional
, blocks
[i
].additional_id
,
2852 blocks
[i
].additional
.size
,
2853 matroska
->current_cluster_pos
,
2854 blocks
[i
].discard_padding
);
2861 static int matroska_parse_cluster(MatroskaDemuxContext
*matroska
)
2863 MatroskaCluster cluster
= { 0 };
2864 EbmlList
*blocks_list
;
2865 MatroskaBlock
*blocks
;
2869 if (!matroska
->contains_ssa
)
2870 return matroska_parse_cluster_incremental(matroska
);
2871 pos
= avio_tell(matroska
->ctx
->pb
);
2872 matroska
->prev_pkt
= NULL
;
2873 if (matroska
->current_id
)
2874 pos
-= 4; /* sizeof the ID which was already read */
2875 res
= ebml_parse(matroska
, matroska_clusters
, &cluster
);
2876 blocks_list
= &cluster
.blocks
;
2877 blocks
= blocks_list
->elem
;
2878 for (i
= 0; i
< blocks_list
->nb_elem
; i
++)
2879 if (blocks
[i
].bin
.size
> 0 && blocks
[i
].bin
.data
) {
2880 int is_keyframe
= blocks
[i
].non_simple
? !blocks
[i
].reference
: -1;
2881 res
= matroska_parse_block(matroska
, blocks
[i
].bin
.data
,
2882 blocks
[i
].bin
.size
, blocks
[i
].bin
.pos
,
2883 cluster
.timecode
, blocks
[i
].duration
,
2884 is_keyframe
, NULL
, 0, 0, pos
,
2885 blocks
[i
].discard_padding
);
2887 ebml_free(matroska_cluster
, &cluster
);
2891 static int matroska_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
2893 MatroskaDemuxContext
*matroska
= s
->priv_data
;
2895 while (matroska_deliver_packet(matroska
, pkt
)) {
2896 int64_t pos
= avio_tell(matroska
->ctx
->pb
);
2899 if (matroska_parse_cluster(matroska
) < 0)
2900 matroska_resync(matroska
, pos
);
2906 static int matroska_read_seek(AVFormatContext
*s
, int stream_index
,
2907 int64_t timestamp
, int flags
)
2909 MatroskaDemuxContext
*matroska
= s
->priv_data
;
2910 MatroskaTrack
*tracks
= matroska
->tracks
.elem
;
2911 AVStream
*st
= s
->streams
[stream_index
];
2912 int i
, index
, index_sub
, index_min
;
2914 /* Parse the CUES now since we need the index data to seek. */
2915 if (matroska
->cues_parsing_deferred
> 0) {
2916 matroska
->cues_parsing_deferred
= 0;
2917 matroska_parse_cues(matroska
);
2920 if (!st
->nb_index_entries
)
2922 timestamp
= FFMAX(timestamp
, st
->index_entries
[0].timestamp
);
2924 if ((index
= av_index_search_timestamp(st
, timestamp
, flags
)) < 0) {
2925 avio_seek(s
->pb
, st
->index_entries
[st
->nb_index_entries
- 1].pos
,
2927 matroska
->current_id
= 0;
2928 while ((index
= av_index_search_timestamp(st
, timestamp
, flags
)) < 0) {
2929 matroska_clear_queue(matroska
);
2930 if (matroska_parse_cluster(matroska
) < 0)
2935 matroska_clear_queue(matroska
);
2936 if (index
< 0 || (matroska
->cues_parsing_deferred
< 0 && index
== st
->nb_index_entries
- 1))
2940 for (i
= 0; i
< matroska
->tracks
.nb_elem
; i
++) {
2941 tracks
[i
].audio
.pkt_cnt
= 0;
2942 tracks
[i
].audio
.sub_packet_cnt
= 0;
2943 tracks
[i
].audio
.buf_timecode
= AV_NOPTS_VALUE
;
2944 tracks
[i
].end_timecode
= 0;
2945 if (tracks
[i
].type
== MATROSKA_TRACK_TYPE_SUBTITLE
&&
2946 tracks
[i
].stream
->discard
!= AVDISCARD_ALL
) {
2947 index_sub
= av_index_search_timestamp(
2948 tracks
[i
].stream
, st
->index_entries
[index
].timestamp
,
2949 AVSEEK_FLAG_BACKWARD
);
2950 while (index_sub
>= 0 &&
2952 tracks
[i
].stream
->index_entries
[index_sub
].pos
< st
->index_entries
[index_min
].pos
&&
2953 st
->index_entries
[index
].timestamp
- tracks
[i
].stream
->index_entries
[index_sub
].timestamp
< 30000000000 / matroska
->time_scale
)
2958 avio_seek(s
->pb
, st
->index_entries
[index_min
].pos
, SEEK_SET
);
2959 matroska
->current_id
= 0;
2960 if (flags
& AVSEEK_FLAG_ANY
) {
2961 st
->skip_to_keyframe
= 0;
2962 matroska
->skip_to_timecode
= timestamp
;
2964 st
->skip_to_keyframe
= 1;
2965 matroska
->skip_to_timecode
= st
->index_entries
[index
].timestamp
;
2967 matroska
->skip_to_keyframe
= 1;
2969 matroska
->num_levels
= 0;
2970 ff_update_cur_dts(s
, st
, st
->index_entries
[index
].timestamp
);
2973 // slightly hackish but allows proper fallback to
2974 // the generic seeking code.
2975 matroska_clear_queue(matroska
);
2976 matroska
->current_id
= 0;
2977 st
->skip_to_keyframe
=
2978 matroska
->skip_to_keyframe
= 0;
2980 matroska
->num_levels
= 0;
2984 static int matroska_read_close(AVFormatContext
*s
)
2986 MatroskaDemuxContext
*matroska
= s
->priv_data
;
2987 MatroskaTrack
*tracks
= matroska
->tracks
.elem
;
2990 matroska_clear_queue(matroska
);
2992 for (n
= 0; n
< matroska
->tracks
.nb_elem
; n
++)
2993 if (tracks
[n
].type
== MATROSKA_TRACK_TYPE_AUDIO
)
2994 av_free(tracks
[n
].audio
.buf
);
2995 ebml_free(matroska_cluster
, &matroska
->current_cluster
);
2996 ebml_free(matroska_segment
, matroska
);
3002 int64_t start_time_ns
;
3003 int64_t end_time_ns
;
3004 int64_t start_offset
;
3008 /* This function searches all the Cues and returns the CueDesc corresponding the
3009 * the timestamp ts. Returned CueDesc will be such that start_time_ns <= ts <
3010 * end_time_ns. All 4 fields will be set to -1 if ts >= file's duration.
3012 static CueDesc
get_cue_desc(AVFormatContext
*s
, int64_t ts
, int64_t cues_start
) {
3013 MatroskaDemuxContext
*matroska
= s
->priv_data
;
3016 int nb_index_entries
= s
->streams
[0]->nb_index_entries
;
3017 AVIndexEntry
*index_entries
= s
->streams
[0]->index_entries
;
3018 if (ts
>= matroska
->duration
* matroska
->time_scale
) return (CueDesc
) {-1, -1, -1, -1};
3019 for (i
= 1; i
< nb_index_entries
; i
++) {
3020 if (index_entries
[i
- 1].timestamp
* matroska
->time_scale
<= ts
&&
3021 index_entries
[i
].timestamp
* matroska
->time_scale
> ts
) {
3026 cue_desc
.start_time_ns
= index_entries
[i
].timestamp
* matroska
->time_scale
;
3027 cue_desc
.start_offset
= index_entries
[i
].pos
- matroska
->segment_start
;
3028 if (i
!= nb_index_entries
- 1) {
3029 cue_desc
.end_time_ns
= index_entries
[i
+ 1].timestamp
* matroska
->time_scale
;
3030 cue_desc
.end_offset
= index_entries
[i
+ 1].pos
- matroska
->segment_start
;
3032 cue_desc
.end_time_ns
= matroska
->duration
* matroska
->time_scale
;
3033 // FIXME: this needs special handling for files where Cues appear
3034 // before Clusters. the current logic assumes Cues appear after
3036 cue_desc
.end_offset
= cues_start
- matroska
->segment_start
;
3041 static int webm_clusters_start_with_keyframe(AVFormatContext
*s
)
3043 MatroskaDemuxContext
*matroska
= s
->priv_data
;
3044 int64_t cluster_pos
, before_pos
;
3046 if (s
->streams
[0]->nb_index_entries
<= 0) return 0;
3047 // seek to the first cluster using cues.
3048 index
= av_index_search_timestamp(s
->streams
[0], 0, 0);
3049 if (index
< 0) return 0;
3050 cluster_pos
= s
->streams
[0]->index_entries
[index
].pos
;
3051 before_pos
= avio_tell(s
->pb
);
3053 int64_t cluster_id
= 0, cluster_length
= 0;
3055 avio_seek(s
->pb
, cluster_pos
, SEEK_SET
);
3056 // read cluster id and length
3057 ebml_read_num(matroska
, matroska
->ctx
->pb
, 4, &cluster_id
);
3058 ebml_read_length(matroska
, matroska
->ctx
->pb
, &cluster_length
);
3059 if (cluster_id
!= 0xF43B675) { // done with all clusters
3062 avio_seek(s
->pb
, cluster_pos
, SEEK_SET
);
3063 matroska
->current_id
= 0;
3064 matroska_clear_queue(matroska
);
3065 if (matroska_parse_cluster(matroska
) < 0 ||
3066 matroska
->num_packets
<= 0) {
3069 pkt
= matroska
->packets
[0];
3070 cluster_pos
+= cluster_length
+ 12; // 12 is the offset of the cluster id and length.
3071 if (!(pkt
->flags
& AV_PKT_FLAG_KEY
)) {
3076 avio_seek(s
->pb
, before_pos
, SEEK_SET
);
3080 static int buffer_size_after_time_downloaded(int64_t time_ns
, double search_sec
, int64_t bps
,
3081 double min_buffer
, double* buffer
,
3082 double* sec_to_download
, AVFormatContext
*s
,
3085 double nano_seconds_per_second
= 1000000000.0;
3086 double time_sec
= time_ns
/ nano_seconds_per_second
;
3088 int64_t time_to_search_ns
= (int64_t)(search_sec
* nano_seconds_per_second
);
3089 int64_t end_time_ns
= time_ns
+ time_to_search_ns
;
3090 double sec_downloaded
= 0.0;
3091 CueDesc desc_curr
= get_cue_desc(s
, time_ns
, cues_start
);
3092 if (desc_curr
.start_time_ns
== -1)
3094 *sec_to_download
= 0.0;
3096 // Check for non cue start time.
3097 if (time_ns
> desc_curr
.start_time_ns
) {
3098 int64_t cue_nano
= desc_curr
.end_time_ns
- time_ns
;
3099 double percent
= (double)(cue_nano
) / (desc_curr
.end_time_ns
- desc_curr
.start_time_ns
);
3100 double cueBytes
= (desc_curr
.end_offset
- desc_curr
.start_offset
) * percent
;
3101 double timeToDownload
= (cueBytes
* 8.0) / bps
;
3103 sec_downloaded
+= (cue_nano
/ nano_seconds_per_second
) - timeToDownload
;
3104 *sec_to_download
+= timeToDownload
;
3106 // Check if the search ends within the first cue.
3107 if (desc_curr
.end_time_ns
>= end_time_ns
) {
3108 double desc_end_time_sec
= desc_curr
.end_time_ns
/ nano_seconds_per_second
;
3109 double percent_to_sub
= search_sec
/ (desc_end_time_sec
- time_sec
);
3110 sec_downloaded
= percent_to_sub
* sec_downloaded
;
3111 *sec_to_download
= percent_to_sub
* *sec_to_download
;
3114 if ((sec_downloaded
+ *buffer
) <= min_buffer
) {
3118 // Get the next Cue.
3119 desc_curr
= get_cue_desc(s
, desc_curr
.end_time_ns
, cues_start
);
3122 while (desc_curr
.start_time_ns
!= -1) {
3123 int64_t desc_bytes
= desc_curr
.end_offset
- desc_curr
.start_offset
;
3124 int64_t desc_ns
= desc_curr
.end_time_ns
- desc_curr
.start_time_ns
;
3125 double desc_sec
= desc_ns
/ nano_seconds_per_second
;
3126 double bits
= (desc_bytes
* 8.0);
3127 double time_to_download
= bits
/ bps
;
3129 sec_downloaded
+= desc_sec
- time_to_download
;
3130 *sec_to_download
+= time_to_download
;
3132 if (desc_curr
.end_time_ns
>= end_time_ns
) {
3133 double desc_end_time_sec
= desc_curr
.end_time_ns
/ nano_seconds_per_second
;
3134 double percent_to_sub
= search_sec
/ (desc_end_time_sec
- time_sec
);
3135 sec_downloaded
= percent_to_sub
* sec_downloaded
;
3136 *sec_to_download
= percent_to_sub
* *sec_to_download
;
3138 if ((sec_downloaded
+ *buffer
) <= min_buffer
)
3143 if ((sec_downloaded
+ *buffer
) <= min_buffer
) {
3148 desc_curr
= get_cue_desc(s
, desc_curr
.end_time_ns
, cues_start
);
3150 *buffer
= *buffer
+ sec_downloaded
;
3154 /* This function computes the bandwidth of the WebM file with the help of
3155 * buffer_size_after_time_downloaded() function. Both of these functions are
3156 * adapted from WebM Tools project and are adapted to work with FFmpeg's
3157 * Matroska parsing mechanism.
3159 * Returns the bandwidth of the file on success; -1 on error.
3161 static int64_t webm_dash_manifest_compute_bandwidth(AVFormatContext
*s
, int64_t cues_start
)
3163 MatroskaDemuxContext
*matroska
= s
->priv_data
;
3164 AVStream
*st
= s
->streams
[0];
3165 double bandwidth
= 0.0;
3168 for (i
= 0; i
< st
->nb_index_entries
; i
++) {
3169 int64_t prebuffer_ns
= 1000000000;
3170 int64_t time_ns
= st
->index_entries
[i
].timestamp
* matroska
->time_scale
;
3171 double nano_seconds_per_second
= 1000000000.0;
3172 int64_t prebuffered_ns
= time_ns
+ prebuffer_ns
;
3173 double prebuffer_bytes
= 0.0;
3174 int64_t temp_prebuffer_ns
= prebuffer_ns
;
3175 int64_t pre_bytes
, pre_ns
;
3176 double pre_sec
, prebuffer
, bits_per_second
;
3177 CueDesc desc_beg
= get_cue_desc(s
, time_ns
, cues_start
);
3179 // Start with the first Cue.
3180 CueDesc desc_end
= desc_beg
;
3182 // Figure out how much data we have downloaded for the prebuffer. This will
3183 // be used later to adjust the bits per sample to try.
3184 while (desc_end
.start_time_ns
!= -1 && desc_end
.end_time_ns
< prebuffered_ns
) {
3185 // Prebuffered the entire Cue.
3186 prebuffer_bytes
+= desc_end
.end_offset
- desc_end
.start_offset
;
3187 temp_prebuffer_ns
-= desc_end
.end_time_ns
- desc_end
.start_time_ns
;
3188 desc_end
= get_cue_desc(s
, desc_end
.end_time_ns
, cues_start
);
3190 if (desc_end
.start_time_ns
== -1) {
3191 // The prebuffer is larger than the duration.
3192 return (matroska
->duration
* matroska
->time_scale
>= prebuffered_ns
) ? -1 : 0;
3195 // The prebuffer ends in the last Cue. Estimate how much data was
3197 pre_bytes
= desc_end
.end_offset
- desc_end
.start_offset
;
3198 pre_ns
= desc_end
.end_time_ns
- desc_end
.start_time_ns
;
3199 pre_sec
= pre_ns
/ nano_seconds_per_second
;
3201 pre_bytes
* ((temp_prebuffer_ns
/ nano_seconds_per_second
) / pre_sec
);
3203 prebuffer
= prebuffer_ns
/ nano_seconds_per_second
;
3205 // Set this to 0.0 in case our prebuffer buffers the entire video.
3206 bits_per_second
= 0.0;
3208 int64_t desc_bytes
= desc_end
.end_offset
- desc_beg
.start_offset
;
3209 int64_t desc_ns
= desc_end
.end_time_ns
- desc_beg
.start_time_ns
;
3210 double desc_sec
= desc_ns
/ nano_seconds_per_second
;
3211 double calc_bits_per_second
= (desc_bytes
* 8) / desc_sec
;
3213 // Drop the bps by the percentage of bytes buffered.
3214 double percent
= (desc_bytes
- prebuffer_bytes
) / desc_bytes
;
3215 double mod_bits_per_second
= calc_bits_per_second
* percent
;
3217 if (prebuffer
< desc_sec
) {
3219 (double)(matroska
->duration
* matroska
->time_scale
) / nano_seconds_per_second
;
3221 // Add 1 so the bits per second should be a little bit greater than file
3223 int64_t bps
= (int64_t)(mod_bits_per_second
) + 1;
3224 const double min_buffer
= 0.0;
3225 double buffer
= prebuffer
;
3226 double sec_to_download
= 0.0;
3228 int rv
= buffer_size_after_time_downloaded(prebuffered_ns
, search_sec
, bps
,
3229 min_buffer
, &buffer
, &sec_to_download
,
3233 } else if (rv
== 0) {
3234 bits_per_second
= (double)(bps
);
3239 desc_end
= get_cue_desc(s
, desc_end
.end_time_ns
, cues_start
);
3240 } while (desc_end
.start_time_ns
!= -1);
3241 if (bandwidth
< bits_per_second
) bandwidth
= bits_per_second
;
3243 return (int64_t)bandwidth
;
3246 static int webm_dash_manifest_cues(AVFormatContext
*s
)
3248 MatroskaDemuxContext
*matroska
= s
->priv_data
;
3249 EbmlList
*seekhead_list
= &matroska
->seekhead
;
3250 MatroskaSeekhead
*seekhead
= seekhead_list
->elem
;
3252 int64_t cues_start
= -1, cues_end
= -1, before_pos
, bandwidth
;
3255 // determine cues start and end positions
3256 for (i
= 0; i
< seekhead_list
->nb_elem
; i
++)
3257 if (seekhead
[i
].id
== MATROSKA_ID_CUES
)
3260 if (i
>= seekhead_list
->nb_elem
) return -1;
3262 before_pos
= avio_tell(matroska
->ctx
->pb
);
3263 cues_start
= seekhead
[i
].pos
+ matroska
->segment_start
;
3264 if (avio_seek(matroska
->ctx
->pb
, cues_start
, SEEK_SET
) == cues_start
) {
3265 uint64_t cues_length
= 0, cues_id
= 0;
3266 ebml_read_num(matroska
, matroska
->ctx
->pb
, 4, &cues_id
);
3267 ebml_read_length(matroska
, matroska
->ctx
->pb
, &cues_length
);
3268 cues_end
= cues_start
+ cues_length
+ 11; // 11 is the offset of Cues ID.
3270 avio_seek(matroska
->ctx
->pb
, before_pos
, SEEK_SET
);
3271 if (cues_start
== -1 || cues_end
== -1) return -1;
3274 matroska_parse_cues(matroska
);
3277 av_dict_set_int(&s
->streams
[0]->metadata
, CUES_START
, cues_start
, 0);
3280 av_dict_set_int(&s
->streams
[0]->metadata
, CUES_END
, cues_end
, 0);
3283 bandwidth
= webm_dash_manifest_compute_bandwidth(s
, cues_start
);
3284 if (bandwidth
< 0) return -1;
3285 av_dict_set_int(&s
->streams
[0]->metadata
, BANDWIDTH
, bandwidth
, 0);
3287 // check if all clusters start with key frames
3288 av_dict_set_int(&s
->streams
[0]->metadata
, CLUSTER_KEYFRAME
, webm_clusters_start_with_keyframe(s
), 0);
3290 // store cue point timestamps as a comma separated list for checking subsegment alignment in
3291 // the muxer. assumes that each timestamp cannot be more than 20 characters long.
3292 buf
= av_malloc(s
->streams
[0]->nb_index_entries
* 20 * sizeof(char));
3293 if (!buf
) return -1;
3295 for (i
= 0; i
< s
->streams
[0]->nb_index_entries
; i
++) {
3296 snprintf(buf
, (i
+ 1) * 20 * sizeof(char),
3297 "%s%" PRId64
, buf
, s
->streams
[0]->index_entries
[i
].timestamp
);
3298 if (i
!= s
->streams
[0]->nb_index_entries
- 1)
3299 strncat(buf
, ",", sizeof(char));
3301 av_dict_set(&s
->streams
[0]->metadata
, CUE_TIMESTAMPS
, buf
, 0);
3307 static int webm_dash_manifest_read_header(AVFormatContext
*s
)
3310 int ret
= matroska_read_header(s
);
3311 MatroskaTrack
*tracks
;
3312 MatroskaDemuxContext
*matroska
= s
->priv_data
;
3314 av_log(s
, AV_LOG_ERROR
, "Failed to read file headers\n");
3318 // initialization range
3319 // 5 is the offset of Cluster ID.
3320 av_dict_set_int(&s
->streams
[0]->metadata
, INITIALIZATION_RANGE
, avio_tell(s
->pb
) - 5, 0);
3322 // basename of the file
3323 buf
= strrchr(s
->filename
, '/');
3324 if (!buf
) return -1;
3325 av_dict_set(&s
->streams
[0]->metadata
, FILENAME
, ++buf
, 0);
3328 buf
= av_asprintf("%g", matroska
->duration
);
3329 if (!buf
) return AVERROR(ENOMEM
);
3330 av_dict_set(&s
->streams
[0]->metadata
, DURATION
, buf
, 0);
3334 tracks
= matroska
->tracks
.elem
;
3335 av_dict_set_int(&s
->streams
[0]->metadata
, TRACK_NUMBER
, tracks
[0].num
, 0);
3337 // parse the cues and populate Cue related fields
3338 return webm_dash_manifest_cues(s
);
3341 static int webm_dash_manifest_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
3346 AVInputFormat ff_matroska_demuxer
= {
3347 .name
= "matroska,webm",
3348 .long_name
= NULL_IF_CONFIG_SMALL("Matroska / WebM"),
3349 .extensions
= "mkv,mk3d,mka,mks",
3350 .priv_data_size
= sizeof(MatroskaDemuxContext
),
3351 .read_probe
= matroska_probe
,
3352 .read_header
= matroska_read_header
,
3353 .read_packet
= matroska_read_packet
,
3354 .read_close
= matroska_read_close
,
3355 .read_seek
= matroska_read_seek
,
3356 .mime_type
= "audio/webm,audio/x-matroska,video/webm,video/x-matroska"
3359 AVInputFormat ff_webm_dash_manifest_demuxer
= {
3360 .name
= "webm_dash_manifest",
3361 .long_name
= NULL_IF_CONFIG_SMALL("WebM DASH Manifest"),
3362 .priv_data_size
= sizeof(MatroskaDemuxContext
),
3363 .read_header
= webm_dash_manifest_read_header
,
3364 .read_packet
= webm_dash_manifest_read_packet
,
3365 .read_close
= matroska_read_close
,