FFmpeg
matroskadec.c
Go to the documentation of this file.
1 /*
2  * Matroska file demuxer
3  * Copyright (c) 2003-2008 The FFmpeg Project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
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/
29  */
30 
31 #include "config.h"
32 #include "config_components.h"
33 
34 #include <inttypes.h>
35 #include <stdio.h>
36 
37 #include "libavutil/avstring.h"
38 #include "libavutil/base64.h"
39 #include "libavutil/bprint.h"
40 #include "libavutil/dict.h"
41 #include "libavutil/display.h"
42 #include "libavutil/intfloat.h"
43 #include "libavutil/intreadwrite.h"
44 #include "libavutil/lzo.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/opt.h"
49 #include "libavutil/spherical.h"
50 
51 #include "libavcodec/bytestream.h"
52 #include "libavcodec/flac.h"
53 #include "libavcodec/mpeg4audio.h"
55 
56 #include "avformat.h"
57 #include "avio_internal.h"
58 #include "demux.h"
59 #include "dovi_isom.h"
60 #include "internal.h"
61 #include "isom.h"
62 #include "matroska.h"
63 #include "oggdec.h"
64 /* For ff_codec_get_id(). */
65 #include "riff.h"
66 #include "rmsipr.h"
67 
68 #if CONFIG_BZLIB
69 #include <bzlib.h>
70 #endif
71 #if CONFIG_ZLIB
72 #include <zlib.h>
73 #endif
74 
75 #include "qtpalette.h"
76 
77 #define EBML_UNKNOWN_LENGTH UINT64_MAX /* EBML unknown length, in uint64_t */
78 #define NEEDS_CHECKING 2 /* Indicates that some error checks
79  * still need to be performed */
80 #define LEVEL_ENDED 3 /* return value of ebml_parse when the
81  * syntax level used for parsing ended. */
82 #define SKIP_THRESHOLD 1024 * 1024 /* In non-seekable mode, if more than SKIP_THRESHOLD
83  * of unkown, potentially damaged data is encountered,
84  * it is considered an error. */
85 #define UNKNOWN_EQUIV 50 * 1024 /* An unknown element is considered equivalent
86  * to this many bytes of unknown data for the
87  * SKIP_THRESHOLD check. */
88 
89 typedef enum {
95  EBML_UTF8,
96  EBML_BIN,
102 
103 typedef struct CountedElement {
104  union {
105  uint64_t u;
106  int64_t i;
107  double f;
108  char *s;
109  } el;
110  unsigned count;
112 
113 typedef const struct EbmlSyntax {
114  uint32_t id;
115  uint8_t type;
116  uint8_t is_counted;
118  size_t data_offset;
119  union {
120  int64_t i;
121  uint64_t u;
122  double f;
123  const char *s;
124  const struct EbmlSyntax *n;
125  } def;
126 } EbmlSyntax;
127 
128 typedef struct EbmlList {
129  int nb_elem;
130  unsigned int alloc_elem_size;
131  void *elem;
133 
134 typedef struct EbmlBin {
135  int size;
137  uint8_t *data;
138  int64_t pos;
140 
141 typedef struct Ebml {
142  uint64_t version;
143  uint64_t max_size;
144  uint64_t id_length;
145  char *doctype;
146  uint64_t doctype_version;
147 } Ebml;
148 
149 typedef struct MatroskaTrackCompression {
150  uint64_t algo;
153 
154 typedef struct MatroskaTrackEncryption {
155  uint64_t algo;
158 
159 typedef struct MatroskaTrackEncoding {
160  uint64_t scope;
161  uint64_t type;
165 
166 typedef struct MatroskaMasteringMeta {
167  double r_x;
168  double r_y;
169  double g_x;
170  double g_y;
171  double b_x;
172  double b_y;
173  double white_x;
174  double white_y;
178 
179 typedef struct MatroskaTrackVideoColor {
182  uint64_t chroma_sub_horz;
183  uint64_t chroma_sub_vert;
184  uint64_t cb_sub_horz;
185  uint64_t cb_sub_vert;
188  uint64_t range;
189  uint64_t transfer_characteristics;
190  uint64_t primaries;
191  uint64_t max_cll;
192  uint64_t max_fall;
195 
196 typedef struct MatroskaTrackVideoProjection {
197  uint64_t type;
198  EbmlBin private;
199  double yaw;
200  double pitch;
201  double roll;
203 
204 typedef struct MatroskaTrackVideo {
205  double frame_rate;
206  uint64_t display_width;
207  uint64_t display_height;
208  uint64_t pixel_width;
209  uint64_t pixel_height;
211  uint64_t display_unit;
212  uint64_t interlaced;
213  uint64_t field_order;
214  uint64_t stereo_mode;
215  uint64_t alpha_mode;
219 
220 typedef struct MatroskaTrackAudio {
221  double samplerate;
223  uint64_t bitdepth;
224  uint64_t channels;
225 
226  /* real audio header (extracted from extradata) */
229  int frame_size;
230  int sub_packet_size;
232  int pkt_cnt;
233  uint64_t buf_timecode;
234  uint8_t *buf;
236 
237 typedef struct MatroskaTrackPlane {
238  uint64_t uid;
239  uint64_t type;
241 
242 typedef struct MatroskaTrackOperation {
245 
246 typedef struct MatroskaBlockAdditionMapping {
247  uint64_t value;
248  char *name;
249  uint64_t type;
252 
253 typedef struct MatroskaTrack {
254  uint64_t num;
255  uint64_t uid;
256  uint64_t type;
257  char *name;
258  char *codec_id;
260  char *language;
261  double time_scale;
263  uint64_t flag_default;
264  uint64_t flag_forced;
265  uint64_t flag_comment;
270  uint64_t seek_preroll;
275  uint64_t codec_delay;
277 
278  AVStream *stream;
279  int64_t end_timecode;
281  int needs_decoding;
282  uint64_t max_block_additional_id;
284 
288 
289 typedef struct MatroskaAttachment {
290  uint64_t uid;
291  char *filename;
292  char *description;
293  char *mime;
295 
298 
299 typedef struct MatroskaChapter {
300  uint64_t start;
301  uint64_t end;
302  uint64_t uid;
303  char *title;
304 
307 
308 typedef struct MatroskaIndexPos {
309  uint64_t track;
310  uint64_t pos;
312 
313 typedef struct MatroskaIndex {
314  uint64_t time;
317 
318 typedef struct MatroskaTag {
319  char *name;
320  char *string;
321  char *lang;
322  uint64_t def;
325 
326 typedef struct MatroskaTagTarget {
327  char *type;
328  uint64_t typevalue;
329  uint64_t trackuid;
330  uint64_t chapteruid;
331  uint64_t attachuid;
333 
334 typedef struct MatroskaTags {
336  EbmlList tag;
337 } MatroskaTags;
338 
339 typedef struct MatroskaSeekhead {
340  uint64_t id;
341  uint64_t pos;
343 
344 typedef struct MatroskaLevel {
345  uint64_t start;
346  uint64_t length;
348 
349 typedef struct MatroskaBlock {
350  uint64_t duration;
352  uint64_t non_simple;
354  uint64_t additional_id;
357 } MatroskaBlock;
358 
359 typedef struct MatroskaCluster {
361  uint64_t timecode;
362  int64_t pos;
364 
365 typedef struct MatroskaLevel1Element {
366  int64_t pos;
367  uint32_t id;
368  int parsed;
370 
371 typedef struct MatroskaDemuxContext {
372  const AVClass *class;
374 
375  /* EBML stuff */
378  uint32_t current_id;
379  int64_t resync_pos;
381 
382  uint64_t time_scale;
383  double duration;
384  char *title;
385  char *muxingapp;
390  EbmlList index;
391  EbmlList tags;
393 
394  /* byte position of the segment inside the stream */
395  int64_t segment_start;
396 
397  /* This packet coincides with FFFormatContext.parse_pkt
398  * and is not owned by us. */
399  AVPacket *pkt;
400 
401  /* the packet queue */
403 
404  int done;
405 
406  /* What to skip before effectively reading a packet. */
407  int skip_to_keyframe;
409 
410  /* File has a CUES element, but we defer parsing until it is needed. */
412 
413  /* Level1 elements and whether they were read yet */
415  int num_level1_elems;
416 
418 
419  /* WebM DASH Manifest live flag */
420  int is_live;
421 
422  /* Bandwidth value for WebM DASH Manifest */
423  int bandwidth;
425 
426 #define CHILD_OF(parent) { .def = { .n = parent } }
427 
428 // The following forward declarations need their size because
429 // a tentative definition with internal linkage must not be an
430 // incomplete type (6.7.2 in C90, 6.9.2 in C99).
431 // Removing the sizes breaks MSVC.
438 
439 static EbmlSyntax ebml_header[] = {
440  { EBML_ID_EBMLREADVERSION, EBML_UINT, 0, 0, offsetof(Ebml, version), { .u = EBML_VERSION } },
441  { EBML_ID_EBMLMAXSIZELENGTH, EBML_UINT, 0, 0, offsetof(Ebml, max_size), { .u = 8 } },
442  { EBML_ID_EBMLMAXIDLENGTH, EBML_UINT, 0, 0, offsetof(Ebml, id_length), { .u = 4 } },
443  { EBML_ID_DOCTYPE, EBML_STR, 0, 0, offsetof(Ebml, doctype), { .s = "(none)" } },
444  { EBML_ID_DOCTYPEREADVERSION, EBML_UINT, 0, 0, offsetof(Ebml, doctype_version), { .u = 1 } },
448 };
449 
451  { EBML_ID_HEADER, EBML_NEST, 0, 0, 0, { .n = ebml_header } },
453  { 0 }
454 };
455 
456 static EbmlSyntax matroska_info[] = {
457  { MATROSKA_ID_TIMECODESCALE, EBML_UINT, 0, 0, offsetof(MatroskaDemuxContext, time_scale), { .u = 1000000 } },
459  { MATROSKA_ID_TITLE, EBML_UTF8, 0, 0, offsetof(MatroskaDemuxContext, title) },
461  { MATROSKA_ID_MUXINGAPP, EBML_UTF8, 0, 0, offsetof(MatroskaDemuxContext, muxingapp) },
462  { MATROSKA_ID_DATEUTC, EBML_BIN, 0, 0, offsetof(MatroskaDemuxContext, date_utc) },
465 };
466 
474  { MATROSKA_ID_VIDEOCOLOR_WHITEX, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, white_x) },
475  { MATROSKA_ID_VIDEOCOLOR_WHITEY, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, white_y) },
476  { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN, EBML_FLOAT, 1, 0, offsetof(MatroskaMasteringMeta, min_luminance) },
477  { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, max_luminance) },
479 };
480 
482  { MATROSKA_ID_VIDEOCOLORMATRIXCOEFF, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, matrix_coefficients), { .u = AVCOL_SPC_UNSPECIFIED } },
483  { MATROSKA_ID_VIDEOCOLORBITSPERCHANNEL, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, bits_per_channel), { .u = 0 } },
484  { MATROSKA_ID_VIDEOCOLORCHROMASUBHORZ, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, chroma_sub_horz) },
485  { MATROSKA_ID_VIDEOCOLORCHROMASUBVERT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, chroma_sub_vert) },
486  { MATROSKA_ID_VIDEOCOLORCBSUBHORZ, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, cb_sub_horz) },
487  { MATROSKA_ID_VIDEOCOLORCBSUBVERT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, cb_sub_vert) },
494  { MATROSKA_ID_VIDEOCOLORMAXFALL, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, max_fall) },
497 };
498 
502  { MATROSKA_ID_VIDEOPROJECTIONPOSEYAW, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideoProjection, yaw), { .f = 0.0 } },
503  { MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideoProjection, pitch), { .f = 0.0 } },
504  { MATROSKA_ID_VIDEOPROJECTIONPOSEROLL, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideoProjection, roll), { .f = 0.0 } },
506 };
507 
508 static EbmlSyntax matroska_track_video[] = {
509  { MATROSKA_ID_VIDEOFRAMERATE, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideo, frame_rate) },
510  { MATROSKA_ID_VIDEODISPLAYWIDTH, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, display_width), { .u=-1 } },
511  { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, display_height), { .u=-1 } },
512  { MATROSKA_ID_VIDEOPIXELWIDTH, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, pixel_width) },
513  { MATROSKA_ID_VIDEOPIXELHEIGHT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, pixel_height) },
514  { MATROSKA_ID_VIDEOCOLORSPACE, EBML_BIN, 0, 0, offsetof(MatroskaTrackVideo, color_space) },
515  { MATROSKA_ID_VIDEOALPHAMODE, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, alpha_mode), { .u = 0 } },
528 };
529 
530 static EbmlSyntax matroska_track_audio[] = {
531  { MATROSKA_ID_AUDIOSAMPLINGFREQ, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackAudio, samplerate), { .f = 8000.0 } },
532  { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackAudio, out_samplerate) },
533  { MATROSKA_ID_AUDIOBITDEPTH, EBML_UINT, 0, 0, offsetof(MatroskaTrackAudio, bitdepth) },
534  { MATROSKA_ID_AUDIOCHANNELS, EBML_UINT, 0, 0, offsetof(MatroskaTrackAudio, channels), { .u = 1 } },
536 };
537 
542 };
543 
545  { MATROSKA_ID_ENCODINGENCALGO, EBML_UINT, 0, 0, offsetof(MatroskaTrackEncryption,algo), {.u = 0} },
553 };
555  { MATROSKA_ID_ENCODINGSCOPE, EBML_UINT, 0, 0, offsetof(MatroskaTrackEncoding, scope), { .u = 1 } },
556  { MATROSKA_ID_ENCODINGTYPE, EBML_UINT, 0, 0, offsetof(MatroskaTrackEncoding, type), { .u = 0 } },
561 };
562 
566 };
567 
568 static EbmlSyntax matroska_track_plane[] = {
572 };
573 
575  { MATROSKA_ID_TRACKPLANE, EBML_NEST, 0, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n = matroska_track_plane} },
577 };
578 
582 };
583 
590 };
591 
592 static EbmlSyntax matroska_track[] = {
593  { MATROSKA_ID_TRACKNUMBER, EBML_UINT, 0, 0, offsetof(MatroskaTrack, num) },
594  { MATROSKA_ID_TRACKNAME, EBML_UTF8, 0, 0, offsetof(MatroskaTrack, name) },
595  { MATROSKA_ID_TRACKUID, EBML_UINT, 0, 0, offsetof(MatroskaTrack, uid) },
596  { MATROSKA_ID_TRACKTYPE, EBML_UINT, 0, 0, offsetof(MatroskaTrack, type) },
597  { MATROSKA_ID_CODECID, EBML_STR, 0, 0, offsetof(MatroskaTrack, codec_id) },
598  { MATROSKA_ID_CODECPRIVATE, EBML_BIN, 0, 0, offsetof(MatroskaTrack, codec_priv) },
599  { MATROSKA_ID_CODECDELAY, EBML_UINT, 0, 0, offsetof(MatroskaTrack, codec_delay), { .u = 0 } },
600  { MATROSKA_ID_TRACKLANGUAGE, EBML_STR, 0, 0, offsetof(MatroskaTrack, language), { .s = "eng" } },
601  { MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, 0, offsetof(MatroskaTrack, default_duration) },
602  { MATROSKA_ID_TRACKTIMECODESCALE, EBML_FLOAT, 0, 0, offsetof(MatroskaTrack, time_scale), { .f = 1.0 } },
603  { MATROSKA_ID_TRACKFLAGCOMMENTARY, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_comment), { .u = 0 } },
604  { MATROSKA_ID_TRACKFLAGDEFAULT, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_default), { .u = 1 } },
605  { MATROSKA_ID_TRACKFLAGFORCED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_forced), { .u = 0 } },
606  { MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_hearingimpaired), { .u = 0 } },
607  { MATROSKA_ID_TRACKFLAGVISUALIMPAIRED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_visualimpaired), { .u = 0 } },
608  { MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_textdescriptions), { .u = 0 } },
609  { MATROSKA_ID_TRACKFLAGORIGINAL, EBML_UINT, 1, 0, offsetof(MatroskaTrack, flag_original), {.u = 0 } },
611  { MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, 0, offsetof(MatroskaTrack, audio), { .n = matroska_track_audio } },
612  { MATROSKA_ID_TRACKOPERATION, EBML_NEST, 0, 0, offsetof(MatroskaTrack, operation), { .n = matroska_track_operation } },
614  { MATROSKA_ID_TRACKMAXBLKADDID, EBML_UINT, 0, 0, offsetof(MatroskaTrack, max_block_additional_id), { .u = 0 } },
615  { MATROSKA_ID_TRACKBLKADDMAPPING, EBML_NEST, 0, sizeof(MatroskaBlockAdditionMapping), offsetof(MatroskaTrack, block_addition_mappings), { .n = matroska_block_addition_mapping } },
616  { MATROSKA_ID_SEEKPREROLL, EBML_UINT, 0, 0, offsetof(MatroskaTrack, seek_preroll), { .u = 0 } },
626 };
627 
628 static EbmlSyntax matroska_tracks[] = {
629  { MATROSKA_ID_TRACKENTRY, EBML_NEST, 0, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext, tracks), { .n = matroska_track } },
631 };
632 
633 static EbmlSyntax matroska_attachment[] = {
634  { MATROSKA_ID_FILEUID, EBML_UINT, 0, 0, offsetof(MatroskaAttachment, uid) },
635  { MATROSKA_ID_FILENAME, EBML_UTF8, 0, 0, offsetof(MatroskaAttachment, filename) },
636  { MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, 0, offsetof(MatroskaAttachment, mime) },
637  { MATROSKA_ID_FILEDATA, EBML_BIN, 0, 0, offsetof(MatroskaAttachment, bin) },
640 };
641 
642 static EbmlSyntax matroska_attachments[] = {
643  { MATROSKA_ID_ATTACHEDFILE, EBML_NEST, 0, sizeof(MatroskaAttachment), offsetof(MatroskaDemuxContext, attachments), { .n = matroska_attachment } },
645 };
646 
648  { MATROSKA_ID_CHAPSTRING, EBML_UTF8, 0, 0, offsetof(MatroskaChapter, title) },
652 };
653 
655  { MATROSKA_ID_CHAPTERTIMESTART, EBML_UINT, 0, 0, offsetof(MatroskaChapter, start), { .u = AV_NOPTS_VALUE } },
656  { MATROSKA_ID_CHAPTERTIMEEND, EBML_UINT, 0, 0, offsetof(MatroskaChapter, end), { .u = AV_NOPTS_VALUE } },
657  { MATROSKA_ID_CHAPTERUID, EBML_UINT, 0, 0, offsetof(MatroskaChapter, uid) },
664 };
665 
666 static EbmlSyntax matroska_chapter[] = {
667  { MATROSKA_ID_CHAPTERATOM, EBML_NEST, 0, sizeof(MatroskaChapter), offsetof(MatroskaDemuxContext, chapters), { .n = matroska_chapter_entry } },
673 };
674 
675 static EbmlSyntax matroska_chapters[] = {
676  { MATROSKA_ID_EDITIONENTRY, EBML_NEST, 0, 0, 0, { .n = matroska_chapter } },
678 };
679 
680 static EbmlSyntax matroska_index_pos[] = {
681  { MATROSKA_ID_CUETRACK, EBML_UINT, 0, 0, offsetof(MatroskaIndexPos, track) },
687 };
688 
689 static EbmlSyntax matroska_index_entry[] = {
690  { MATROSKA_ID_CUETIME, EBML_UINT, 0, 0, offsetof(MatroskaIndex, time) },
693 };
694 
695 static EbmlSyntax matroska_index[] = {
698 };
699 
700 static EbmlSyntax matroska_simpletag[] = {
701  { MATROSKA_ID_TAGNAME, EBML_UTF8, 0, 0, offsetof(MatroskaTag, name) },
702  { MATROSKA_ID_TAGSTRING, EBML_UTF8, 0, 0, offsetof(MatroskaTag, string) },
703  { MATROSKA_ID_TAGLANG, EBML_STR, 0, 0, offsetof(MatroskaTag, lang), { .s = "und" } },
704  { MATROSKA_ID_TAGDEFAULT, EBML_UINT, 0, 0, offsetof(MatroskaTag, def) },
705  { MATROSKA_ID_TAGDEFAULT_BUG, EBML_UINT, 0, 0, offsetof(MatroskaTag, def) },
706  { MATROSKA_ID_SIMPLETAG, EBML_NEST, 0, sizeof(MatroskaTag), offsetof(MatroskaTag, sub), { .n = matroska_simpletag } },
708 };
709 
710 static EbmlSyntax matroska_tagtargets[] = {
712  { MATROSKA_ID_TAGTARGETS_TYPEVALUE, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, typevalue), { .u = 50 } },
713  { MATROSKA_ID_TAGTARGETS_TRACKUID, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, trackuid), { .u = 0 } },
714  { MATROSKA_ID_TAGTARGETS_CHAPTERUID, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, chapteruid), { .u = 0 } },
715  { MATROSKA_ID_TAGTARGETS_ATTACHUID, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, attachuid), { .u = 0 } },
717 };
718 
719 static EbmlSyntax matroska_tag[] = {
720  { MATROSKA_ID_SIMPLETAG, EBML_NEST, 0, sizeof(MatroskaTag), offsetof(MatroskaTags, tag), { .n = matroska_simpletag } },
721  { MATROSKA_ID_TAGTARGETS, EBML_NEST, 0, 0, offsetof(MatroskaTags, target), { .n = matroska_tagtargets } },
723 };
724 
725 static EbmlSyntax matroska_tags[] = {
726  { MATROSKA_ID_TAG, EBML_NEST, 0, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext, tags), { .n = matroska_tag } },
728 };
729 
731  { MATROSKA_ID_SEEKID, EBML_UINT, 0, 0, offsetof(MatroskaSeekhead, id) },
732  { MATROSKA_ID_SEEKPOSITION, EBML_UINT, 0, 0, offsetof(MatroskaSeekhead, pos), { .u = -1 } },
734 };
735 
736 static EbmlSyntax matroska_seekhead[] = {
737  { MATROSKA_ID_SEEKENTRY, EBML_NEST, 0, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext, seekhead), { .n = matroska_seekhead_entry } },
739 };
740 
741 static EbmlSyntax matroska_segment[] = {
743  { MATROSKA_ID_INFO, EBML_LEVEL1, 0, 0, 0, { .n = matroska_info } },
744  { MATROSKA_ID_TRACKS, EBML_LEVEL1, 0, 0, 0, { .n = matroska_tracks } },
746  { MATROSKA_ID_CHAPTERS, EBML_LEVEL1, 0, 0, 0, { .n = matroska_chapters } },
747  { MATROSKA_ID_CUES, EBML_LEVEL1, 0, 0, 0, { .n = matroska_index } },
748  { MATROSKA_ID_TAGS, EBML_LEVEL1, 0, 0, 0, { .n = matroska_tags } },
749  { MATROSKA_ID_SEEKHEAD, EBML_LEVEL1, 0, 0, 0, { .n = matroska_seekhead } },
750  { 0 } /* We don't want to go back to level 0, so don't add the parent. */
751 };
752 
753 static EbmlSyntax matroska_segments[] = {
754  { MATROSKA_ID_SEGMENT, EBML_NEST, 0, 0, 0, { .n = matroska_segment } },
755  { 0 }
756 };
757 
758 static EbmlSyntax matroska_blockmore[] = {
759  { MATROSKA_ID_BLOCKADDID, EBML_UINT, 0, 0, offsetof(MatroskaBlock,additional_id), { .u = 1 } },
760  { MATROSKA_ID_BLOCKADDITIONAL, EBML_BIN, 0, 0, offsetof(MatroskaBlock,additional) },
762 };
763 
765  { MATROSKA_ID_BLOCKMORE, EBML_NEST, 0, 0, 0, {.n = matroska_blockmore} },
767 };
768 
769 static EbmlSyntax matroska_blockgroup[] = {
770  { MATROSKA_ID_BLOCK, EBML_BIN, 0, 0, offsetof(MatroskaBlock, bin) },
773  { MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, 0, offsetof(MatroskaBlock, discard_padding) },
774  { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 1, 0, offsetof(MatroskaBlock, reference) },
776  { 1, EBML_UINT, 0, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
778 };
779 
780 // The following array contains SimpleBlock and BlockGroup twice
781 // in order to reuse the other values for matroska_cluster_enter.
783  { MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, 0, offsetof(MatroskaBlock, bin) },
784  { MATROSKA_ID_BLOCKGROUP, EBML_NEST, 0, 0, 0, { .n = matroska_blockgroup } },
785  { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, 0, offsetof(MatroskaCluster, timecode) },
791 };
792 
794  { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, 0, { .n = &matroska_cluster_parsing[2] } },
795  { 0 }
796 };
797 #undef CHILD_OF
798 
799 static const CodecMime mkv_image_mime_tags[] = {
800  {"image/gif" , AV_CODEC_ID_GIF},
801  {"image/jpeg" , AV_CODEC_ID_MJPEG},
802  {"image/png" , AV_CODEC_ID_PNG},
803  {"image/tiff" , AV_CODEC_ID_TIFF},
804 
805  {"" , AV_CODEC_ID_NONE}
806 };
807 
808 static const CodecMime mkv_mime_tags[] = {
809  {"application/x-truetype-font", AV_CODEC_ID_TTF},
810  {"application/x-font" , AV_CODEC_ID_TTF},
811  {"application/vnd.ms-opentype", AV_CODEC_ID_OTF},
812  {"binary" , AV_CODEC_ID_BIN_DATA},
813 
814  {"" , AV_CODEC_ID_NONE}
815 };
816 
817 static const char *const matroska_doctypes[] = { "matroska", "webm" };
818 
819 /*
820  * This function prepares the status for parsing of level 1 elements.
821  */
822 static int matroska_reset_status(MatroskaDemuxContext *matroska,
823  uint32_t id, int64_t position)
824 {
825  int64_t err = 0;
826  if (position >= 0) {
827  err = avio_seek(matroska->ctx->pb, position, SEEK_SET);
828  if (err > 0)
829  err = 0;
830  } else
831  position = avio_tell(matroska->ctx->pb);
832 
833  matroska->current_id = id;
834  matroska->num_levels = 1;
835  matroska->unknown_count = 0;
836  matroska->resync_pos = position;
837  if (id)
838  matroska->resync_pos -= (av_log2(id) + 7) / 8;
839 
840  return err;
841 }
842 
843 static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
844 {
845  AVIOContext *pb = matroska->ctx->pb;
846  uint32_t id;
847 
848  /* Try to seek to the last position to resync from. If this doesn't work,
849  * we resync from the earliest position available: The start of the buffer. */
850  if (last_pos < avio_tell(pb) && avio_seek(pb, last_pos + 1, SEEK_SET) < 0) {
851  av_log(matroska->ctx, AV_LOG_WARNING,
852  "Seek to desired resync point failed. Seeking to "
853  "earliest point available instead.\n");
854  avio_seek(pb, FFMAX(avio_tell(pb) + (pb->buffer - pb->buf_ptr),
855  last_pos + 1), SEEK_SET);
856  }
857 
858  id = avio_rb32(pb);
859 
860  // try to find a toplevel element
861  while (!avio_feof(pb)) {
862  if (id == MATROSKA_ID_INFO || id == MATROSKA_ID_TRACKS ||
863  id == MATROSKA_ID_CUES || id == MATROSKA_ID_TAGS ||
865  id == MATROSKA_ID_CLUSTER || id == MATROSKA_ID_CHAPTERS) {
866  /* Prepare the context for parsing of a level 1 element. */
867  matroska_reset_status(matroska, id, -1);
868  /* Given that we are here means that an error has occurred,
869  * so treat the segment as unknown length in order not to
870  * discard valid data that happens to be beyond the designated
871  * end of the segment. */
872  matroska->levels[0].length = EBML_UNKNOWN_LENGTH;
873  return 0;
874  }
875  id = (id << 8) | avio_r8(pb);
876  }
877 
878  matroska->done = 1;
879  return pb->error ? pb->error : AVERROR_EOF;
880 }
881 
882 /*
883  * Read: an "EBML number", which is defined as a variable-length
884  * array of bytes. The first byte indicates the length by giving a
885  * number of 0-bits followed by a one. The position of the first
886  * "one" bit inside the first byte indicates the length of this
887  * number.
888  * Returns: number of bytes read, < 0 on error
889  */
890 static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb,
891  int max_size, uint64_t *number, int eof_forbidden)
892 {
893  int read, n = 1;
894  uint64_t total;
895  int64_t pos;
896 
897  /* The first byte tells us the length in bytes - except when it is zero. */
898  total = avio_r8(pb);
899  if (pb->eof_reached)
900  goto err;
901 
902  /* get the length of the EBML number */
903  read = 8 - ff_log2_tab[total];
904 
905  if (!total || read > max_size) {
906  pos = avio_tell(pb) - 1;
907  if (!total) {
908  av_log(matroska->ctx, AV_LOG_ERROR,
909  "0x00 at pos %"PRId64" (0x%"PRIx64") invalid as first byte "
910  "of an EBML number\n", pos, pos);
911  } else {
912  av_log(matroska->ctx, AV_LOG_ERROR,
913  "Length %d indicated by an EBML number's first byte 0x%02x "
914  "at pos %"PRId64" (0x%"PRIx64") exceeds max length %d.\n",
915  read, (uint8_t) total, pos, pos, max_size);
916  }
917  return AVERROR_INVALIDDATA;
918  }
919 
920  /* read out length */
921  total ^= 1 << ff_log2_tab[total];
922  while (n++ < read)
923  total = (total << 8) | avio_r8(pb);
924 
925  if (pb->eof_reached) {
926  eof_forbidden = 1;
927  goto err;
928  }
929 
930  *number = total;
931 
932  return read;
933 
934 err:
935  pos = avio_tell(pb);
936  if (pb->error) {
937  av_log(matroska->ctx, AV_LOG_ERROR,
938  "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
939  pos, pos);
940  return pb->error;
941  }
942  if (eof_forbidden) {
943  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely "
944  "at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
945  return AVERROR(EIO);
946  }
947  return AVERROR_EOF;
948 }
949 
950 /**
951  * Read a EBML length value.
952  * This needs special handling for the "unknown length" case which has multiple
953  * encodings.
954  */
955 static int ebml_read_length(MatroskaDemuxContext *matroska, AVIOContext *pb,
956  uint64_t *number)
957 {
958  int res = ebml_read_num(matroska, pb, 8, number, 1);
959  if (res > 0 && *number + 1 == 1ULL << (7 * res))
960  *number = EBML_UNKNOWN_LENGTH;
961  return res;
962 }
963 
964 /*
965  * Read the next element as an unsigned int.
966  * Returns NEEDS_CHECKING unless size == 0.
967  */
968 static int ebml_read_uint(AVIOContext *pb, int size,
969  uint64_t default_value, uint64_t *num)
970 {
971  int n = 0;
972 
973  if (size == 0) {
974  *num = default_value;
975  return 0;
976  }
977  /* big-endian ordering; build up number */
978  *num = 0;
979  while (n++ < size)
980  *num = (*num << 8) | avio_r8(pb);
981 
982  return NEEDS_CHECKING;
983 }
984 
985 /*
986  * Read the next element as a signed int.
987  * Returns NEEDS_CHECKING unless size == 0.
988  */
989 static int ebml_read_sint(AVIOContext *pb, int size,
990  int64_t default_value, int64_t *num)
991 {
992  int n = 1;
993 
994  if (size == 0) {
995  *num = default_value;
996  return 0;
997  } else {
998  *num = sign_extend(avio_r8(pb), 8);
999 
1000  /* big-endian ordering; build up number */
1001  while (n++ < size)
1002  *num = ((uint64_t)*num << 8) | avio_r8(pb);
1003  }
1004 
1005  return NEEDS_CHECKING;
1007 
1008 /*
1009  * Read the next element as a float.
1010  * Returns 0 if size == 0, NEEDS_CHECKING or < 0 on obvious failure.
1011  */
1012 static int ebml_read_float(AVIOContext *pb, int size,
1013  double default_value, double *num)
1014 {
1015  if (size == 0) {
1016  *num = default_value;
1017  return 0;
1018  } else if (size == 4) {
1019  *num = av_int2float(avio_rb32(pb));
1020  } else if (size == 8) {
1021  *num = av_int2double(avio_rb64(pb));
1022  } else
1023  return AVERROR_INVALIDDATA;
1024 
1025  return NEEDS_CHECKING;
1027 
1028 /*
1029  * Read the next element as an ASCII string.
1030  * 0 is success, < 0 or NEEDS_CHECKING is failure.
1031  */
1032 static int ebml_read_ascii(AVIOContext *pb, int size,
1033  const char *default_value, char **str)
1034 {
1035  char *res;
1036  int ret;
1037 
1038  if (size == 0 && default_value) {
1039  res = av_strdup(default_value);
1040  if (!res)
1041  return AVERROR(ENOMEM);
1042  } else {
1043  /* EBML strings are usually not 0-terminated, so we allocate one
1044  * byte more, read the string and NUL-terminate it ourselves. */
1045  if (!(res = av_malloc(size + 1)))
1046  return AVERROR(ENOMEM);
1047  if ((ret = avio_read(pb, (uint8_t *) res, size)) != size) {
1048  av_free(res);
1049  return ret < 0 ? ret : NEEDS_CHECKING;
1050  }
1051  (res)[size] = '\0';
1052  }
1053  av_free(*str);
1054  *str = res;
1055 
1056  return 0;
1058 
1059 /*
1060  * Read the next element as binary data.
1061  * 0 is success, < 0 or NEEDS_CHECKING is failure.
1062  */
1063 static int ebml_read_binary(AVIOContext *pb, int length,
1064  int64_t pos, EbmlBin *bin)
1065 {
1066  int ret;
1067 
1069  if (ret < 0)
1070  return ret;
1071  memset(bin->buf->data + length, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1072 
1073  bin->data = bin->buf->data;
1074  bin->size = length;
1075  bin->pos = pos;
1076  if ((ret = avio_read(pb, bin->data, length)) != length) {
1077  av_buffer_unref(&bin->buf);
1078  bin->data = NULL;
1079  bin->size = 0;
1080  return ret < 0 ? ret : NEEDS_CHECKING;
1081  }
1082 
1083  return 0;
1084 }
1086 /*
1087  * Read the next element, but only the header. The contents
1088  * are supposed to be sub-elements which can be read separately.
1089  * 0 is success, < 0 is failure.
1090  */
1091 static int ebml_read_master(MatroskaDemuxContext *matroska,
1092  uint64_t length, int64_t pos)
1093 {
1095 
1096  if (matroska->num_levels >= EBML_MAX_DEPTH) {
1097  av_log(matroska->ctx, AV_LOG_ERROR,
1098  "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
1099  return AVERROR(ENOSYS);
1100  }
1101 
1102  level = &matroska->levels[matroska->num_levels++];
1103  level->start = pos;
1104  level->length = length;
1105 
1106  return 0;
1108 
1109 /*
1110  * Read a signed "EBML number"
1111  * Return: number of bytes processed, < 0 on error
1112  */
1113 static int matroska_ebmlnum_sint(MatroskaDemuxContext *matroska,
1114  AVIOContext *pb, int64_t *num)
1115 {
1116  uint64_t unum;
1117  int res;
1118 
1119  /* read as unsigned number first */
1120  if ((res = ebml_read_num(matroska, pb, 8, &unum, 1)) < 0)
1121  return res;
1122 
1123  /* make signed (weird way) */
1124  *num = unum - ((1LL << (7 * res - 1)) - 1);
1125 
1126  return res;
1127 }
1128 
1129 static int ebml_parse(MatroskaDemuxContext *matroska,
1130  EbmlSyntax *syntax, void *data);
1131 
1132 static EbmlSyntax *ebml_parse_id(EbmlSyntax *syntax, uint32_t id)
1133 {
1134  int i;
1135 
1136  // Whoever touches this should be aware of the duplication
1137  // existing in matroska_cluster_parsing.
1138  for (i = 0; syntax[i].id; i++)
1139  if (id == syntax[i].id)
1140  break;
1141 
1142  return &syntax[i];
1143 }
1144 
1145 static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
1146  void *data)
1147 {
1148  int res;
1149 
1150  if (data) {
1151  for (int i = 0; syntax[i].id; i++) {
1152  void *dst = (char *)data + syntax[i].data_offset;
1153  switch (syntax[i].type) {
1154  case EBML_UINT:
1155  *(uint64_t *)dst = syntax[i].def.u;
1156  break;
1157  case EBML_SINT:
1158  *(int64_t *) dst = syntax[i].def.i;
1159  break;
1160  case EBML_FLOAT:
1161  *(double *) dst = syntax[i].def.f;
1162  break;
1163  case EBML_STR:
1164  case EBML_UTF8:
1165  // the default may be NULL
1166  if (syntax[i].def.s) {
1167  *(char**)dst = av_strdup(syntax[i].def.s);
1168  if (!*(char**)dst)
1169  return AVERROR(ENOMEM);
1170  }
1171  break;
1172  }
1173  }
1174 
1175  if (!matroska->levels[matroska->num_levels - 1].length) {
1176  matroska->num_levels--;
1177  return 0;
1178  }
1179  }
1180 
1181  do {
1182  res = ebml_parse(matroska, syntax, data);
1183  } while (!res);
1184 
1185  return res == LEVEL_ENDED ? 0 : res;
1186 }
1187 
1188 static int is_ebml_id_valid(uint32_t id)
1189 {
1190  // Due to endian nonsense in Matroska, the highest byte with any bits set
1191  // will contain the leading length bit. This bit in turn identifies the
1192  // total byte length of the element by its position within the byte.
1193  unsigned int bits = av_log2(id);
1194  return id && (bits + 7) / 8 == (8 - bits % 8);
1196 
1197 /*
1198  * Allocate and return the entry for the level1 element with the given ID. If
1199  * an entry already exists, return the existing entry.
1200  */
1202  uint32_t id, int64_t pos)
1203 {
1204  int i;
1205  MatroskaLevel1Element *elem;
1206 
1207  if (!is_ebml_id_valid(id))
1208  return NULL;
1209 
1210  // Some files link to all clusters; useless.
1211  if (id == MATROSKA_ID_CLUSTER)
1212  return NULL;
1213 
1214  // There can be multiple SeekHeads and Tags.
1215  for (i = 0; i < matroska->num_level1_elems; i++) {
1216  if (matroska->level1_elems[i].id == id) {
1217  if (matroska->level1_elems[i].pos == pos ||
1218  id != MATROSKA_ID_SEEKHEAD && id != MATROSKA_ID_TAGS)
1219  return &matroska->level1_elems[i];
1220  }
1221  }
1222 
1223  // Only a completely broken file would have more elements.
1224  if (matroska->num_level1_elems >= FF_ARRAY_ELEMS(matroska->level1_elems)) {
1225  av_log(matroska->ctx, AV_LOG_ERROR, "Too many level1 elements.\n");
1226  return NULL;
1227  }
1228 
1229  elem = &matroska->level1_elems[matroska->num_level1_elems++];
1230  *elem = (MatroskaLevel1Element){.id = id};
1231 
1232  return elem;
1233 }
1234 
1235 static int ebml_parse(MatroskaDemuxContext *matroska,
1236  EbmlSyntax *syntax, void *data)
1237 {
1238  static const uint64_t max_lengths[EBML_TYPE_COUNT] = {
1239  // Forbid unknown-length EBML_NONE elements.
1241  [EBML_UINT] = 8,
1242  [EBML_SINT] = 8,
1243  [EBML_FLOAT] = 8,
1244  // max. 16 MB for strings
1245  [EBML_STR] = 0x1000000,
1246  [EBML_UTF8] = 0x1000000,
1247  // max. 256 MB for binary data
1248  [EBML_BIN] = 0x10000000,
1249  // no limits for anything else
1250  };
1251  AVIOContext *pb = matroska->ctx->pb;
1252  uint32_t id;
1253  uint64_t length;
1254  int64_t pos = avio_tell(pb), pos_alt;
1255  int res, update_pos = 1, level_check;
1256  MatroskaLevel1Element *level1_elem;
1257  MatroskaLevel *level = matroska->num_levels ? &matroska->levels[matroska->num_levels - 1] : NULL;
1258 
1259  if (!matroska->current_id) {
1260  uint64_t id;
1261  res = ebml_read_num(matroska, pb, 4, &id, 0);
1262  if (res < 0) {
1263  if (pb->eof_reached && res == AVERROR_EOF) {
1264  if (matroska->is_live)
1265  // in live mode, finish parsing if EOF is reached.
1266  return 1;
1267  if (level && pos == avio_tell(pb)) {
1268  if (level->length == EBML_UNKNOWN_LENGTH) {
1269  // Unknown-length levels automatically end at EOF.
1270  matroska->num_levels--;
1271  return LEVEL_ENDED;
1272  } else {
1273  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely "
1274  "at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
1275  }
1276  }
1277  }
1278  return res;
1279  }
1280  matroska->current_id = id | 1 << 7 * res;
1281  pos_alt = pos + res;
1282  } else {
1283  pos_alt = pos;
1284  pos -= (av_log2(matroska->current_id) + 7) / 8;
1285  }
1286 
1287  id = matroska->current_id;
1288 
1289  syntax = ebml_parse_id(syntax, id);
1290  if (!syntax->id && id != EBML_ID_VOID && id != EBML_ID_CRC32) {
1291  if (level && level->length == EBML_UNKNOWN_LENGTH) {
1292  // Unknown-length levels end when an element from an upper level
1293  // in the hierarchy is encountered.
1294  while (syntax->def.n) {
1295  syntax = ebml_parse_id(syntax->def.n, id);
1296  if (syntax->id) {
1297  matroska->num_levels--;
1298  return LEVEL_ENDED;
1299  }
1300  };
1301  }
1302 
1303  av_log(matroska->ctx, AV_LOG_DEBUG, "Unknown entry 0x%"PRIX32" at pos. "
1304  "%"PRId64"\n", id, pos);
1305  update_pos = 0; /* Don't update resync_pos as an error might have happened. */
1306  }
1307 
1308  if (data) {
1309  data = (char *) data + syntax->data_offset;
1310  if (syntax->list_elem_size) {
1311  EbmlList *list = data;
1312  void *newelem;
1313 
1314  if ((unsigned)list->nb_elem + 1 >= UINT_MAX / syntax->list_elem_size)
1315  return AVERROR(ENOMEM);
1316  newelem = av_fast_realloc(list->elem,
1317  &list->alloc_elem_size,
1318  (list->nb_elem + 1) * syntax->list_elem_size);
1319  if (!newelem)
1320  return AVERROR(ENOMEM);
1321  list->elem = newelem;
1322  data = (char *) list->elem + list->nb_elem * syntax->list_elem_size;
1323  memset(data, 0, syntax->list_elem_size);
1324  list->nb_elem++;
1325  }
1326  }
1327 
1328  if (syntax->type != EBML_STOP) {
1329  matroska->current_id = 0;
1330  if ((res = ebml_read_length(matroska, pb, &length)) < 0)
1331  return res;
1332 
1333  pos_alt += res;
1334 
1335  if (matroska->num_levels > 0) {
1336  if (length != EBML_UNKNOWN_LENGTH &&
1337  level->length != EBML_UNKNOWN_LENGTH) {
1338  uint64_t elem_end = pos_alt + length,
1339  level_end = level->start + level->length;
1340 
1341  if (elem_end < level_end) {
1342  level_check = 0;
1343  } else if (elem_end == level_end) {
1344  level_check = LEVEL_ENDED;
1345  } else {
1346  av_log(matroska->ctx, AV_LOG_ERROR,
1347  "Element at 0x%"PRIx64" ending at 0x%"PRIx64" exceeds "
1348  "containing master element ending at 0x%"PRIx64"\n",
1349  pos, elem_end, level_end);
1350  return AVERROR_INVALIDDATA;
1351  }
1352  } else if (length != EBML_UNKNOWN_LENGTH) {
1353  level_check = 0;
1354  } else if (level->length != EBML_UNKNOWN_LENGTH) {
1355  av_log(matroska->ctx, AV_LOG_ERROR, "Unknown-sized element "
1356  "at 0x%"PRIx64" inside parent with finite size\n", pos);
1357  return AVERROR_INVALIDDATA;
1358  } else {
1359  level_check = 0;
1360  if (id != MATROSKA_ID_CLUSTER && (syntax->type == EBML_LEVEL1
1361  || syntax->type == EBML_NEST)) {
1362  // According to the current specifications only clusters and
1363  // segments are allowed to be unknown-length. We also accept
1364  // other unknown-length master elements.
1365  av_log(matroska->ctx, AV_LOG_WARNING,
1366  "Found unknown-length element 0x%"PRIX32" other than "
1367  "a cluster at 0x%"PRIx64". Spec-incompliant, but "
1368  "parsing will nevertheless be attempted.\n", id, pos);
1369  update_pos = -1;
1370  }
1371  }
1372  } else
1373  level_check = 0;
1374 
1375  if (max_lengths[syntax->type] && length > max_lengths[syntax->type]) {
1376  if (length != EBML_UNKNOWN_LENGTH) {
1377  av_log(matroska->ctx, AV_LOG_ERROR,
1378  "Invalid length 0x%"PRIx64" > 0x%"PRIx64" for element "
1379  "with ID 0x%"PRIX32" at 0x%"PRIx64"\n",
1380  length, max_lengths[syntax->type], id, pos);
1381  } else if (syntax->type != EBML_NONE) {
1382  av_log(matroska->ctx, AV_LOG_ERROR,
1383  "Element with ID 0x%"PRIX32" at pos. 0x%"PRIx64" has "
1384  "unknown length, yet the length of an element of its "
1385  "type must be known.\n", id, pos);
1386  } else {
1387  av_log(matroska->ctx, AV_LOG_ERROR,
1388  "Found unknown-length element with ID 0x%"PRIX32" at "
1389  "pos. 0x%"PRIx64" for which no syntax for parsing is "
1390  "available.\n", id, pos);
1391  }
1392  return AVERROR_INVALIDDATA;
1393  }
1394 
1395  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1396  // Loosing sync will likely manifest itself as encountering unknown
1397  // elements which are not reliably distinguishable from elements
1398  // belonging to future extensions of the format.
1399  // We use a heuristic to detect such situations: If the current
1400  // element is not expected at the current syntax level and there
1401  // were only a few unknown elements in a row, then the element is
1402  // skipped or considered defective based upon the length of the
1403  // current element (i.e. how much would be skipped); if there were
1404  // more than a few skipped elements in a row and skipping the current
1405  // element would lead us more than SKIP_THRESHOLD away from the last
1406  // known good position, then it is inferred that an error occurred.
1407  // The dependency on the number of unknown elements in a row exists
1408  // because the distance to the last known good position is
1409  // automatically big if the last parsed element was big.
1410  // In both cases, each unknown element is considered equivalent to
1411  // UNKNOWN_EQUIV of skipped bytes for the check.
1412  // The whole check is only done for non-seekable output, because
1413  // in this situation skipped data can't simply be rechecked later.
1414  // This is especially important when using unkown length elements
1415  // as the check for whether a child exceeds its containing master
1416  // element is not effective in this situation.
1417  if (update_pos) {
1418  matroska->unknown_count = 0;
1419  } else {
1420  int64_t dist = length + UNKNOWN_EQUIV * matroska->unknown_count++;
1421 
1422  if (matroska->unknown_count > 3)
1423  dist += pos_alt - matroska->resync_pos;
1424 
1425  if (dist > SKIP_THRESHOLD) {
1426  av_log(matroska->ctx, AV_LOG_ERROR,
1427  "Unknown element %"PRIX32" at pos. 0x%"PRIx64" with "
1428  "length 0x%"PRIx64" considered as invalid data. Last "
1429  "known good position 0x%"PRIx64", %d unknown elements"
1430  " in a row\n", id, pos, length, matroska->resync_pos,
1431  matroska->unknown_count);
1432  return AVERROR_INVALIDDATA;
1433  }
1434  }
1435  }
1436 
1437  if (update_pos > 0) {
1438  // We have found an element that is allowed at this place
1439  // in the hierarchy and it passed all checks, so treat the beginning
1440  // of the element as the "last known good" position.
1441  matroska->resync_pos = pos;
1442  }
1443 
1444  if (!data && length != EBML_UNKNOWN_LENGTH)
1445  goto skip;
1446  }
1447 
1448  switch (syntax->type) {
1449  case EBML_UINT:
1450  res = ebml_read_uint(pb, length, syntax->def.u, data);
1451  break;
1452  case EBML_SINT:
1453  res = ebml_read_sint(pb, length, syntax->def.i, data);
1454  break;
1455  case EBML_FLOAT:
1456  res = ebml_read_float(pb, length, syntax->def.f, data);
1457  break;
1458  case EBML_STR:
1459  case EBML_UTF8:
1460  res = ebml_read_ascii(pb, length, syntax->def.s, data);
1461  break;
1462  case EBML_BIN:
1463  res = ebml_read_binary(pb, length, pos_alt, data);
1464  break;
1465  case EBML_LEVEL1:
1466  case EBML_NEST:
1467  if ((res = ebml_read_master(matroska, length, pos_alt)) < 0)
1468  return res;
1469  if (id == MATROSKA_ID_SEGMENT)
1470  matroska->segment_start = pos_alt;
1471  if (id == MATROSKA_ID_CUES)
1472  matroska->cues_parsing_deferred = 0;
1473  if (syntax->type == EBML_LEVEL1 &&
1474  (level1_elem = matroska_find_level1_elem(matroska, syntax->id, pos))) {
1475  if (!level1_elem->pos) {
1476  // Zero is not a valid position for a level 1 element.
1477  level1_elem->pos = pos;
1478  } else if (level1_elem->pos != pos)
1479  av_log(matroska->ctx, AV_LOG_ERROR, "Duplicate element\n");
1480  level1_elem->parsed = 1;
1481  }
1482  if (res = ebml_parse_nest(matroska, syntax->def.n, data))
1483  return res;
1484  break;
1485  case EBML_STOP:
1486  return 1;
1487  skip:
1488  default:
1489  if (length) {
1490  int64_t res2;
1491  if (ffio_limit(pb, length) != length) {
1492  // ffio_limit emits its own error message,
1493  // so we don't have to.
1494  return AVERROR(EIO);
1495  }
1496  if ((res2 = avio_skip(pb, length - 1)) >= 0) {
1497  // avio_skip might take us past EOF. We check for this
1498  // by skipping only length - 1 bytes, reading a byte and
1499  // checking the error flags. This is done in order to check
1500  // that the element has been properly skipped even when
1501  // no filesize (that ffio_limit relies on) is available.
1502  avio_r8(pb);
1503  res = NEEDS_CHECKING;
1504  } else
1505  res = res2;
1506  } else
1507  res = 0;
1508  }
1509  if (res) {
1510  if (res == NEEDS_CHECKING) {
1511  if (pb->eof_reached) {
1512  if (pb->error)
1513  res = pb->error;
1514  else
1515  res = AVERROR_EOF;
1516  } else
1517  goto level_check;
1518  }
1519 
1520  if (res == AVERROR_INVALIDDATA)
1521  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
1522  else if (res == AVERROR(EIO))
1523  av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
1524  else if (res == AVERROR_EOF) {
1525  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely\n");
1526  res = AVERROR(EIO);
1527  }
1528 
1529  return res;
1530  }
1531 
1532 level_check:
1533  if (syntax->is_counted && data) {
1534  CountedElement *elem = data;
1535  if (elem->count != UINT_MAX)
1536  elem->count++;
1537  }
1538 
1539  if (level_check == LEVEL_ENDED && matroska->num_levels) {
1540  level = &matroska->levels[matroska->num_levels - 1];
1541  pos = avio_tell(pb);
1542 
1543  // Given that pos >= level->start no check for
1544  // level->length != EBML_UNKNOWN_LENGTH is necessary.
1545  while (matroska->num_levels && pos == level->start + level->length) {
1546  matroska->num_levels--;
1547  level--;
1548  }
1549  }
1550 
1551  return level_check;
1552 }
1553 
1554 static void ebml_free(EbmlSyntax *syntax, void *data)
1555 {
1556  int i, j;
1557  for (i = 0; syntax[i].id; i++) {
1558  void *data_off = (char *) data + syntax[i].data_offset;
1559  switch (syntax[i].type) {
1560  case EBML_STR:
1561  case EBML_UTF8:
1562  av_freep(data_off);
1563  break;
1564  case EBML_BIN:
1565  av_buffer_unref(&((EbmlBin *) data_off)->buf);
1566  break;
1567  case EBML_LEVEL1:
1568  case EBML_NEST:
1569  if (syntax[i].list_elem_size) {
1570  EbmlList *list = data_off;
1571  char *ptr = list->elem;
1572  for (j = 0; j < list->nb_elem;
1573  j++, ptr += syntax[i].list_elem_size)
1574  ebml_free(syntax[i].def.n, ptr);
1575  av_freep(&list->elem);
1576  list->nb_elem = 0;
1577  list->alloc_elem_size = 0;
1578  } else
1579  ebml_free(syntax[i].def.n, data_off);
1580  default:
1581  break;
1582  }
1583  }
1584 }
1585 
1586 /*
1587  * Autodetecting...
1588  */
1589 static int matroska_probe(const AVProbeData *p)
1590 {
1591  uint64_t total = 0;
1592  int len_mask = 0x80, size = 1, n = 1, i;
1593 
1594  /* EBML header? */
1595  if (AV_RB32(p->buf) != EBML_ID_HEADER)
1596  return 0;
1597 
1598  /* length of header */
1599  total = p->buf[4];
1600  while (size <= 8 && !(total & len_mask)) {
1601  size++;
1602  len_mask >>= 1;
1603  }
1604  if (size > 8)
1605  return 0;
1606  total &= (len_mask - 1);
1607  while (n < size)
1608  total = (total << 8) | p->buf[4 + n++];
1609 
1610  if (total + 1 == 1ULL << (7 * size)){
1611  /* Unknown-length header - simply parse the whole buffer. */
1612  total = p->buf_size - 4 - size;
1613  } else {
1614  /* Does the probe data contain the whole header? */
1615  if (p->buf_size < 4 + size + total)
1616  return 0;
1617  }
1618 
1619  /* The header should contain a known document type. For now,
1620  * we don't parse the whole header but simply check for the
1621  * availability of that array of characters inside the header.
1622  * Not fully fool-proof, but good enough. */
1623  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++) {
1624  size_t probelen = strlen(matroska_doctypes[i]);
1625  if (total < probelen)
1626  continue;
1627  for (n = 4 + size; n <= 4 + size + total - probelen; n++)
1628  if (!memcmp(p->buf + n, matroska_doctypes[i], probelen))
1629  return AVPROBE_SCORE_MAX;
1630  }
1631 
1632  // probably valid EBML header but no recognized doctype
1633  return AVPROBE_SCORE_EXTENSION;
1634 }
1635 
1637  uint64_t num)
1638 {
1639  MatroskaTrack *tracks = matroska->tracks.elem;
1640  int i;
1641 
1642  for (i = 0; i < matroska->tracks.nb_elem; i++)
1643  if (tracks[i].num == num)
1644  return &tracks[i];
1645 
1646  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %"PRIu64"\n", num);
1647  return NULL;
1648 }
1649 
1650 static int matroska_decode_buffer(uint8_t **buf, int *buf_size,
1651  MatroskaTrack *track)
1652 {
1653  MatroskaTrackEncoding *encodings = track->encodings.elem;
1654  uint8_t *data = *buf;
1655  int isize = *buf_size;
1656  uint8_t *pkt_data = NULL;
1657  uint8_t av_unused *newpktdata;
1658  int pkt_size = isize;
1659  int result = 0;
1660  int olen;
1661 
1662  if (pkt_size >= 10000000U)
1663  return AVERROR_INVALIDDATA;
1664 
1665  switch (encodings[0].compression.algo) {
1667  {
1668  int header_size = encodings[0].compression.settings.size;
1669  uint8_t *header = encodings[0].compression.settings.data;
1670 
1671  if (header_size && !header) {
1672  av_log(NULL, AV_LOG_ERROR, "Compression size but no data in headerstrip\n");
1673  return -1;
1674  }
1675 
1676  if (!header_size)
1677  return 0;
1678 
1679  pkt_size = isize + header_size;
1680  pkt_data = av_malloc(pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1681  if (!pkt_data)
1682  return AVERROR(ENOMEM);
1683 
1684  memcpy(pkt_data, header, header_size);
1685  memcpy(pkt_data + header_size, data, isize);
1686  break;
1687  }
1689  do {
1690  int insize = isize;
1691  olen = pkt_size *= 3;
1692  newpktdata = av_realloc(pkt_data, pkt_size + AV_LZO_OUTPUT_PADDING
1694  if (!newpktdata) {
1695  result = AVERROR(ENOMEM);
1696  goto failed;
1697  }
1698  pkt_data = newpktdata;
1699  result = av_lzo1x_decode(pkt_data, &olen, data, &insize);
1700  } while (result == AV_LZO_OUTPUT_FULL && pkt_size < 10000000);
1701  if (result) {
1703  goto failed;
1704  }
1705  pkt_size -= olen;
1706  break;
1707 #if CONFIG_ZLIB
1709  {
1710  z_stream zstream = { 0 };
1711  if (!pkt_size || inflateInit(&zstream) != Z_OK)
1712  return -1;
1713  zstream.next_in = data;
1714  zstream.avail_in = isize;
1715  do {
1716  pkt_size *= 3;
1717  newpktdata = av_realloc(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1718  if (!newpktdata) {
1719  inflateEnd(&zstream);
1720  result = AVERROR(ENOMEM);
1721  goto failed;
1722  }
1723  pkt_data = newpktdata;
1724  zstream.avail_out = pkt_size - zstream.total_out;
1725  zstream.next_out = pkt_data + zstream.total_out;
1726  result = inflate(&zstream, Z_NO_FLUSH);
1727  } while (result == Z_OK && pkt_size < 10000000);
1728  pkt_size = zstream.total_out;
1729  inflateEnd(&zstream);
1730  if (result != Z_STREAM_END) {
1731  if (result == Z_MEM_ERROR)
1732  result = AVERROR(ENOMEM);
1733  else
1735  goto failed;
1736  }
1737  break;
1738  }
1739 #endif
1740 #if CONFIG_BZLIB
1742  {
1743  bz_stream bzstream = { 0 };
1744  if (!pkt_size || BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
1745  return -1;
1746  bzstream.next_in = data;
1747  bzstream.avail_in = isize;
1748  do {
1749  pkt_size *= 3;
1750  newpktdata = av_realloc(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1751  if (!newpktdata) {
1752  BZ2_bzDecompressEnd(&bzstream);
1753  result = AVERROR(ENOMEM);
1754  goto failed;
1755  }
1756  pkt_data = newpktdata;
1757  bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
1758  bzstream.next_out = pkt_data + bzstream.total_out_lo32;
1759  result = BZ2_bzDecompress(&bzstream);
1760  } while (result == BZ_OK && pkt_size < 10000000);
1761  pkt_size = bzstream.total_out_lo32;
1762  BZ2_bzDecompressEnd(&bzstream);
1763  if (result != BZ_STREAM_END) {
1764  if (result == BZ_MEM_ERROR)
1765  result = AVERROR(ENOMEM);
1766  else
1768  goto failed;
1769  }
1770  break;
1771  }
1772 #endif
1773  default:
1774  return AVERROR_INVALIDDATA;
1775  }
1776 
1777  memset(pkt_data + pkt_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1778 
1779  *buf = pkt_data;
1780  *buf_size = pkt_size;
1781  return 0;
1783 failed:
1784  av_free(pkt_data);
1785  return result;
1786 }
1787 
1789  AVDictionary **metadata, char *prefix)
1790 {
1791  MatroskaTag *tags = list->elem;
1792  char key[1024];
1793  int i;
1794 
1795  for (i = 0; i < list->nb_elem; i++) {
1796  const char *lang = tags[i].lang &&
1797  strcmp(tags[i].lang, "und") ? tags[i].lang : NULL;
1798 
1799  if (!tags[i].name) {
1800  av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no TagName.\n");
1801  continue;
1802  }
1803  if (prefix)
1804  snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
1805  else
1806  av_strlcpy(key, tags[i].name, sizeof(key));
1807  if (tags[i].def || !lang) {
1808  av_dict_set(metadata, key, tags[i].string, 0);
1809  if (tags[i].sub.nb_elem)
1810  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1811  }
1812  if (lang) {
1813  av_strlcat(key, "-", sizeof(key));
1814  av_strlcat(key, lang, sizeof(key));
1815  av_dict_set(metadata, key, tags[i].string, 0);
1816  if (tags[i].sub.nb_elem)
1817  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1818  }
1819  }
1821 }
1822 
1824 {
1825  MatroskaDemuxContext *matroska = s->priv_data;
1826  MatroskaTags *tags = matroska->tags.elem;
1827  int i, j;
1828 
1829  for (i = 0; i < matroska->tags.nb_elem; i++) {
1830  if (tags[i].target.attachuid) {
1831  MatroskaAttachment *attachment = matroska->attachments.elem;
1832  int found = 0;
1833  for (j = 0; j < matroska->attachments.nb_elem; j++) {
1834  if (attachment[j].uid == tags[i].target.attachuid &&
1835  attachment[j].stream) {
1836  matroska_convert_tag(s, &tags[i].tag,
1837  &attachment[j].stream->metadata, NULL);
1838  found = 1;
1839  }
1840  }
1841  if (!found) {
1843  "The tags at index %d refer to a "
1844  "non-existent attachment %"PRId64".\n",
1845  i, tags[i].target.attachuid);
1846  }
1847  } else if (tags[i].target.chapteruid) {
1848  MatroskaChapter *chapter = matroska->chapters.elem;
1849  int found = 0;
1850  for (j = 0; j < matroska->chapters.nb_elem; j++) {
1851  if (chapter[j].uid == tags[i].target.chapteruid &&
1852  chapter[j].chapter) {
1853  matroska_convert_tag(s, &tags[i].tag,
1854  &chapter[j].chapter->metadata, NULL);
1855  found = 1;
1856  }
1857  }
1858  if (!found) {
1860  "The tags at index %d refer to a non-existent chapter "
1861  "%"PRId64".\n",
1862  i, tags[i].target.chapteruid);
1863  }
1864  } else if (tags[i].target.trackuid) {
1865  MatroskaTrack *track = matroska->tracks.elem;
1866  int found = 0;
1867  for (j = 0; j < matroska->tracks.nb_elem; j++) {
1868  if (track[j].uid == tags[i].target.trackuid &&
1869  track[j].stream) {
1870  matroska_convert_tag(s, &tags[i].tag,
1871  &track[j].stream->metadata, NULL);
1872  found = 1;
1873  }
1874  }
1875  if (!found) {
1877  "The tags at index %d refer to a non-existent track "
1878  "%"PRId64".\n",
1879  i, tags[i].target.trackuid);
1880  }
1881  } else {
1882  matroska_convert_tag(s, &tags[i].tag, &s->metadata,
1883  tags[i].target.type);
1884  }
1885  }
1886 }
1887 
1889  int64_t pos)
1890 {
1891  uint32_t saved_id = matroska->current_id;
1892  int64_t before_pos = avio_tell(matroska->ctx->pb);
1893  int ret = 0;
1894  int ret2;
1895 
1896  /* seek */
1897  if (avio_seek(matroska->ctx->pb, pos, SEEK_SET) == pos) {
1898  /* We don't want to lose our seekhead level, so we add
1899  * a dummy. This is a crude hack. */
1900  if (matroska->num_levels == EBML_MAX_DEPTH) {
1901  av_log(matroska->ctx, AV_LOG_INFO,
1902  "Max EBML element depth (%d) reached, "
1903  "cannot parse further.\n", EBML_MAX_DEPTH);
1905  } else {
1906  matroska->levels[matroska->num_levels] = (MatroskaLevel) { 0, EBML_UNKNOWN_LENGTH };
1907  matroska->num_levels++;
1908  matroska->current_id = 0;
1909 
1910  ret = ebml_parse(matroska, matroska_segment, matroska);
1911  if (ret == LEVEL_ENDED) {
1912  /* This can only happen if the seek brought us beyond EOF. */
1913  ret = AVERROR_EOF;
1914  }
1915  }
1916  }
1917  /* Seek back - notice that in all instances where this is used
1918  * it is safe to set the level to 1. */
1919  ret2 = matroska_reset_status(matroska, saved_id, before_pos);
1920  if (ret >= 0)
1921  ret = ret2;
1922 
1923  return ret;
1924 }
1925 
1926 static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
1927 {
1928  EbmlList *seekhead_list = &matroska->seekhead;
1929  int i;
1930 
1931  // we should not do any seeking in the streaming case
1932  if (!(matroska->ctx->pb->seekable & AVIO_SEEKABLE_NORMAL))
1933  return;
1934 
1935  for (i = 0; i < seekhead_list->nb_elem; i++) {
1936  MatroskaSeekhead *seekheads = seekhead_list->elem;
1937  uint32_t id = seekheads[i].id;
1938  int64_t pos = seekheads[i].pos + matroska->segment_start;
1939  MatroskaLevel1Element *elem;
1940 
1941  if (id != seekheads[i].id || pos < matroska->segment_start)
1942  continue;
1943 
1944  elem = matroska_find_level1_elem(matroska, id, pos);
1945  if (!elem || elem->parsed)
1946  continue;
1947 
1948  elem->pos = pos;
1949 
1950  // defer cues parsing until we actually need cue data.
1951  if (id == MATROSKA_ID_CUES)
1952  continue;
1953 
1954  if (matroska_parse_seekhead_entry(matroska, pos) < 0) {
1955  // mark index as broken
1956  matroska->cues_parsing_deferred = -1;
1957  break;
1958  }
1959 
1960  elem->parsed = 1;
1961  }
1962 }
1963 
1964 static void matroska_add_index_entries(MatroskaDemuxContext *matroska)
1965 {
1966  EbmlList *index_list;
1968  uint64_t index_scale = 1;
1969  int i, j;
1970 
1971  if (matroska->ctx->flags & AVFMT_FLAG_IGNIDX)
1972  return;
1973 
1974  index_list = &matroska->index;
1975  index = index_list->elem;
1976  if (index_list->nb_elem < 2)
1977  return;
1978  if (index[1].time > 1E14 / matroska->time_scale) {
1979  av_log(matroska->ctx, AV_LOG_WARNING, "Dropping apparently-broken index.\n");
1980  return;
1981  }
1982  for (i = 0; i < index_list->nb_elem; i++) {
1983  EbmlList *pos_list = &index[i].pos;
1984  MatroskaIndexPos *pos = pos_list->elem;
1985  for (j = 0; j < pos_list->nb_elem; j++) {
1986  MatroskaTrack *track = matroska_find_track_by_num(matroska,
1987  pos[j].track);
1988  if (track && track->stream)
1989  av_add_index_entry(track->stream,
1990  pos[j].pos + matroska->segment_start,
1991  index[i].time / index_scale, 0, 0,
1993  }
1994  }
1995 }
1996 
1997 static void matroska_parse_cues(MatroskaDemuxContext *matroska) {
1998  int i;
1999 
2000  if (matroska->ctx->flags & AVFMT_FLAG_IGNIDX)
2001  return;
2002 
2003  for (i = 0; i < matroska->num_level1_elems; i++) {
2004  MatroskaLevel1Element *elem = &matroska->level1_elems[i];
2005  if (elem->id == MATROSKA_ID_CUES && !elem->parsed) {
2006  if (matroska_parse_seekhead_entry(matroska, elem->pos) < 0)
2007  matroska->cues_parsing_deferred = -1;
2008  elem->parsed = 1;
2009  break;
2010  }
2011  }
2012 
2013  matroska_add_index_entries(matroska);
2014 }
2015 
2016 static int matroska_aac_profile(char *codec_id)
2017 {
2018  static const char *const aac_profiles[] = { "MAIN", "LC", "SSR" };
2019  int profile;
2020 
2022  if (strstr(codec_id, aac_profiles[profile]))
2023  break;
2024  return profile + 1;
2025 }
2026 
2027 static int matroska_aac_sri(int samplerate)
2028 {
2029  int sri;
2030 
2031  for (sri = 0; sri < FF_ARRAY_ELEMS(ff_mpeg4audio_sample_rates); sri++)
2032  if (ff_mpeg4audio_sample_rates[sri] == samplerate)
2033  break;
2034  return sri;
2035 }
2036 
2037 static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
2038 {
2039  /* Convert to seconds and adjust by number of seconds between 2001-01-01 and Epoch */
2040  avpriv_dict_set_timestamp(metadata, "creation_time", date_utc / 1000 + 978307200000000LL);
2041 }
2042 
2044  MatroskaTrack *track,
2045  int *offset)
2046 {
2047  AVStream *st = track->stream;
2048  uint8_t *p = track->codec_priv.data;
2049  int size = track->codec_priv.size;
2050 
2051  if (size < 8 + FLAC_STREAMINFO_SIZE || p[4] & 0x7f) {
2052  av_log(s, AV_LOG_WARNING, "Invalid FLAC private data\n");
2053  track->codec_priv.size = 0;
2054  return 0;
2055  }
2056  *offset = 8;
2057  track->codec_priv.size = 8 + FLAC_STREAMINFO_SIZE;
2058 
2059  p += track->codec_priv.size;
2060  size -= track->codec_priv.size;
2061 
2062  /* parse the remaining metadata blocks if present */
2063  while (size >= 4) {
2064  int block_last, block_type, block_size;
2065 
2066  flac_parse_block_header(p, &block_last, &block_type, &block_size);
2067 
2068  p += 4;
2069  size -= 4;
2070  if (block_size > size)
2071  return 0;
2072 
2073  /* check for the channel mask */
2074  if (block_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
2075  AVDictionary *dict = NULL;
2076  AVDictionaryEntry *chmask;
2077 
2078  ff_vorbis_comment(s, &dict, p, block_size, 0);
2079  chmask = av_dict_get(dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);
2080  if (chmask) {
2081  uint64_t mask = strtol(chmask->value, NULL, 0);
2082  if (!mask || mask & ~0x3ffffULL) {
2084  "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
2085  } else
2087  }
2088  av_dict_free(&dict);
2089  }
2090 
2091  p += block_size;
2092  size -= block_size;
2093  }
2094 
2095  return 0;
2096 }
2097 
2098 static int mkv_field_order(MatroskaDemuxContext *matroska, uint64_t field_order)
2099 {
2100  int minor, micro, bttb = 0;
2101 
2102  /* workaround a bug in our Matroska muxer, introduced in version 57.36 alongside
2103  * this function, and fixed in 57.52 */
2104  if (matroska->muxingapp && sscanf(matroska->muxingapp, "Lavf57.%d.%d", &minor, &micro) == 2)
2105  bttb = (minor >= 36 && minor <= 51 && micro >= 100);
2106 
2107  switch (field_order) {
2109  return AV_FIELD_PROGRESSIVE;
2111  return AV_FIELD_UNKNOWN;
2113  return AV_FIELD_TT;
2115  return AV_FIELD_BB;
2117  return bttb ? AV_FIELD_TB : AV_FIELD_BT;
2119  return bttb ? AV_FIELD_BT : AV_FIELD_TB;
2120  default:
2121  return AV_FIELD_UNKNOWN;
2122  }
2123 }
2124 
2125 static void mkv_stereo_mode_display_mul(int stereo_mode,
2126  int *h_width, int *h_height)
2127 {
2128  switch (stereo_mode) {
2134  break;
2139  *h_width = 2;
2140  break;
2145  *h_height = 2;
2146  break;
2147  }
2148 }
2149 
2150 static int mkv_parse_video_color(AVStream *st, const MatroskaTrack *track) {
2151  const MatroskaTrackVideoColor *color = track->video.color.elem;
2152  const MatroskaMasteringMeta *mastering_meta;
2153  int has_mastering_primaries, has_mastering_luminance;
2154 
2155  if (!track->video.color.nb_elem)
2156  return 0;
2157 
2158  mastering_meta = &color->mastering_meta;
2159  // Mastering primaries are CIE 1931 coords, and must be > 0.
2160  has_mastering_primaries =
2161  mastering_meta->r_x > 0 && mastering_meta->r_y > 0 &&
2162  mastering_meta->g_x > 0 && mastering_meta->g_y > 0 &&
2163  mastering_meta->b_x > 0 && mastering_meta->b_y > 0 &&
2164  mastering_meta->white_x > 0 && mastering_meta->white_y > 0;
2165  has_mastering_luminance = mastering_meta->max_luminance >
2166  mastering_meta->min_luminance.el.f &&
2167  mastering_meta->min_luminance.el.f >= 0 &&
2168  mastering_meta->min_luminance.count;
2169 
2170  if (color->matrix_coefficients != AVCOL_SPC_RESERVED)
2171  st->codecpar->color_space = color->matrix_coefficients;
2172  if (color->primaries != AVCOL_PRI_RESERVED &&
2173  color->primaries != AVCOL_PRI_RESERVED0)
2174  st->codecpar->color_primaries = color->primaries;
2175  if (color->transfer_characteristics != AVCOL_TRC_RESERVED &&
2176  color->transfer_characteristics != AVCOL_TRC_RESERVED0)
2177  st->codecpar->color_trc = color->transfer_characteristics;
2178  if (color->range != AVCOL_RANGE_UNSPECIFIED &&
2179  color->range <= AVCOL_RANGE_JPEG)
2180  st->codecpar->color_range = color->range;
2181  if (color->chroma_siting_horz != MATROSKA_COLOUR_CHROMASITINGHORZ_UNDETERMINED &&
2182  color->chroma_siting_vert != MATROSKA_COLOUR_CHROMASITINGVERT_UNDETERMINED &&
2183  color->chroma_siting_horz < MATROSKA_COLOUR_CHROMASITINGHORZ_NB &&
2184  color->chroma_siting_vert < MATROSKA_COLOUR_CHROMASITINGVERT_NB) {
2185  st->codecpar->chroma_location =
2186  avcodec_chroma_pos_to_enum((color->chroma_siting_horz - 1) << 7,
2187  (color->chroma_siting_vert - 1) << 7);
2188  }
2189  if (color->max_cll && color->max_fall) {
2190  size_t size = 0;
2191  int ret;
2193  if (!metadata)
2194  return AVERROR(ENOMEM);
2196  (uint8_t *)metadata, size);
2197  if (ret < 0) {
2198  av_freep(&metadata);
2199  return ret;
2200  }
2201  metadata->MaxCLL = color->max_cll;
2202  metadata->MaxFALL = color->max_fall;
2203  }
2204 
2205  if (has_mastering_primaries || has_mastering_luminance) {
2206  AVMasteringDisplayMetadata *metadata =
2209  sizeof(AVMasteringDisplayMetadata));
2210  if (!metadata) {
2211  return AVERROR(ENOMEM);
2212  }
2213  memset(metadata, 0, sizeof(AVMasteringDisplayMetadata));
2214  if (has_mastering_primaries) {
2215  metadata->display_primaries[0][0] = av_d2q(mastering_meta->r_x, INT_MAX);
2216  metadata->display_primaries[0][1] = av_d2q(mastering_meta->r_y, INT_MAX);
2217  metadata->display_primaries[1][0] = av_d2q(mastering_meta->g_x, INT_MAX);
2218  metadata->display_primaries[1][1] = av_d2q(mastering_meta->g_y, INT_MAX);
2219  metadata->display_primaries[2][0] = av_d2q(mastering_meta->b_x, INT_MAX);
2220  metadata->display_primaries[2][1] = av_d2q(mastering_meta->b_y, INT_MAX);
2221  metadata->white_point[0] = av_d2q(mastering_meta->white_x, INT_MAX);
2222  metadata->white_point[1] = av_d2q(mastering_meta->white_y, INT_MAX);
2223  metadata->has_primaries = 1;
2224  }
2225  if (has_mastering_luminance) {
2226  metadata->max_luminance = av_d2q(mastering_meta->max_luminance, INT_MAX);
2227  metadata->min_luminance = av_d2q(mastering_meta->min_luminance.el.f, INT_MAX);
2228  metadata->has_luminance = 1;
2229  }
2230  }
2231  return 0;
2232 }
2233 
2234 static int mkv_create_display_matrix(AVStream *st,
2235  const MatroskaTrackVideoProjection *proj,
2236  void *logctx)
2237 {
2238  double pitch = proj->pitch, yaw = proj->yaw, roll = proj->roll;
2239  int32_t *matrix;
2240  int hflip;
2241 
2242  if (pitch == 0.0 && yaw == 0.0 && roll == 0.0)
2243  return 0;
2244 
2245  /* Note: The following constants are exactly representable
2246  * as floating-point numbers. */
2247  if (pitch != 0.0 || (yaw != 0.0 && yaw != 180.0 && yaw != -180.0) ||
2248  isnan(roll)) {
2249  av_log(logctx, AV_LOG_WARNING, "Ignoring non-2D rectangular "
2250  "projection in stream %u (yaw %f, pitch %f, roll %f)\n",
2251  st->index, yaw, pitch, roll);
2252  return 0;
2253  }
2255  9 * sizeof(*matrix));
2256  if (!matrix)
2257  return AVERROR(ENOMEM);
2258 
2259  hflip = yaw != 0.0;
2260  /* ProjectionPoseRoll is in the counter-clockwise direction
2261  * whereas av_display_rotation_set() expects its argument
2262  * to be oriented clockwise, so we need to negate roll.
2263  * Furthermore, if hflip is set, we need to negate it again
2264  * to account for the fact that the Matroska specifications
2265  * require the yaw rotation to be applied first. */
2266  av_display_rotation_set(matrix, roll * (2 * hflip - 1));
2267  av_display_matrix_flip(matrix, hflip, 0);
2268 
2269  return 0;
2270 }
2271 
2272 static int mkv_parse_video_projection(AVStream *st, const MatroskaTrack *track,
2273  void *logctx)
2274 {
2275  AVSphericalMapping *spherical;
2276  const MatroskaTrackVideoProjection *mkv_projection = &track->video.projection;
2277  const uint8_t *priv_data = mkv_projection->private.data;
2278  enum AVSphericalProjection projection;
2279  size_t spherical_size;
2280  uint32_t l = 0, t = 0, r = 0, b = 0;
2281  uint32_t padding = 0;
2282  int ret;
2283 
2284  if (mkv_projection->private.size && priv_data[0] != 0) {
2285  av_log(logctx, AV_LOG_WARNING, "Unknown spherical metadata\n");
2286  return 0;
2287  }
2288 
2289  switch (track->video.projection.type) {
2291  return mkv_create_display_matrix(st, mkv_projection, logctx);
2293  if (track->video.projection.private.size == 20) {
2294  t = AV_RB32(priv_data + 4);
2295  b = AV_RB32(priv_data + 8);
2296  l = AV_RB32(priv_data + 12);
2297  r = AV_RB32(priv_data + 16);
2298 
2299  if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
2300  av_log(logctx, AV_LOG_ERROR,
2301  "Invalid bounding rectangle coordinates "
2302  "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n",
2303  l, t, r, b);
2304  return AVERROR_INVALIDDATA;
2305  }
2306  } else if (track->video.projection.private.size != 0) {
2307  av_log(logctx, AV_LOG_ERROR, "Unknown spherical metadata\n");
2308  return AVERROR_INVALIDDATA;
2309  }
2310 
2311  if (l || t || r || b)
2312  projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
2313  else
2314  projection = AV_SPHERICAL_EQUIRECTANGULAR;
2315  break;
2317  if (track->video.projection.private.size < 4) {
2318  av_log(logctx, AV_LOG_ERROR, "Missing projection private properties\n");
2319  return AVERROR_INVALIDDATA;
2320  } else if (track->video.projection.private.size == 12) {
2321  uint32_t layout = AV_RB32(priv_data + 4);
2322  if (layout) {
2323  av_log(logctx, AV_LOG_WARNING,
2324  "Unknown spherical cubemap layout %"PRIu32"\n", layout);
2325  return 0;
2326  }
2327  projection = AV_SPHERICAL_CUBEMAP;
2328  padding = AV_RB32(priv_data + 8);
2329  } else {
2330  av_log(logctx, AV_LOG_ERROR, "Unknown spherical metadata\n");
2331  return AVERROR_INVALIDDATA;
2332  }
2333  break;
2334  default:
2335  av_log(logctx, AV_LOG_WARNING,
2336  "Unknown spherical metadata type %"PRIu64"\n",
2337  track->video.projection.type);
2338  return 0;
2339  }
2340 
2341  spherical = av_spherical_alloc(&spherical_size);
2342  if (!spherical)
2343  return AVERROR(ENOMEM);
2344 
2345  spherical->projection = projection;
2346 
2347  spherical->yaw = (int32_t) (track->video.projection.yaw * (1 << 16));
2348  spherical->pitch = (int32_t) (track->video.projection.pitch * (1 << 16));
2349  spherical->roll = (int32_t) (track->video.projection.roll * (1 << 16));
2350 
2351  spherical->padding = padding;
2352 
2353  spherical->bound_left = l;
2354  spherical->bound_top = t;
2355  spherical->bound_right = r;
2356  spherical->bound_bottom = b;
2357 
2358  ret = av_stream_add_side_data(st, AV_PKT_DATA_SPHERICAL, (uint8_t *)spherical,
2359  spherical_size);
2360  if (ret < 0) {
2361  av_freep(&spherical);
2362  return ret;
2363  }
2364 
2365  return 0;
2366 }
2367 
2369  EbmlBin *bin)
2370 {
2371  return ff_isom_parse_dvcc_dvvc(s, st, bin->data, bin->size);
2372 }
2373 
2375 {
2376  const EbmlList *mappings_list = &track->block_addition_mappings;
2377  MatroskaBlockAdditionMapping *mappings = mappings_list->elem;
2378  int ret;
2379 
2380  for (int i = 0; i < mappings_list->nb_elem; i++) {
2381  MatroskaBlockAdditionMapping *mapping = &mappings[i];
2382 
2383  switch (mapping->type) {
2384  case MKBETAG('d','v','c','C'):
2385  case MKBETAG('d','v','v','C'):
2386  if ((ret = mkv_parse_dvcc_dvvc(s, st, track, &mapping->extradata)) < 0)
2387  return ret;
2388 
2389  break;
2390  default:
2392  "Unknown block additional mapping type 0x%"PRIx64", value %"PRIu64", name \"%s\"\n",
2393  mapping->type, mapping->value, mapping->name ? mapping->name : "");
2394  }
2395  }
2396 
2397  return 0;
2398 }
2399 
2400 static int get_qt_codec(MatroskaTrack *track, uint32_t *fourcc, enum AVCodecID *codec_id)
2401 {
2402  const AVCodecTag *codec_tags;
2403 
2404  codec_tags = track->type == MATROSKA_TRACK_TYPE_VIDEO ?
2406 
2407  /* Normalize noncompliant private data that starts with the fourcc
2408  * by expanding/shifting the data by 4 bytes and storing the data
2409  * size at the start. */
2410  if (ff_codec_get_id(codec_tags, AV_RL32(track->codec_priv.data))) {
2411  int ret = av_buffer_realloc(&track->codec_priv.buf,
2413  if (ret < 0)
2414  return ret;
2415 
2416  track->codec_priv.data = track->codec_priv.buf->data;
2417  memmove(track->codec_priv.data + 4, track->codec_priv.data, track->codec_priv.size);
2418  track->codec_priv.size += 4;
2419  AV_WB32(track->codec_priv.data, track->codec_priv.size);
2420  }
2421 
2422  *fourcc = AV_RL32(track->codec_priv.data + 4);
2423  *codec_id = ff_codec_get_id(codec_tags, *fourcc);
2424 
2425  return 0;
2426 }
2427 
2429 {
2430  MatroskaDemuxContext *matroska = s->priv_data;
2431  MatroskaTrack *tracks = matroska->tracks.elem;
2432  int i, j, ret;
2433  int k;
2434 
2435  for (i = 0; i < matroska->tracks.nb_elem; i++) {
2436  MatroskaTrack *track = &tracks[i];
2438  EbmlList *encodings_list = &track->encodings;
2439  MatroskaTrackEncoding *encodings = encodings_list->elem;
2440  uint8_t *extradata = NULL;
2441  int extradata_size = 0;
2442  int extradata_offset = 0;
2443  uint32_t fourcc = 0;
2444  FFIOContext b;
2445  AVStream *st;
2446  FFStream *sti;
2447  char* key_id_base64 = NULL;
2448  int bit_depth = -1;
2449 
2450  /* Apply some sanity checks. */
2451  if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
2452  track->type != MATROSKA_TRACK_TYPE_AUDIO &&
2453  track->type != MATROSKA_TRACK_TYPE_SUBTITLE &&
2454  track->type != MATROSKA_TRACK_TYPE_METADATA) {
2455  av_log(matroska->ctx, AV_LOG_INFO,
2456  "Unknown or unsupported track type %"PRIu64"\n",
2457  track->type);
2458  continue;
2459  }
2460  if (!track->codec_id)
2461  continue;
2462 
2463  if ( track->type == MATROSKA_TRACK_TYPE_AUDIO && track->codec_id[0] != 'A'
2464  || track->type == MATROSKA_TRACK_TYPE_VIDEO && track->codec_id[0] != 'V'
2465  || track->type == MATROSKA_TRACK_TYPE_SUBTITLE && track->codec_id[0] != 'D' && track->codec_id[0] != 'S'
2466  || track->type == MATROSKA_TRACK_TYPE_METADATA && track->codec_id[0] != 'D' && track->codec_id[0] != 'S'
2467  ) {
2468  av_log(matroska->ctx, AV_LOG_INFO, "Inconsistent track type\n");
2469  continue;
2470  }
2471 
2472  if (track->audio.samplerate < 0 || track->audio.samplerate > INT_MAX ||
2473  isnan(track->audio.samplerate)) {
2474  av_log(matroska->ctx, AV_LOG_WARNING,
2475  "Invalid sample rate %f, defaulting to 8000 instead.\n",
2476  track->audio.samplerate);
2477  track->audio.samplerate = 8000;
2478  }
2479 
2480  if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2481  if (!track->default_duration && track->video.frame_rate > 0) {
2482  double default_duration = 1000000000 / track->video.frame_rate;
2483  if (default_duration > UINT64_MAX || default_duration < 0) {
2484  av_log(matroska->ctx, AV_LOG_WARNING,
2485  "Invalid frame rate %e. Cannot calculate default duration.\n",
2486  track->video.frame_rate);
2487  } else {
2488  track->default_duration = default_duration;
2489  }
2490  }
2491  if (track->video.display_width == -1)
2492  track->video.display_width = track->video.pixel_width;
2493  if (track->video.display_height == -1)
2494  track->video.display_height = track->video.pixel_height;
2495  if (track->video.color_space.size == 4)
2496  fourcc = AV_RL32(track->video.color_space.data);
2497  } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2498  if (!track->audio.out_samplerate)
2499  track->audio.out_samplerate = track->audio.samplerate;
2500  }
2501  if (encodings_list->nb_elem > 1) {
2502  av_log(matroska->ctx, AV_LOG_ERROR,
2503  "Multiple combined encodings not supported");
2504  } else if (encodings_list->nb_elem == 1) {
2505  if (encodings[0].type) {
2506  if (encodings[0].encryption.key_id.size > 0) {
2507  /* Save the encryption key id to be stored later as a
2508  metadata tag. */
2509  const int b64_size = AV_BASE64_SIZE(encodings[0].encryption.key_id.size);
2510  key_id_base64 = av_malloc(b64_size);
2511  if (key_id_base64 == NULL)
2512  return AVERROR(ENOMEM);
2513 
2514  av_base64_encode(key_id_base64, b64_size,
2515  encodings[0].encryption.key_id.data,
2516  encodings[0].encryption.key_id.size);
2517  } else {
2518  encodings[0].scope = 0;
2519  av_log(matroska->ctx, AV_LOG_ERROR,
2520  "Unsupported encoding type");
2521  }
2522  } else if (
2523 #if CONFIG_ZLIB
2524  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB &&
2525 #endif
2526 #if CONFIG_BZLIB
2527  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_BZLIB &&
2528 #endif
2529  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_LZO &&
2530  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP) {
2531  encodings[0].scope = 0;
2532  av_log(matroska->ctx, AV_LOG_ERROR,
2533  "Unsupported encoding type");
2534  } else if (track->codec_priv.size && encodings[0].scope & 2) {
2535  uint8_t *codec_priv = track->codec_priv.data;
2536  int ret = matroska_decode_buffer(&track->codec_priv.data,
2537  &track->codec_priv.size,
2538  track);
2539  if (ret < 0) {
2540  track->codec_priv.data = NULL;
2541  track->codec_priv.size = 0;
2542  av_log(matroska->ctx, AV_LOG_ERROR,
2543  "Failed to decode codec private data\n");
2544  }
2545 
2546  if (codec_priv != track->codec_priv.data) {
2547  av_buffer_unref(&track->codec_priv.buf);
2548  if (track->codec_priv.data) {
2549  track->codec_priv.buf = av_buffer_create(track->codec_priv.data,
2551  NULL, NULL, 0);
2552  if (!track->codec_priv.buf) {
2553  av_freep(&track->codec_priv.data);
2554  track->codec_priv.size = 0;
2555  return AVERROR(ENOMEM);
2556  }
2557  }
2558  }
2559  }
2560  }
2561  track->needs_decoding = encodings && !encodings[0].type &&
2562  encodings[0].scope & 1 &&
2563  (encodings[0].compression.algo !=
2565  encodings[0].compression.settings.size);
2566 
2567  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
2568  if (av_strstart(track->codec_id, ff_mkv_codec_tags[j].str, NULL)) {
2570  break;
2571  }
2572  }
2573 
2574  st = track->stream = avformat_new_stream(s, NULL);
2575  if (!st) {
2576  av_free(key_id_base64);
2577  return AVERROR(ENOMEM);
2578  }
2579  sti = ffstream(st);
2580 
2581  if (key_id_base64) {
2582  /* export encryption key id as base64 metadata tag */
2583  av_dict_set(&st->metadata, "enc_key_id", key_id_base64,
2585  }
2586 
2587  if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC") &&
2588  track->codec_priv.size >= 40 &&
2589  track->codec_priv.data) {
2590  track->ms_compat = 1;
2591  bit_depth = AV_RL16(track->codec_priv.data + 14);
2592  fourcc = AV_RL32(track->codec_priv.data + 16);
2594  fourcc);
2595  if (!codec_id)
2597  fourcc);
2598  extradata_offset = 40;
2599  } else if (!strcmp(track->codec_id, "A_MS/ACM") &&
2600  track->codec_priv.size >= 14 &&
2601  track->codec_priv.data) {
2602  int ret;
2604  track->codec_priv.size,
2605  0, NULL, NULL, NULL, NULL);
2606  ret = ff_get_wav_header(s, &b.pub, st->codecpar,
2607  track->codec_priv.size, 0);
2608  if (ret < 0)
2609  return ret;
2610  codec_id = st->codecpar->codec_id;
2611  fourcc = st->codecpar->codec_tag;
2612  extradata_offset = FFMIN(track->codec_priv.size, 18);
2613  } else if (!strcmp(track->codec_id, "A_QUICKTIME")
2614  /* Normally 36, but allow noncompliant private data */
2615  && (track->codec_priv.size >= 32)
2616  && (track->codec_priv.data)) {
2617  uint16_t sample_size;
2618  int ret = get_qt_codec(track, &fourcc, &codec_id);
2619  if (ret < 0)
2620  return ret;
2621  sample_size = AV_RB16(track->codec_priv.data + 26);
2622  if (fourcc == 0) {
2623  if (sample_size == 8) {
2624  fourcc = MKTAG('r','a','w',' ');
2626  } else if (sample_size == 16) {
2627  fourcc = MKTAG('t','w','o','s');
2629  }
2630  }
2631  if ((fourcc == MKTAG('t','w','o','s') ||
2632  fourcc == MKTAG('s','o','w','t')) &&
2633  sample_size == 8)
2635  } else if (!strcmp(track->codec_id, "V_QUICKTIME") &&
2636  (track->codec_priv.size >= 21) &&
2637  (track->codec_priv.data)) {
2638  int ret = get_qt_codec(track, &fourcc, &codec_id);
2639  if (ret < 0)
2640  return ret;
2641  if (codec_id == AV_CODEC_ID_NONE && AV_RL32(track->codec_priv.data+4) == AV_RL32("SMI ")) {
2642  fourcc = MKTAG('S','V','Q','3');
2644  }
2645  if (codec_id == AV_CODEC_ID_NONE)
2646  av_log(matroska->ctx, AV_LOG_ERROR,
2647  "mov FourCC not found %s.\n", av_fourcc2str(fourcc));
2648  if (track->codec_priv.size >= 86) {
2649  bit_depth = AV_RB16(track->codec_priv.data + 82);
2651  track->codec_priv.size,
2652  0, NULL, NULL, NULL, NULL);
2653  if (ff_get_qtpalette(codec_id, &b.pub, track->palette)) {
2654  bit_depth &= 0x1F;
2655  track->has_palette = 1;
2656  }
2657  }
2658  } else if (codec_id == AV_CODEC_ID_PCM_S16BE) {
2659  switch (track->audio.bitdepth) {
2660  case 8:
2662  break;
2663  case 24:
2665  break;
2666  case 32:
2668  break;
2669  }
2670  } else if (codec_id == AV_CODEC_ID_PCM_S16LE) {
2671  switch (track->audio.bitdepth) {
2672  case 8:
2674  break;
2675  case 24:
2677  break;
2678  case 32:
2680  break;
2681  }
2682  } else if (codec_id == AV_CODEC_ID_PCM_F32LE &&
2683  track->audio.bitdepth == 64) {
2685  } else if (codec_id == AV_CODEC_ID_AAC && !track->codec_priv.size) {
2686  int profile = matroska_aac_profile(track->codec_id);
2687  int sri = matroska_aac_sri(track->audio.samplerate);
2688  extradata = av_mallocz(5 + AV_INPUT_BUFFER_PADDING_SIZE);
2689  if (!extradata)
2690  return AVERROR(ENOMEM);
2691  extradata[0] = (profile << 3) | ((sri & 0x0E) >> 1);
2692  extradata[1] = ((sri & 0x01) << 7) | (track->audio.channels << 3);
2693  if (strstr(track->codec_id, "SBR")) {
2694  sri = matroska_aac_sri(track->audio.out_samplerate);
2695  extradata[2] = 0x56;
2696  extradata[3] = 0xE5;
2697  extradata[4] = 0x80 | (sri << 3);
2698  extradata_size = 5;
2699  } else
2700  extradata_size = 2;
2701  } else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size && track->codec_priv.size < INT_MAX - 12 - AV_INPUT_BUFFER_PADDING_SIZE) {
2702  /* Only ALAC's magic cookie is stored in Matroska's track headers.
2703  * Create the "atom size", "tag", and "tag version" fields the
2704  * decoder expects manually. */
2705  extradata_size = 12 + track->codec_priv.size;
2706  extradata = av_mallocz(extradata_size +
2708  if (!extradata)
2709  return AVERROR(ENOMEM);
2710  AV_WB32(extradata, extradata_size);
2711  memcpy(&extradata[4], "alac", 4);
2712  AV_WB32(&extradata[8], 0);
2713  memcpy(&extradata[12], track->codec_priv.data,
2714  track->codec_priv.size);
2715  } else if (codec_id == AV_CODEC_ID_TTA) {
2716  uint8_t *ptr;
2717  if (track->audio.channels > UINT16_MAX ||
2718  track->audio.bitdepth > UINT16_MAX) {
2719  av_log(matroska->ctx, AV_LOG_WARNING,
2720  "Too large audio channel number %"PRIu64
2721  " or bitdepth %"PRIu64". Skipping track.\n",
2722  track->audio.channels, track->audio.bitdepth);
2723  if (matroska->ctx->error_recognition & AV_EF_EXPLODE)
2724  return AVERROR_INVALIDDATA;
2725  else
2726  continue;
2727  }
2728  if (track->audio.out_samplerate < 0 || track->audio.out_samplerate > INT_MAX)
2729  return AVERROR_INVALIDDATA;
2730  extradata_size = 22;
2731  extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
2732  if (!extradata)
2733  return AVERROR(ENOMEM);
2734  ptr = extradata;
2735  bytestream_put_be32(&ptr, AV_RB32("TTA1"));
2736  bytestream_put_le16(&ptr, 1);
2737  bytestream_put_le16(&ptr, track->audio.channels);
2738  bytestream_put_le16(&ptr, track->audio.bitdepth);
2739  bytestream_put_le32(&ptr, track->audio.out_samplerate);
2740  bytestream_put_le32(&ptr, av_rescale(matroska->duration * matroska->time_scale,
2741  track->audio.out_samplerate,
2742  AV_TIME_BASE * 1000));
2743  } else if (codec_id == AV_CODEC_ID_RV10 ||
2747  extradata_offset = 26;
2748  } else if (codec_id == AV_CODEC_ID_RA_144) {
2749  track->audio.out_samplerate = 8000;
2750  track->audio.channels = 1;
2751  } else if ((codec_id == AV_CODEC_ID_RA_288 ||
2755  && track->codec_priv.data) {
2756  const uint8_t *ptr = track->codec_priv.data;
2757  int flavor;
2758 
2759  if (track->codec_priv.size < 46)
2760  return AVERROR_INVALIDDATA;
2761  ptr += 22;
2762  flavor = bytestream_get_be16(&ptr);
2763  track->audio.coded_framesize = bytestream_get_be32(&ptr);
2764  ptr += 12;
2765  track->audio.sub_packet_h = bytestream_get_be16(&ptr);
2766  track->audio.frame_size = bytestream_get_be16(&ptr);
2767  track->audio.sub_packet_size = bytestream_get_be16(&ptr);
2768  if (track->audio.coded_framesize <= 0 ||
2769  track->audio.sub_packet_h <= 0 ||
2770  track->audio.frame_size <= 0)
2771  return AVERROR_INVALIDDATA;
2772 
2773  if (codec_id == AV_CODEC_ID_RA_288) {
2774  if (track->audio.sub_packet_h & 1 || 2 * track->audio.frame_size
2775  != (int64_t)track->audio.sub_packet_h * track->audio.coded_framesize)
2776  return AVERROR_INVALIDDATA;
2777  st->codecpar->block_align = track->audio.coded_framesize;
2778  track->codec_priv.size = 0;
2779  } else {
2780  if (codec_id == AV_CODEC_ID_SIPR) {
2781  static const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
2782  if (flavor > 3)
2783  return AVERROR_INVALIDDATA;
2784  track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
2785  st->codecpar->bit_rate = sipr_bit_rate[flavor];
2786  } else if (track->audio.sub_packet_size <= 0 ||
2787  track->audio.frame_size % track->audio.sub_packet_size)
2788  return AVERROR_INVALIDDATA;
2789  st->codecpar->block_align = track->audio.sub_packet_size;
2790  extradata_offset = 78;
2791  }
2792  track->audio.buf = av_malloc_array(track->audio.sub_packet_h,
2793  track->audio.frame_size);
2794  if (!track->audio.buf)
2795  return AVERROR(ENOMEM);
2796  } else if (codec_id == AV_CODEC_ID_FLAC && track->codec_priv.size) {
2797  ret = matroska_parse_flac(s, track, &extradata_offset);
2798  if (ret < 0)
2799  return ret;
2800  } else if (codec_id == AV_CODEC_ID_WAVPACK && track->codec_priv.size < 2) {
2801  av_log(matroska->ctx, AV_LOG_INFO, "Assuming WavPack version 4.10 "
2802  "in absence of valid CodecPrivate.\n");
2803  extradata_size = 2;
2804  extradata = av_mallocz(2 + AV_INPUT_BUFFER_PADDING_SIZE);
2805  if (!extradata)
2806  return AVERROR(ENOMEM);
2807  AV_WL16(extradata, 0x410);
2808  } else if (codec_id == AV_CODEC_ID_PRORES && track->codec_priv.size == 4) {
2809  fourcc = AV_RL32(track->codec_priv.data);
2810  } else if (codec_id == AV_CODEC_ID_VP9 && track->codec_priv.size) {
2811  /* we don't need any value stored in CodecPrivate.
2812  make sure that it's not exported as extradata. */
2813  track->codec_priv.size = 0;
2814  }
2815  track->codec_priv.size -= extradata_offset;
2816 
2817  if (codec_id == AV_CODEC_ID_NONE)
2818  av_log(matroska->ctx, AV_LOG_INFO,
2819  "Unknown/unsupported AVCodecID %s.\n", track->codec_id);
2820 
2821  if (track->time_scale < 0.01) {
2822  av_log(matroska->ctx, AV_LOG_WARNING,
2823  "Track TimestampScale too small %f, assuming 1.0.\n",
2824  track->time_scale);
2825  track->time_scale = 1.0;
2826  }
2827  avpriv_set_pts_info(st, 64, matroska->time_scale * track->time_scale,
2828  1000 * 1000 * 1000); /* 64 bit pts in ns */
2829 
2830  /* convert the delay from ns to the track timebase */
2832  (AVRational){ 1, 1000000000 },
2833  st->time_base);
2834 
2835  st->codecpar->codec_id = codec_id;
2836 
2837  if (strcmp(track->language, "und"))
2838  av_dict_set(&st->metadata, "language", track->language, 0);
2839  av_dict_set(&st->metadata, "title", track->name, 0);
2840 
2841  if (track->flag_default)
2843  if (track->flag_forced)
2845  if (track->flag_comment)
2847  if (track->flag_hearingimpaired)
2849  if (track->flag_visualimpaired)
2851  if (track->flag_original.count > 0)
2854 
2855  if (!st->codecpar->extradata) {
2856  if (extradata) {
2857  st->codecpar->extradata = extradata;
2858  st->codecpar->extradata_size = extradata_size;
2859  } else if (track->codec_priv.data && track->codec_priv.size > 0) {
2860  if (ff_alloc_extradata(st->codecpar, track->codec_priv.size))
2861  return AVERROR(ENOMEM);
2862  memcpy(st->codecpar->extradata,
2863  track->codec_priv.data + extradata_offset,
2864  track->codec_priv.size);
2865  }
2866  }
2867 
2868  if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2870  int display_width_mul = 1;
2871  int display_height_mul = 1;
2872 
2874  st->codecpar->codec_tag = fourcc;
2875  if (bit_depth >= 0)
2877  st->codecpar->width = track->video.pixel_width;
2878  st->codecpar->height = track->video.pixel_height;
2879 
2881  st->codecpar->field_order = mkv_field_order(matroska, track->video.field_order);
2884 
2886  mkv_stereo_mode_display_mul(track->video.stereo_mode, &display_width_mul, &display_height_mul);
2887 
2889  if (track->video.display_width && track->video.display_height &&
2890  st->codecpar->height < INT64_MAX / track->video.display_width / display_width_mul &&
2891  st->codecpar->width < INT64_MAX / track->video.display_height / display_height_mul)
2893  &st->sample_aspect_ratio.den,
2894  st->codecpar->height * track->video.display_width * display_width_mul,
2895  st->codecpar->width * track->video.display_height * display_height_mul,
2896  INT_MAX);
2897  }
2898  if (st->codecpar->codec_id != AV_CODEC_ID_HEVC)
2900 
2901  if (track->default_duration) {
2902  int div = track->default_duration <= INT64_MAX ? 1 : 2;
2904  1000000000 / div, track->default_duration / div, 30000);
2905 #if FF_API_R_FRAME_RATE
2906  if ( st->avg_frame_rate.num < st->avg_frame_rate.den * 1000LL
2907  && st->avg_frame_rate.num > st->avg_frame_rate.den * 5LL)
2908  st->r_frame_rate = st->avg_frame_rate;
2909 #endif
2910  }
2911 
2912  /* export stereo mode flag as metadata tag */
2914  av_dict_set(&st->metadata, "stereo_mode", ff_matroska_video_stereo_mode[track->video.stereo_mode], 0);
2915 
2916  /* export alpha mode flag as metadata tag */
2917  if (track->video.alpha_mode)
2918  av_dict_set(&st->metadata, "alpha_mode", "1", 0);
2919 
2920  /* if we have virtual track, mark the real tracks */
2921  for (j=0; j < track->operation.combine_planes.nb_elem; j++) {
2922  char buf[32];
2924  continue;
2925  snprintf(buf, sizeof(buf), "%s_%d",
2927  for (k=0; k < matroska->tracks.nb_elem; k++)
2928  if (planes[j].uid == tracks[k].uid && tracks[k].stream) {
2929  av_dict_set(&tracks[k].stream->metadata,
2930  "stereo_mode", buf, 0);
2931  break;
2932  }
2933  }
2934  // add stream level stereo3d side data if it is a supported format
2936  track->video.stereo_mode != 10 && track->video.stereo_mode != 12) {
2937  int ret = ff_mkv_stereo3d_conv(st, track->video.stereo_mode);
2938  if (ret < 0)
2939  return ret;
2940  }
2941 
2942  ret = mkv_parse_video_color(st, track);
2943  if (ret < 0)
2944  return ret;
2945  ret = mkv_parse_video_projection(st, track, matroska->ctx);
2946  if (ret < 0)
2947  return ret;
2948  } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2950  st->codecpar->codec_tag = fourcc;
2951  st->codecpar->sample_rate = track->audio.out_samplerate;
2952  // channel layout may be already set by codec private checks above
2956  }
2957  if (!st->codecpar->bits_per_coded_sample)
2959  if (st->codecpar->codec_id == AV_CODEC_ID_MP3 ||
2960  st->codecpar->codec_id == AV_CODEC_ID_MLP ||
2963  else if (st->codecpar->codec_id != AV_CODEC_ID_AAC)
2965  if (track->codec_delay > 0) {
2967  (AVRational){1, 1000000000},
2968  (AVRational){1, st->codecpar->codec_id == AV_CODEC_ID_OPUS ?
2969  48000 : st->codecpar->sample_rate});
2970  }
2971  if (track->seek_preroll > 0) {
2973  (AVRational){1, 1000000000},
2974  (AVRational){1, st->codecpar->sample_rate});
2975  }
2976  } else if (codec_id == AV_CODEC_ID_WEBVTT) {
2978 
2979  if (!strcmp(track->codec_id, "D_WEBVTT/CAPTIONS")) {
2981  } else if (!strcmp(track->codec_id, "D_WEBVTT/DESCRIPTIONS")) {
2983  } else if (!strcmp(track->codec_id, "D_WEBVTT/METADATA")) {
2985  }
2986  } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
2988 
2989  if (track->flag_textdescriptions)
2991  }
2992 
2993  ret = mkv_parse_block_addition_mappings(s, st, track);
2994  if (ret < 0)
2995  return ret;
2996  }
2997 
2998  return 0;
2999 }
3000 
3002 {
3003  FFFormatContext *const si = ffformatcontext(s);
3004  MatroskaDemuxContext *matroska = s->priv_data;
3005  EbmlList *attachments_list = &matroska->attachments;
3006  EbmlList *chapters_list = &matroska->chapters;
3007  MatroskaAttachment *attachments;
3008  MatroskaChapter *chapters;
3009  uint64_t max_start = 0;
3010  int64_t pos;
3011  Ebml ebml = { 0 };
3012  int i, j, res;
3013 
3014  matroska->ctx = s;
3015  matroska->cues_parsing_deferred = 1;
3016 
3017  /* First read the EBML header. */
3018  if (ebml_parse(matroska, ebml_syntax, &ebml) || !ebml.doctype) {
3019  av_log(matroska->ctx, AV_LOG_ERROR, "EBML header parsing failed\n");
3020  ebml_free(ebml_syntax, &ebml);
3021  return AVERROR_INVALIDDATA;
3022  }
3023  if (ebml.version > EBML_VERSION ||
3024  ebml.max_size > sizeof(uint64_t) ||
3025  ebml.id_length > sizeof(uint32_t) ||
3026  ebml.doctype_version > 3) {
3028  "EBML version %"PRIu64", doctype %s, doc version %"PRIu64,
3029  ebml.version, ebml.doctype, ebml.doctype_version);
3030  ebml_free(ebml_syntax, &ebml);
3031  return AVERROR_PATCHWELCOME;
3032  } else if (ebml.doctype_version == 3) {
3033  av_log(matroska->ctx, AV_LOG_WARNING,
3034  "EBML header using unsupported features\n"
3035  "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
3036  ebml.version, ebml.doctype, ebml.doctype_version);
3037  }
3038  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++)
3039  if (!strcmp(ebml.doctype, matroska_doctypes[i]))
3040  break;
3042  av_log(s, AV_LOG_WARNING, "Unknown EBML doctype '%s'\n", ebml.doctype);
3043  if (matroska->ctx->error_recognition & AV_EF_EXPLODE) {
3044  ebml_free(ebml_syntax, &ebml);
3045  return AVERROR_INVALIDDATA;
3046  }
3047  }
3048  ebml_free(ebml_syntax, &ebml);
3049 
3050  matroska->pkt = si->parse_pkt;
3051 
3052  /* The next thing is a segment. */
3053  pos = avio_tell(matroska->ctx->pb);
3054  res = ebml_parse(matroska, matroska_segments, matroska);
3055  // Try resyncing until we find an EBML_STOP type element.
3056  while (res != 1) {
3057  res = matroska_resync(matroska, pos);
3058  if (res < 0)
3059  return res;
3060  pos = avio_tell(matroska->ctx->pb);
3061  res = ebml_parse(matroska, matroska_segment, matroska);
3062  if (res == AVERROR(EIO)) // EOF is translated to EIO, this exists the loop on EOF
3063  return res;
3064  }
3065  /* Set data_offset as it might be needed later by seek_frame_generic. */
3066  if (matroska->current_id == MATROSKA_ID_CLUSTER)
3067  si->data_offset = avio_tell(matroska->ctx->pb) - 4;
3068  matroska_execute_seekhead(matroska);
3069 
3070  if (!matroska->time_scale)
3071  matroska->time_scale = 1000000;
3072  if (isnan(matroska->duration))
3073  matroska->duration = 0;
3074  if (matroska->duration)
3075  matroska->ctx->duration = matroska->duration * matroska->time_scale *
3076  1000 / AV_TIME_BASE;
3077  av_dict_set(&s->metadata, "title", matroska->title, 0);
3078  av_dict_set(&s->metadata, "encoder", matroska->muxingapp, 0);
3079 
3080  if (matroska->date_utc.size == 8)
3081  matroska_metadata_creation_time(&s->metadata, AV_RB64(matroska->date_utc.data));
3082 
3083  res = matroska_parse_tracks(s);
3084  if (res < 0)
3085  return res;
3086 
3087  attachments = attachments_list->elem;
3088  for (j = 0; j < attachments_list->nb_elem; j++) {
3089  if (!(attachments[j].filename && attachments[j].mime &&
3090  attachments[j].bin.data && attachments[j].bin.size > 0)) {
3091  av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
3092  } else {
3094  if (!st)
3095  break;
3096  av_dict_set(&st->metadata, "filename", attachments[j].filename, 0);
3097  av_dict_set(&st->metadata, "mimetype", attachments[j].mime, 0);
3098  if (attachments[j].description)
3099  av_dict_set(&st->metadata, "title", attachments[j].description, 0);
3101 
3102  for (i = 0; mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
3103  if (av_strstart(attachments[j].mime, mkv_image_mime_tags[i].str, NULL)) {
3105  break;
3106  }
3107  }
3108 
3109  attachments[j].stream = st;
3110 
3111  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
3112  res = ff_add_attached_pic(s, st, NULL, &attachments[j].bin.buf, 0);
3113  if (res < 0)
3114  return res;
3115  } else {
3117  if (ff_alloc_extradata(st->codecpar, attachments[j].bin.size))
3118  break;
3119  memcpy(st->codecpar->extradata, attachments[j].bin.data,
3120  attachments[j].bin.size);
3121 
3122  for (i = 0; mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
3123  if (av_strstart(attachments[j].mime, mkv_mime_tags[i].str, NULL)) {
3125  break;
3126  }
3127  }
3128  }
3129  }
3130  }
3131 
3132  chapters = chapters_list->elem;
3133  for (i = 0; i < chapters_list->nb_elem; i++)
3134  if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid &&
3135  (max_start == 0 || chapters[i].start > max_start)) {
3136  chapters[i].chapter =
3137  avpriv_new_chapter(s, chapters[i].uid,
3138  (AVRational) { 1, 1000000000 },
3139  chapters[i].start, chapters[i].end,
3140  chapters[i].title);
3141  max_start = chapters[i].start;
3142  }
3143 
3144  matroska_add_index_entries(matroska);
3145 
3147 
3148  return 0;
3150 
3151 /*
3152  * Put one packet in an application-supplied AVPacket struct.
3153  * Returns 0 on success or -1 on failure.
3154  */
3155 static int matroska_deliver_packet(MatroskaDemuxContext *matroska,
3156  AVPacket *pkt)
3157 {
3158  if (matroska->queue.head) {
3159  MatroskaTrack *tracks = matroska->tracks.elem;
3160  MatroskaTrack *track;
3161 
3162  avpriv_packet_list_get(&matroska->queue, pkt);
3163  track = &tracks[pkt->stream_index];
3164  if (track->has_palette) {
3166  if (!pal) {
3167  av_log(matroska->ctx, AV_LOG_ERROR, "Cannot append palette to packet\n");
3168  } else {
3169  memcpy(pal, track->palette, AVPALETTE_SIZE);
3170  }
3171  track->has_palette = 0;
3172  }
3173  return 0;
3174  }
3175 
3176  return -1;
3177 }
3178 
3179 /*
3180  * Free all packets in our internal queue.
3181  */
3182 static void matroska_clear_queue(MatroskaDemuxContext *matroska)
3183 {
3184  avpriv_packet_list_free(&matroska->queue);
3185 }
3186 
3187 static int matroska_parse_laces(MatroskaDemuxContext *matroska, uint8_t **buf,
3188  int size, int type, AVIOContext *pb,
3189  uint32_t lace_size[256], int *laces)
3190 {
3191  int n;
3192  uint8_t *data = *buf;
3193 
3194  if (!type) {
3195  *laces = 1;
3196  lace_size[0] = size;
3197  return 0;
3198  }
3199 
3200  if (size <= 0)
3201  return AVERROR_INVALIDDATA;
3202 
3203  *laces = *data + 1;
3204  data += 1;
3205  size -= 1;
3206 
3207  switch (type) {
3208  case 0x1: /* Xiph lacing */
3209  {
3210  uint8_t temp;
3211  uint32_t total = 0;
3212  for (n = 0; n < *laces - 1; n++) {
3213  lace_size[n] = 0;
3214 
3215  do {
3216  if (size <= total)
3217  return AVERROR_INVALIDDATA;
3218  temp = *data;
3219  total += temp;
3220  lace_size[n] += temp;
3221  data += 1;
3222  size -= 1;
3223  } while (temp == 0xff);
3224  }
3225  if (size < total)
3226  return AVERROR_INVALIDDATA;
3227 
3228  lace_size[n] = size - total;
3229  break;
3230  }
3231 
3232  case 0x2: /* fixed-size lacing */
3233  if (size % (*laces))
3234  return AVERROR_INVALIDDATA;
3235  for (n = 0; n < *laces; n++)
3236  lace_size[n] = size / *laces;
3237  break;
3238 
3239  case 0x3: /* EBML lacing */
3240  {
3241  uint64_t num;
3242  uint64_t total;
3243  int offset;
3244 
3245  avio_skip(pb, 4);
3246 
3247  n = ebml_read_num(matroska, pb, 8, &num, 1);
3248  if (n < 0)
3249  return n;
3250  if (num > INT_MAX)
3251  return AVERROR_INVALIDDATA;
3252 
3253  total = lace_size[0] = num;
3254  offset = n;
3255  for (n = 1; n < *laces - 1; n++) {
3256  int64_t snum;
3257  int r;
3258  r = matroska_ebmlnum_sint(matroska, pb, &snum);
3259  if (r < 0)
3260  return r;
3261  if (lace_size[n - 1] + snum > (uint64_t)INT_MAX)
3262  return AVERROR_INVALIDDATA;
3263 
3264  lace_size[n] = lace_size[n - 1] + snum;
3265  total += lace_size[n];
3266  offset += r;
3267  }
3268  data += offset;
3269  size -= offset;
3270  if (size < total)
3271  return AVERROR_INVALIDDATA;
3272 
3273  lace_size[*laces - 1] = size - total;
3274  break;
3275  }
3276  }
3278  *buf = data;
3279 
3280  return 0;
3281 }
3282 
3283 static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
3284  MatroskaTrack *track, AVStream *st,
3285  uint8_t *data, int size, uint64_t timecode,
3286  int64_t pos)
3287 {
3288  const int a = st->codecpar->block_align;
3289  const int sps = track->audio.sub_packet_size;
3290  const int cfs = track->audio.coded_framesize;
3291  const int h = track->audio.sub_packet_h;
3292  const int w = track->audio.frame_size;
3293  int y = track->audio.sub_packet_cnt;
3294  int x;
3295 
3296  if (!track->audio.pkt_cnt) {
3297  if (track->audio.sub_packet_cnt == 0)
3298  track->audio.buf_timecode = timecode;
3299  if (st->codecpar->codec_id == AV_CODEC_ID_RA_288) {
3300  if (size < cfs * h / 2) {
3301  av_log(matroska->ctx, AV_LOG_ERROR,
3302  "Corrupt int4 RM-style audio packet size\n");
3303  return AVERROR_INVALIDDATA;
3304  }
3305  for (x = 0; x < h / 2; x++)
3306  memcpy(track->audio.buf + x * 2 * w + y * cfs,
3307  data + x * cfs, cfs);
3308  } else if (st->codecpar->codec_id == AV_CODEC_ID_SIPR) {
3309  if (size < w) {
3310  av_log(matroska->ctx, AV_LOG_ERROR,
3311  "Corrupt sipr RM-style audio packet size\n");
3312  return AVERROR_INVALIDDATA;
3313  }
3314  memcpy(track->audio.buf + y * w, data, w);
3315  } else {
3316  if (size < w) {
3317  av_log(matroska->ctx, AV_LOG_ERROR,
3318  "Corrupt generic RM-style audio packet size\n");
3319  return AVERROR_INVALIDDATA;
3320  }
3321  for (x = 0; x < w / sps; x++)
3322  memcpy(track->audio.buf +
3323  sps * (h * x + ((h + 1) / 2) * (y & 1) + (y >> 1)),
3324  data + x * sps, sps);
3325  }
3326 
3327  if (++track->audio.sub_packet_cnt >= h) {
3328  if (st->codecpar->codec_id == AV_CODEC_ID_SIPR)
3329  ff_rm_reorder_sipr_data(track->audio.buf, h, w);
3330  track->audio.sub_packet_cnt = 0;
3331  track->audio.pkt_cnt = h * w / a;
3332  }
3333  }
3334 
3335  while (track->audio.pkt_cnt) {
3336  int ret;
3337  AVPacket *pkt = matroska->pkt;
3338 
3339  ret = av_new_packet(pkt, a);
3340  if (ret < 0) {
3341  return ret;
3342  }
3343  memcpy(pkt->data,
3344  track->audio.buf + a * (h * w / a - track->audio.pkt_cnt--),
3345  a);
3346  pkt->pts = track->audio.buf_timecode;
3348  pkt->pos = pos;
3349  pkt->stream_index = st->index;
3350  ret = avpriv_packet_list_put(&matroska->queue, pkt, NULL, 0);
3351  if (ret < 0) {
3353  return AVERROR(ENOMEM);
3354  }
3355  }
3356 
3357  return 0;
3358 }
3359 
3360 /* reconstruct full wavpack blocks from mangled matroska ones */
3361 static int matroska_parse_wavpack(MatroskaTrack *track,
3362  uint8_t **data, int *size)
3363 {
3364  uint8_t *dst = NULL;
3365  uint8_t *src = *data;
3366  int dstlen = 0;
3367  int srclen = *size;
3368  uint32_t samples;
3369  uint16_t ver;
3370  int ret, offset = 0;
3371 
3372  if (srclen < 12)
3373  return AVERROR_INVALIDDATA;
3374 
3375  av_assert1(track->stream->codecpar->extradata_size >= 2);
3376  ver = AV_RL16(track->stream->codecpar->extradata);
3377 
3378  samples = AV_RL32(src);
3379  src += 4;
3380  srclen -= 4;
3381 
3382  while (srclen >= 8) {
3383  int multiblock;
3384  uint32_t blocksize;
3385  uint8_t *tmp;
3386 
3387  uint32_t flags = AV_RL32(src);
3388  uint32_t crc = AV_RL32(src + 4);
3389  src += 8;
3390  srclen -= 8;
3391 
3392  multiblock = (flags & 0x1800) != 0x1800;
3393  if (multiblock) {
3394  if (srclen < 4) {
3396  goto fail;
3397  }
3398  blocksize = AV_RL32(src);
3399  src += 4;
3400  srclen -= 4;
3401  } else
3402  blocksize = srclen;
3403 
3404  if (blocksize > srclen) {
3406  goto fail;
3407  }
3408 
3409  tmp = av_realloc(dst, dstlen + blocksize + 32 + AV_INPUT_BUFFER_PADDING_SIZE);
3410  if (!tmp) {
3411  ret = AVERROR(ENOMEM);
3412  goto fail;
3413  }
3414  dst = tmp;
3415  dstlen += blocksize + 32;
3416 
3417  AV_WL32(dst + offset, MKTAG('w', 'v', 'p', 'k')); // tag
3418  AV_WL32(dst + offset + 4, blocksize + 24); // blocksize - 8
3419  AV_WL16(dst + offset + 8, ver); // version
3420  AV_WL16(dst + offset + 10, 0); // track/index_no
3421  AV_WL32(dst + offset + 12, 0); // total samples
3422  AV_WL32(dst + offset + 16, 0); // block index
3423  AV_WL32(dst + offset + 20, samples); // number of samples
3424  AV_WL32(dst + offset + 24, flags); // flags
3425  AV_WL32(dst + offset + 28, crc); // crc
3426  memcpy(dst + offset + 32, src, blocksize); // block data
3427 
3428  src += blocksize;
3429  srclen -= blocksize;
3430  offset += blocksize + 32;
3431  }
3432 
3433  memset(dst + dstlen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3434 
3435  *data = dst;
3436  *size = dstlen;
3437 
3438  return 0;
3440 fail:
3441  av_freep(&dst);
3442  return ret;
3443 }
3444 
3445 static int matroska_parse_prores(MatroskaTrack *track,
3446  uint8_t **data, int *size)
3447 {
3448  uint8_t *dst;
3449  int dstlen = *size + 8;
3450 
3451  dst = av_malloc(dstlen + AV_INPUT_BUFFER_PADDING_SIZE);
3452  if (!dst)
3453  return AVERROR(ENOMEM);
3454 
3455  AV_WB32(dst, dstlen);
3456  AV_WB32(dst + 4, MKBETAG('i', 'c', 'p', 'f'));
3457  memcpy(dst + 8, *data, dstlen - 8);
3458  memset(dst + dstlen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3459 
3460  *data = dst;
3461  *size = dstlen;
3462 
3463  return 0;
3464 }
3465 
3466 static int matroska_parse_webvtt(MatroskaDemuxContext *matroska,
3467  MatroskaTrack *track,
3468  AVStream *st,
3469  uint8_t *data, int data_len,
3470  uint64_t timecode,
3471  uint64_t duration,
3472  int64_t pos)
3473 {
3474  AVPacket *pkt = matroska->pkt;
3475  uint8_t *id, *settings, *text, *buf;
3476  int id_len, settings_len, text_len;
3477  uint8_t *p, *q;
3478  int err;
3479 
3480  if (data_len <= 0)
3481  return AVERROR_INVALIDDATA;
3482 
3483  p = data;
3484  q = data + data_len;
3485 
3486  id = p;
3487  id_len = -1;
3488  while (p < q) {
3489  if (*p == '\r' || *p == '\n') {
3490  id_len = p - id;
3491  if (*p == '\r')
3492  p++;
3493  break;
3494  }
3495  p++;
3496  }
3497 
3498  if (p >= q || *p != '\n')
3499  return AVERROR_INVALIDDATA;
3500  p++;
3501 
3502  settings = p;
3503  settings_len = -1;
3504  while (p < q) {
3505  if (*p == '\r' || *p == '\n') {
3506  settings_len = p - settings;
3507  if (*p == '\r')
3508  p++;
3509  break;
3510  }
3511  p++;
3512  }
3513 
3514  if (p >= q || *p != '\n')
3515  return AVERROR_INVALIDDATA;
3516  p++;
3517 
3518  text = p;
3519  text_len = q - p;
3520  while (text_len > 0) {
3521  const int len = text_len - 1;
3522  const uint8_t c = p[len];
3523  if (c != '\r' && c != '\n')
3524  break;
3525  text_len = len;
3526  }
3527 
3528  if (text_len <= 0)
3529  return AVERROR_INVALIDDATA;
3530 
3531  err = av_new_packet(pkt, text_len);
3532  if (err < 0) {
3533  return err;
3534  }
3535 
3536  memcpy(pkt->data, text, text_len);
3537 
3538  if (id_len > 0) {
3541  id_len);
3542  if (!buf) {
3544  return AVERROR(ENOMEM);
3545  }
3546  memcpy(buf, id, id_len);
3547  }
3548 
3549  if (settings_len > 0) {
3552  settings_len);
3553  if (!buf) {
3555  return AVERROR(ENOMEM);
3556  }
3557  memcpy(buf, settings, settings_len);
3558  }
3559 
3560  // Do we need this for subtitles?
3561  // pkt->flags = AV_PKT_FLAG_KEY;
3562 
3563  pkt->stream_index = st->index;
3564  pkt->pts = timecode;
3565 
3566  // Do we need this for subtitles?
3567  // pkt->dts = timecode;
3568 
3569  pkt->duration = duration;
3570  pkt->pos = pos;
3571 
3572  err = avpriv_packet_list_put(&matroska->queue, pkt, NULL, 0);
3573  if (err < 0) {
3575  return AVERROR(ENOMEM);
3576  }
3577 
3578  return 0;
3579 }
3580 
3581 static int matroska_parse_frame(MatroskaDemuxContext *matroska,
3582  MatroskaTrack *track, AVStream *st,
3583  AVBufferRef *buf, uint8_t *data, int pkt_size,
3584  uint64_t timecode, uint64_t lace_duration,
3585  int64_t pos, int is_keyframe,
3586  uint8_t *additional, uint64_t additional_id, int additional_size,
3587  int64_t discard_padding)
3588 {
3589  uint8_t *pkt_data = data;
3590  int res = 0;
3591  AVPacket *pkt = matroska->pkt;
3592 
3593  if (st->codecpar->codec_id == AV_CODEC_ID_WAVPACK) {
3594  res = matroska_parse_wavpack(track, &pkt_data, &pkt_size);
3595  if (res < 0) {
3596  av_log(matroska->ctx, AV_LOG_ERROR,
3597  "Error parsing a wavpack block.\n");
3598  goto fail;
3599  }
3600  if (!buf)
3601  av_freep(&data);
3602  buf = NULL;
3603  }
3604 
3605  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES &&
3606  AV_RB32(pkt_data + 4) != MKBETAG('i', 'c', 'p', 'f')) {
3607  res = matroska_parse_prores(track, &pkt_data, &pkt_size);
3608  if (res < 0) {
3609  av_log(matroska->ctx, AV_LOG_ERROR,
3610  "Error parsing a prores block.\n");
3611  goto fail;
3612  }
3613  if (!buf)
3614  av_freep(&data);
3615  buf = NULL;
3616  }
3617 
3618  if (!pkt_size && !additional_size)
3619  goto no_output;
3620 
3621  if (!buf)
3622  pkt->buf = av_buffer_create(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE,
3623  NULL, NULL, 0);
3624  else
3625  pkt->buf = av_buffer_ref(buf);
3626 
3627  if (!pkt->buf) {
3628  res = AVERROR(ENOMEM);
3629  goto fail;
3630  }
3631 
3632  pkt->data = pkt_data;
3633  pkt->size = pkt_size;
3634  pkt->flags = is_keyframe;
3635  pkt->stream_index = st->index;
3636 
3637  if (additional_size > 0) {
3638  uint8_t *side_data = av_packet_new_side_data(pkt,
3640  additional_size + 8);
3641  if (!side_data) {
3643  return AVERROR(ENOMEM);
3644  }
3645  AV_WB64(side_data, additional_id);
3646  memcpy(side_data + 8, additional, additional_size);
3647  }
3648 
3649  if (discard_padding) {
3650  uint8_t *side_data = av_packet_new_side_data(pkt,
3652  10);
3653  if (!side_data) {
3655  return AVERROR(ENOMEM);
3656  }
3657  discard_padding = av_rescale_q(discard_padding,
3658  (AVRational){1, 1000000000},
3659  (AVRational){1, st->codecpar->sample_rate});
3660  if (discard_padding > 0) {
3661  AV_WL32(side_data + 4, discard_padding);
3662  } else {
3663  AV_WL32(side_data, -discard_padding);
3664  }
3665  }
3666 
3667  if (track->ms_compat)
3668  pkt->dts = timecode;
3669  else
3670  pkt->pts = timecode;
3671  pkt->pos = pos;
3672  pkt->duration = lace_duration;
3673 
3674  res = avpriv_packet_list_put(&matroska->queue, pkt, NULL, 0);
3675  if (res < 0) {
3677  return AVERROR(ENOMEM);
3678  }
3679 
3680  return 0;
3681 
3682 no_output:
3684  if (!buf)
3685  av_free(pkt_data);
3686  return res;
3687 }
3688 
3689 static int matroska_parse_block(MatroskaDemuxContext *matroska, AVBufferRef *buf, uint8_t *data,
3690  int size, int64_t pos, uint64_t cluster_time,
3691  uint64_t block_duration, int is_keyframe,
3692  uint8_t *additional, uint64_t additional_id, int additional_size,
3693  int64_t cluster_pos, int64_t discard_padding)
3694 {
3695  uint64_t timecode = AV_NOPTS_VALUE;
3696  MatroskaTrack *track;
3697  FFIOContext pb;
3698  int res = 0;
3699  AVStream *st;
3700  int16_t block_time;
3701  uint32_t lace_size[256];
3702  int n, flags, laces = 0;
3703  uint64_t num;
3704  int trust_default_duration;
3705 
3706  av_assert1(buf);
3707 
3708  ffio_init_context(&pb, data, size, 0, NULL, NULL, NULL, NULL);
3709 
3710  if ((n = ebml_read_num(matroska, &pb.pub, 8, &num, 1)) < 0)
3711  return n;
3712  data += n;
3713  size -= n;
3714 
3715  track = matroska_find_track_by_num(matroska, num);
3716  if (!track || size < 3)
3717  return AVERROR_INVALIDDATA;
3718 
3719  if (!(st = track->stream)) {
3720  av_log(matroska->ctx, AV_LOG_VERBOSE,
3721  "No stream associated to TrackNumber %"PRIu64". "
3722  "Ignoring Block with this TrackNumber.\n", num);
3723  return 0;
3724  }
3725 
3726  if (st->discard >= AVDISCARD_ALL)
3727  return res;
3728  if (block_duration > INT64_MAX)
3729  block_duration = INT64_MAX;
3730 
3731  block_time = sign_extend(AV_RB16(data), 16);
3732  data += 2;
3733  flags = *data++;
3734  size -= 3;
3735  if (is_keyframe == -1)
3736  is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
3737 
3738  if (cluster_time != (uint64_t) -1 &&
3739  (block_time >= 0 || cluster_time >= -block_time)) {
3740  uint64_t timecode_cluster_in_track_tb = (double) cluster_time / track->time_scale;
3741  timecode = timecode_cluster_in_track_tb + block_time - track->codec_delay_in_track_tb;
3742  if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
3743  timecode < track->end_timecode)
3744  is_keyframe = 0; /* overlapping subtitles are not key frame */
3745  if (is_keyframe) {
3746  ff_reduce_index(matroska->ctx, st->index);
3747  av_add_index_entry(st, cluster_pos, timecode, 0, 0,
3749  }
3750  }
3751 
3752  if (matroska->skip_to_keyframe &&
3753  track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
3754  // Compare signed timecodes. Timecode may be negative due to codec delay
3755  // offset. We don't support timestamps greater than int64_t anyway - see
3756  // AVPacket's pts.
3757  if ((int64_t)timecode < (int64_t)matroska->skip_to_timecode)
3758  return res;
3759  if (is_keyframe)
3760  matroska->skip_to_keyframe = 0;
3761  else if (!ffstream(st)->skip_to_keyframe) {
3762  av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
3763  matroska->skip_to_keyframe = 0;
3764  }
3765  }
3766 
3767  res = matroska_parse_laces(matroska, &data, size, (flags & 0x06) >> 1,
3768  &pb.pub, lace_size, &laces);
3769  if (res < 0) {
3770  av_log(matroska->ctx, AV_LOG_ERROR, "Error parsing frame sizes.\n");
3771  return res;
3772  }
3773 
3774  trust_default_duration = track->default_duration != 0;
3775  if (track->audio.samplerate == 8000 && trust_default_duration) {
3776  // If this is needed for more codecs, then add them here
3777  if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
3778  if (track->audio.samplerate != st->codecpar->sample_rate || !st->codecpar->frame_size)
3779  trust_default_duration = 0;
3780  }
3781  }
3782 
3783  if (!block_duration && trust_default_duration)
3784  block_duration = track->default_duration * laces / matroska->time_scale;
3785 
3786  if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
3787  track->end_timecode =
3788  FFMAX(track->end_timecode, timecode + block_duration);
3789 
3790  for (n = 0; n < laces; n++) {
3791  int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
3792  uint8_t *out_data = data;
3793  int out_size = lace_size[n];
3794 
3795  if (track->needs_decoding) {
3796  res = matroska_decode_buffer(&out_data, &out_size, track);
3797  if (res < 0)
3798  return res;
3799  /* Given that we are here means that out_data is no longer
3800  * owned by buf, so set it to NULL. This depends upon
3801  * zero-length header removal compression being ignored. */
3802  av_assert1(out_data != data);
3803  buf = NULL;
3804  }
3805 
3806  if (track->audio.buf) {
3807  res = matroska_parse_rm_audio(matroska, track, st,
3808  out_data, out_size,
3809  timecode, pos);
3810  if (!buf)
3811  av_free(out_data);
3812  if (res)
3813  return res;
3814  } else if (st->codecpar->codec_id == AV_CODEC_ID_WEBVTT) {
3815  res = matroska_parse_webvtt(matroska, track, st,
3816  out_data, out_size,
3817  timecode, lace_duration,
3818  pos);
3819  if (!buf)
3820  av_free(out_data);
3821  if (res)
3822  return res;
3823  } else {
3824  res = matroska_parse_frame(matroska, track, st, buf, out_data,
3825  out_size, timecode, lace_duration,
3826  pos, !n ? is_keyframe : 0,
3827  additional, additional_id, additional_size,
3828  discard_padding);
3829  if (res)
3830  return res;
3831  }
3832 
3833  if (timecode != AV_NOPTS_VALUE)
3834  timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
3835  data += lace_size[n];
3836  }
3837 
3838  return 0;
3839 }
3840 
3841 static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
3842 {
3843  MatroskaCluster *cluster = &matroska->current_cluster;
3844  MatroskaBlock *block = &cluster->block;
3845  int res;
3846 
3847  av_assert0(matroska->num_levels <= 2);
3848 
3849  if (matroska->num_levels == 1) {
3850  res = ebml_parse(matroska, matroska_segment, NULL);
3851 
3852  if (res == 1) {
3853  /* Found a cluster: subtract the size of the ID already read. */
3854  cluster->pos = avio_tell(matroska->ctx->pb) - 4;
3855 
3856  res = ebml_parse(matroska, matroska_cluster_enter, cluster);
3857  if (res < 0)
3858  return res;
3859  }
3860  }
3861 
3862  if (matroska->num_levels == 2) {
3863  /* We are inside a cluster. */
3864  res = ebml_parse(matroska, matroska_cluster_parsing, cluster);
3865 
3866  if (res >= 0 && block->bin.size > 0) {
3867  int is_keyframe = block->non_simple ? block->reference.count == 0 : -1;
3868  uint8_t* additional = block->additional.size > 0 ?
3869  block->additional.data : NULL;
3870 
3871  res = matroska_parse_block(matroska, block->bin.buf, block->bin.data,
3872  block->bin.size, block->bin.pos,
3873  cluster->timecode, block->duration,
3874  is_keyframe, additional, block->additional_id,
3875  block->additional.size, cluster->pos,
3876  block->discard_padding);
3877  }
3878 
3880  memset(block, 0, sizeof(*block));
3881  } else if (!matroska->num_levels) {
3882  if (!avio_feof(matroska->ctx->pb)) {
3883  avio_r8(matroska->ctx->pb);
3884  if (!avio_feof(matroska->ctx->pb)) {
3885  av_log(matroska->ctx, AV_LOG_WARNING, "File extends beyond "
3886  "end of segment.\n");
3887  return AVERROR_INVALIDDATA;
3888  }
3889  }
3890  matroska->done = 1;
3891  return AVERROR_EOF;
3892  }
3893 
3894  return res;
3895 }
3896 
3898 {
3899  MatroskaDemuxContext *matroska = s->priv_data;
3900  int ret = 0;
3901 
3902  if (matroska->resync_pos == -1) {
3903  // This can only happen if generic seeking has been used.
3904  matroska->resync_pos = avio_tell(s->pb);
3905  }
3906 
3907  while (matroska_deliver_packet(matroska, pkt)) {
3908  if (matroska->done)
3909  return (ret < 0) ? ret : AVERROR_EOF;
3910  if (matroska_parse_cluster(matroska) < 0 && !matroska->done)
3911  ret = matroska_resync(matroska, matroska->resync_pos);
3912  }
3913 
3914  return 0;
3915 }
3916 
3917 static int matroska_read_seek(AVFormatContext *s, int stream_index,
3918  int64_t timestamp, int flags)
3919 {
3920  MatroskaDemuxContext *matroska = s->priv_data;
3921  MatroskaTrack *tracks = NULL;
3922  AVStream *st = s->streams[stream_index];
3923  FFStream *const sti = ffstream(st);
3924  int i, index;
3925 
3926  /* Parse the CUES now since we need the index data to seek. */
3927  if (matroska->cues_parsing_deferred > 0) {
3928  matroska->cues_parsing_deferred = 0;
3929  matroska_parse_cues(matroska);
3930  }
3931 
3932  if (!sti->nb_index_entries)
3933  goto err;
3934  timestamp = FFMAX(timestamp, sti->index_entries[0].timestamp);
3935 
3936  if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 ||
3937  index == sti->nb_index_entries - 1) {
3938  matroska_reset_status(matroska, 0, sti->index_entries[sti->nb_index_entries - 1].pos);
3939  while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 ||
3940  index == sti->nb_index_entries - 1) {
3941  matroska_clear_queue(matroska);
3942  if (matroska_parse_cluster(matroska) < 0)
3943  break;
3944  }
3945  }
3946 
3947  matroska_clear_queue(matroska);
3948  if (index < 0 || (matroska->cues_parsing_deferred < 0 &&
3949  index == sti->nb_index_entries - 1))
3950  goto err;
3951 
3952  tracks = matroska->tracks.elem;
3953  for (i = 0; i < matroska->tracks.nb_elem; i++) {
3954  tracks[i].audio.pkt_cnt = 0;
3955  tracks[i].audio.sub_packet_cnt = 0;
3956  tracks[i].audio.buf_timecode = AV_NOPTS_VALUE;
3957  tracks[i].end_timecode = 0;
3958  }
3959 
3960  /* We seek to a level 1 element, so set the appropriate status. */
3961  matroska_reset_status(matroska, 0, sti->index_entries[index].pos);
3962  if (flags & AVSEEK_FLAG_ANY) {
3963  sti->skip_to_keyframe = 0;
3964  matroska->skip_to_timecode = timestamp;
3965  } else {
3966  sti->skip_to_keyframe = 1;
3967  matroska->skip_to_timecode = sti->index_entries[index].timestamp;
3968  }
3969  matroska->skip_to_keyframe = 1;
3970  matroska->done = 0;
3972  return 0;
3973 err:
3974  // slightly hackish but allows proper fallback to
3975  // the generic seeking code.
3976  matroska_reset_status(matroska, 0, -1);
3977  matroska->resync_pos = -1;
3978  matroska_clear_queue(matroska);
3980  matroska->skip_to_keyframe = 0;
3981  matroska->done = 0;
3982  return -1;
3983 }
3984 
3986 {
3987  MatroskaDemuxContext *matroska = s->priv_data;
3988  MatroskaTrack *tracks = matroska->tracks.elem;
3989  int n;
3990 
3991  matroska_clear_queue(matroska);
3992 
3993  for (n = 0; n < matroska->tracks.nb_elem; n++)
3994  if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
3995  av_freep(&tracks[n].audio.buf);
3996  ebml_free(matroska_segment, matroska);
3997 
3998  return 0;
3999 }
4000 
4001 #if CONFIG_WEBM_DASH_MANIFEST_DEMUXER
4002 typedef struct {
4003  int64_t start_time_ns;
4004  int64_t end_time_ns;
4005  int64_t start_offset;
4006  int64_t end_offset;
4007 } CueDesc;
4008 
4009 /* This function searches all the Cues and returns the CueDesc corresponding to
4010  * the timestamp ts. Returned CueDesc will be such that start_time_ns <= ts <
4011  * end_time_ns. All 4 fields will be set to -1 if ts >= file's duration.
4012  */
4013 static CueDesc get_cue_desc(AVFormatContext *s, int64_t ts, int64_t cues_start) {
4014  MatroskaDemuxContext *matroska = s->priv_data;
4015  FFStream *const sti = ffstream(s->streams[0]);
4016  AVIndexEntry *const index_entries = sti->index_entries;
4017  int nb_index_entries = sti->nb_index_entries;
4018  CueDesc cue_desc;
4019  int i;
4020 
4021  if (ts >= (int64_t)(matroska->duration * matroska->time_scale))
4022  return (CueDesc) {-1, -1, -1, -1};
4023  for (i = 1; i < nb_index_entries; i++) {
4024  if (index_entries[i - 1].timestamp * matroska->time_scale <= ts &&
4025  index_entries[i].timestamp * matroska->time_scale > ts) {
4026  break;
4027  }
4028  }
4029  --i;
4030  cue_desc.start_time_ns = index_entries[i].timestamp * matroska->time_scale;
4031  cue_desc.start_offset = index_entries[i].pos - matroska->segment_start;
4032  if (i != nb_index_entries - 1) {
4033  cue_desc.end_time_ns = index_entries[i + 1].timestamp * matroska->time_scale;
4034  cue_desc.end_offset = index_entries[i + 1].pos - matroska->segment_start;
4035  } else {
4036  cue_desc.end_time_ns = matroska->duration * matroska->time_scale;
4037  // FIXME: this needs special handling for files where Cues appear
4038  // before Clusters. the current logic assumes Cues appear after
4039  // Clusters.
4040  cue_desc.end_offset = cues_start - matroska->segment_start;
4041  }
4042  return cue_desc;
4043 }
4044 
4045 static int webm_clusters_start_with_keyframe(AVFormatContext *s)
4046 {
4047  MatroskaDemuxContext *matroska = s->priv_data;
4048  AVStream *const st = s->streams[0];
4049  FFStream *const sti = ffstream(st);
4050  uint32_t id = matroska->current_id;
4051  int64_t cluster_pos, before_pos;
4052  int index, rv = 1;
4053 
4054  if (sti->nb_index_entries <= 0)
4055  return 0;
4056 
4057  // seek to the first cluster using cues.
4058  index = av_index_search_timestamp(st, 0, 0);
4059  if (index < 0)
4060  return 0;
4061  cluster_pos = sti->index_entries[index].pos;
4062  before_pos = avio_tell(s->pb);
4063  while (1) {
4064  uint64_t cluster_id, cluster_length;
4065  int read;
4066  AVPacket *pkt;
4067  avio_seek(s->pb, cluster_pos, SEEK_SET);
4068  // read cluster id and length
4069  read = ebml_read_num(matroska, matroska->ctx->pb, 4, &cluster_id, 1);
4070  if (read < 0 || cluster_id != 0xF43B675) // done with all clusters
4071  break;
4072  read = ebml_read_length(matroska, matroska->ctx->pb, &cluster_length);
4073  if (read < 0)
4074  break;
4075 
4076  matroska_reset_status(matroska, 0, cluster_pos);
4077  matroska_clear_queue(matroska);
4078  if (matroska_parse_cluster(matroska) < 0 ||
4079  !matroska->queue.head) {
4080  break;
4081  }
4082  pkt = &matroska->queue.head->pkt;
4083  // 4 + read is the length of the cluster id and the cluster length field.
4084  cluster_pos += 4 + read + cluster_length;
4085  if (!(pkt->flags & AV_PKT_FLAG_KEY)) {
4086  rv = 0;
4087  break;
4088  }
4089  }
4090 
4091  /* Restore the status after matroska_read_header: */
4092  matroska_reset_status(matroska, id, before_pos);
4093 
4094  return rv;
4095 }
4096 
4097 static int buffer_size_after_time_downloaded(int64_t time_ns, double search_sec, int64_t bps,
4098  double min_buffer, double* buffer,
4099  double* sec_to_download, AVFormatContext *s,
4100  int64_t cues_start)
4101 {
4102  double nano_seconds_per_second = 1000000000.0;
4103  double time_sec = time_ns / nano_seconds_per_second;
4104  int rv = 0;
4105  int64_t time_to_search_ns = (int64_t)(search_sec * nano_seconds_per_second);
4106  int64_t end_time_ns = time_ns + time_to_search_ns;
4107  double sec_downloaded = 0.0;
4108  CueDesc desc_curr = get_cue_desc(s, time_ns, cues_start);
4109  if (desc_curr.start_time_ns == -1)
4110  return -1;
4111  *sec_to_download = 0.0;
4112 
4113  // Check for non cue start time.
4114  if (time_ns > desc_curr.start_time_ns) {
4115  int64_t cue_nano = desc_curr.end_time_ns - time_ns;
4116  double percent = (double)(cue_nano) / (desc_curr.end_time_ns - desc_curr.start_time_ns);
4117  double cueBytes = (desc_curr.end_offset - desc_curr.start_offset) * percent;
4118  double timeToDownload = (cueBytes * 8.0) / bps;
4119 
4120  sec_downloaded += (cue_nano / nano_seconds_per_second) - timeToDownload;
4121  *sec_to_download += timeToDownload;
4122 
4123  // Check if the search ends within the first cue.
4124  if (desc_curr.end_time_ns >= end_time_ns) {
4125  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
4126  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
4127  sec_downloaded = percent_to_sub * sec_downloaded;
4128  *sec_to_download = percent_to_sub * *sec_to_download;
4129  }
4130 
4131  if ((sec_downloaded + *buffer) <= min_buffer) {
4132  return 1;
4133  }
4134 
4135  // Get the next Cue.
4136  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
4137  }
4138 
4139  while (desc_curr.start_time_ns != -1) {
4140  int64_t desc_bytes = desc_curr.end_offset - desc_curr.start_offset;
4141  int64_t desc_ns = desc_curr.end_time_ns - desc_curr.start_time_ns;
4142  double desc_sec = desc_ns / nano_seconds_per_second;
4143  double bits = (desc_bytes * 8.0);
4144  double time_to_download = bits / bps;
4145 
4146  sec_downloaded += desc_sec - time_to_download;
4147  *sec_to_download += time_to_download;
4148 
4149  if (desc_curr.end_time_ns >= end_time_ns) {
4150  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
4151  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
4152  sec_downloaded = percent_to_sub * sec_downloaded;
4153  *sec_to_download = percent_to_sub * *sec_to_download;
4154 
4155  if ((sec_downloaded + *buffer) <= min_buffer)
4156  rv = 1;
4157  break;
4158  }
4159 
4160  if ((sec_downloaded + *buffer) <= min_buffer) {
4161  rv = 1;
4162  break;
4163  }
4164 
4165  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
4166  }
4167  *buffer = *buffer + sec_downloaded;
4168  return rv;
4169 }
4170 
4171 /* This function computes the bandwidth of the WebM file with the help of
4172  * buffer_size_after_time_downloaded() function. Both of these functions are
4173  * adapted from WebM Tools project and are adapted to work with FFmpeg's
4174  * Matroska parsing mechanism.
4175  *
4176  * Returns the bandwidth of the file on success; -1 on error.
4177  * */
4178 static int64_t webm_dash_manifest_compute_bandwidth(AVFormatContext *s, int64_t cues_start)
4179 {
4180  MatroskaDemuxContext *matroska = s->priv_data;
4181  AVStream *st = s->streams[0];
4182  FFStream *const sti = ffstream(st);
4183  double bandwidth = 0.0;
4184 
4185  for (int i = 0; i < sti->nb_index_entries; i++) {
4186  int64_t prebuffer_ns = 1000000000;
4187  int64_t time_ns = sti->index_entries[i].timestamp * matroska->time_scale;
4188  double nano_seconds_per_second = 1000000000.0;
4189  int64_t prebuffered_ns = time_ns + prebuffer_ns;
4190  double prebuffer_bytes = 0.0;
4191  int64_t temp_prebuffer_ns = prebuffer_ns;
4192  int64_t pre_bytes, pre_ns;
4193  double pre_sec, prebuffer, bits_per_second;
4194  CueDesc desc_beg = get_cue_desc(s, time_ns, cues_start);
4195 
4196  // Start with the first Cue.
4197  CueDesc desc_end = desc_beg;
4198 
4199  // Figure out how much data we have downloaded for the prebuffer. This will
4200  // be used later to adjust the bits per sample to try.
4201  while (desc_end.start_time_ns != -1 && desc_end.end_time_ns < prebuffered_ns) {
4202  // Prebuffered the entire Cue.
4203  prebuffer_bytes += desc_end.end_offset - desc_end.start_offset;
4204  temp_prebuffer_ns -= desc_end.end_time_ns - desc_end.start_time_ns;
4205  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
4206  }
4207  if (desc_end.start_time_ns == -1) {
4208  // The prebuffer is larger than the duration.
4209  if (matroska->duration * matroska->time_scale >= prebuffered_ns)
4210  return -1;
4211  bits_per_second = 0.0;
4212  } else {
4213  // The prebuffer ends in the last Cue. Estimate how much data was
4214  // prebuffered.
4215  pre_bytes = desc_end.end_offset - desc_end.start_offset;
4216  pre_ns = desc_end.end_time_ns - desc_end.start_time_ns;
4217  if (pre_ns <= 0)
4218  return -1;
4219  pre_sec = pre_ns / nano_seconds_per_second;
4220  prebuffer_bytes +=
4221  pre_bytes * ((temp_prebuffer_ns / nano_seconds_per_second) / pre_sec);
4222 
4223  prebuffer = prebuffer_ns / nano_seconds_per_second;
4224 
4225  // Set this to 0.0 in case our prebuffer buffers the entire video.
4226  bits_per_second = 0.0;
4227  do {
4228  int64_t desc_bytes = desc_end.end_offset - desc_beg.start_offset;
4229  int64_t desc_ns = desc_end.end_time_ns - desc_beg.start_time_ns;
4230  double desc_sec, calc_bits_per_second, percent, mod_bits_per_second;
4231  if (desc_bytes <= 0)
4232  return -1;
4233 
4234  desc_sec = desc_ns / nano_seconds_per_second;
4235  calc_bits_per_second = (desc_bytes * 8) / desc_sec;
4236 
4237  // Drop the bps by the percentage of bytes buffered.
4238  percent = (desc_bytes - prebuffer_bytes) / desc_bytes;
4239  mod_bits_per_second = calc_bits_per_second * percent;
4240 
4241  if (prebuffer < desc_sec) {
4242  double search_sec =
4243  (double)(matroska->duration * matroska->time_scale) / nano_seconds_per_second;
4244 
4245  // Add 1 so the bits per second should be a little bit greater than file
4246  // datarate.
4247  int64_t bps = (int64_t)(mod_bits_per_second) + 1;
4248  const double min_buffer = 0.0;
4249  double buffer = prebuffer;
4250  double sec_to_download = 0.0;
4251 
4252  int rv = buffer_size_after_time_downloaded(prebuffered_ns, search_sec, bps,
4253  min_buffer, &buffer, &sec_to_download,
4254  s, cues_start);
4255  if (rv < 0) {
4256  return -1;
4257  } else if (rv == 0) {
4258  bits_per_second = (double)(bps);
4259  break;
4260  }
4261  }
4262 
4263  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
4264  } while (desc_end.start_time_ns != -1);
4265  }
4266  if (bandwidth < bits_per_second) bandwidth = bits_per_second;
4267  }
4268  return (int64_t)bandwidth;
4269 }
4270 
4271 static int webm_dash_manifest_cues(AVFormatContext *s, int64_t init_range)
4272 {
4273  MatroskaDemuxContext *matroska = s->priv_data;
4274  EbmlList *seekhead_list = &matroska->seekhead;
4275  MatroskaSeekhead *seekhead = seekhead_list->elem;
4276  AVStream *const st = s->streams[0];
4277  FFStream *const sti = ffstream(st);
4278  AVBPrint bprint;
4279  char *buf;
4280  int64_t cues_start = -1, cues_end = -1, before_pos, bandwidth;
4281  int i;
4282  int ret;
4283 
4284  // determine cues start and end positions
4285  for (i = 0; i < seekhead_list->nb_elem; i++)
4286  if (seekhead[i].id == MATROSKA_ID_CUES)
4287  break;
4288 
4289  if (i >= seekhead_list->nb_elem) return -1;
4290 
4291  before_pos = avio_tell(matroska->ctx->pb);
4292  cues_start = seekhead[i].pos + matroska->segment_start;
4293  if (avio_seek(matroska->ctx->pb, cues_start, SEEK_SET) == cues_start) {
4294  // cues_end is computed as cues_start + cues_length + length of the
4295  // Cues element ID (i.e. 4) + EBML length of the Cues element.
4296  // cues_end is inclusive and the above sum is reduced by 1.
4297  uint64_t cues_length, cues_id;
4298  int bytes_read;
4299  bytes_read = ebml_read_num (matroska, matroska->ctx->pb, 4, &cues_id, 1);
4300  if (bytes_read < 0 || cues_id != (MATROSKA_ID_CUES & 0xfffffff))
4301  return bytes_read < 0 ? bytes_read : AVERROR_INVALIDDATA;
4302  bytes_read = ebml_read_length(matroska, matroska->ctx->pb, &cues_length);
4303  if (bytes_read < 0)
4304  return bytes_read;
4305  cues_end = cues_start + 4 + bytes_read + cues_length - 1;
4306  }
4307  avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
4308  if (cues_start == -1 || cues_end == -1) return -1;
4309 
4310  // parse the cues
4311  matroska_parse_cues(matroska);
4312 
4313  if (!sti->nb_index_entries)
4314  return AVERROR_INVALIDDATA;
4315 
4316  // cues start
4317  av_dict_set_int(&s->streams[0]->metadata, CUES_START, cues_start, 0);
4318 
4319  // cues end
4320  av_dict_set_int(&s->streams[0]->metadata, CUES_END, cues_end, 0);
4321 
4322  // if the file has cues at the start, fix up the init range so that
4323  // it does not include it
4324  if (cues_start <= init_range)
4325  av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, cues_start - 1, 0);
4326 
4327  // bandwidth
4328  bandwidth = webm_dash_manifest_compute_bandwidth(s, cues_start);
4329  if (bandwidth < 0) return -1;
4330  av_dict_set_int(&s->streams[0]->metadata, BANDWIDTH, bandwidth, 0);
4331 
4332  // check if all clusters start with key frames
4333  av_dict_set_int(&s->streams[0]->metadata, CLUSTER_KEYFRAME, webm_clusters_start_with_keyframe(s), 0);
4334 
4335  // Store cue point timestamps as a comma separated list
4336  // for checking subsegment alignment in the muxer.
4338  for (int i = 0; i < sti->nb_index_entries; i++)
4339  av_bprintf(&bprint, "%" PRId64",", sti->index_entries[i].timestamp);
4340  if (!av_bprint_is_complete(&bprint)) {
4341  av_bprint_finalize(&bprint, NULL);
4342  return AVERROR(ENOMEM);
4343  }
4344  // Remove the trailing ','
4345  bprint.str[--bprint.len] = '\0';
4346  if ((ret = av_bprint_finalize(&bprint, &buf)) < 0)
4347  return ret;
4348  av_dict_set(&s->streams[0]->metadata, CUE_TIMESTAMPS,
4350 
4351  return 0;
4352 }
4353 
4354 static int webm_dash_manifest_read_header(AVFormatContext *s)
4355 {
4356  char *buf;
4357  int ret = matroska_read_header(s);
4358  int64_t init_range;
4359  MatroskaTrack *tracks;
4360  MatroskaDemuxContext *matroska = s->priv_data;
4361  if (ret) {
4362  av_log(s, AV_LOG_ERROR, "Failed to read file headers\n");
4363  return -1;
4364  }
4365  if (!matroska->tracks.nb_elem || !s->nb_streams) {
4366  av_log(s, AV_LOG_ERROR, "No track found\n");
4367  return AVERROR_INVALIDDATA;
4368  }
4369 
4370  if (!matroska->is_live) {
4371  buf = av_asprintf("%g", matroska->duration);
4372  if (!buf)
4373  return AVERROR(ENOMEM);
4374  av_dict_set(&s->streams[0]->metadata, DURATION,
4376 
4377  // initialization range
4378  // 5 is the offset of Cluster ID.
4379  init_range = avio_tell(s->pb) - 5;
4380  av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, init_range, 0);
4381  }
4382 
4383  // basename of the file
4384  buf = strrchr(s->url, '/');
4385  av_dict_set(&s->streams[0]->metadata, FILENAME, buf ? ++buf : s->url, 0);
4386 
4387  // track number
4388  tracks = matroska->tracks.elem;
4389  av_dict_set_int(&s->streams[0]->metadata, TRACK_NUMBER, tracks[0].num, 0);
4390 
4391  // parse the cues and populate Cue related fields
4392  if (!matroska->is_live) {
4393  ret = webm_dash_manifest_cues(s, init_range);
4394  if (ret < 0) {
4395  av_log(s, AV_LOG_ERROR, "Error parsing Cues\n");
4396  return ret;
4397  }
4398  }
4399