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