FFmpeg  4.3.8
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 
33 #include <inttypes.h>
34 #include <stdio.h>
35 
36 #include "libavutil/avstring.h"
37 #include "libavutil/base64.h"
38 #include "libavutil/dict.h"
39 #include "libavutil/intfloat.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavutil/lzo.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/opt.h"
46 #include "libavutil/spherical.h"
47 
48 #include "libavcodec/bytestream.h"
49 #include "libavcodec/flac.h"
50 #include "libavcodec/mpeg4audio.h"
51 
52 #include "avformat.h"
53 #include "avio_internal.h"
54 #include "internal.h"
55 #include "isom.h"
56 #include "matroska.h"
57 #include "oggdec.h"
58 /* For ff_codec_get_id(). */
59 #include "riff.h"
60 #include "rmsipr.h"
61 
62 #if CONFIG_BZLIB
63 #include <bzlib.h>
64 #endif
65 #if CONFIG_ZLIB
66 #include <zlib.h>
67 #endif
68 
69 #include "qtpalette.h"
70 
71 #define EBML_UNKNOWN_LENGTH UINT64_MAX /* EBML unknown length, in uint64_t */
72 #define NEEDS_CHECKING 2 /* Indicates that some error checks
73  * still need to be performed */
74 #define LEVEL_ENDED 3 /* return value of ebml_parse when the
75  * syntax level used for parsing ended. */
76 #define SKIP_THRESHOLD 1024 * 1024 /* In non-seekable mode, if more than SKIP_THRESHOLD
77  * of unkown, potentially damaged data is encountered,
78  * it is considered an error. */
79 #define UNKNOWN_EQUIV 50 * 1024 /* An unknown element is considered equivalent
80  * to this many bytes of unknown data for the
81  * SKIP_THRESHOLD check. */
82 
83 typedef enum {
95 } EbmlType;
96 
97 typedef const struct EbmlSyntax {
98  uint32_t id;
101  size_t data_offset;
102  union {
104  uint64_t u;
105  double f;
106  const char *s;
107  const struct EbmlSyntax *n;
108  } def;
109 } EbmlSyntax;
110 
111 typedef struct EbmlList {
112  int nb_elem;
113  unsigned int alloc_elem_size;
114  void *elem;
115 } EbmlList;
116 
117 typedef struct EbmlBin {
118  int size;
122 } EbmlBin;
123 
124 typedef struct Ebml {
125  uint64_t version;
126  uint64_t max_size;
127  uint64_t id_length;
128  char *doctype;
129  uint64_t doctype_version;
130 } Ebml;
131 
132 typedef struct MatroskaTrackCompression {
133  uint64_t algo;
136 
137 typedef struct MatroskaTrackEncryption {
138  uint64_t algo;
141 
142 typedef struct MatroskaTrackEncoding {
143  uint64_t scope;
144  uint64_t type;
148 
149 typedef struct MatroskaMasteringMeta {
150  double r_x;
151  double r_y;
152  double g_x;
153  double g_y;
154  double b_x;
155  double b_y;
156  double white_x;
157  double white_y;
161 
162 typedef struct MatroskaTrackVideoColor {
165  uint64_t chroma_sub_horz;
166  uint64_t chroma_sub_vert;
167  uint64_t cb_sub_horz;
168  uint64_t cb_sub_vert;
171  uint64_t range;
173  uint64_t primaries;
174  uint64_t max_cll;
175  uint64_t max_fall;
178 
180  uint64_t type;
181  EbmlBin private;
182  double yaw;
183  double pitch;
184  double roll;
186 
187 typedef struct MatroskaTrackVideo {
188  double frame_rate;
189  uint64_t display_width;
190  uint64_t display_height;
191  uint64_t pixel_width;
192  uint64_t pixel_height;
194  uint64_t display_unit;
195  uint64_t interlaced;
196  uint64_t field_order;
197  uint64_t stereo_mode;
198  uint64_t alpha_mode;
202 
203 typedef struct MatroskaTrackAudio {
204  double samplerate;
206  uint64_t bitdepth;
207  uint64_t channels;
208 
209  /* real audio header (extracted from extradata) */
215  int pkt_cnt;
216  uint64_t buf_timecode;
219 
220 typedef struct MatroskaTrackPlane {
221  uint64_t uid;
222  uint64_t type;
224 
225 typedef struct MatroskaTrackOperation {
228 
229 typedef struct MatroskaTrack {
230  uint64_t num;
231  uint64_t uid;
232  uint64_t type;
233  char *name;
234  char *codec_id;
236  char *language;
237  double time_scale;
239  uint64_t flag_default;
240  uint64_t flag_forced;
241  uint64_t seek_preroll;
246  uint64_t codec_delay;
248 
254 
255  uint32_t palette[AVPALETTE_COUNT];
257 } MatroskaTrack;
258 
259 typedef struct MatroskaAttachment {
260  uint64_t uid;
261  char *filename;
262  char *description;
263  char *mime;
265 
268 
269 typedef struct MatroskaChapter {
270  uint64_t start;
271  uint64_t end;
272  uint64_t uid;
273  char *title;
274 
277 
278 typedef struct MatroskaIndexPos {
279  uint64_t track;
280  uint64_t pos;
282 
283 typedef struct MatroskaIndex {
284  uint64_t time;
286 } MatroskaIndex;
287 
288 typedef struct MatroskaTag {
289  char *name;
290  char *string;
291  char *lang;
292  uint64_t def;
294 } MatroskaTag;
295 
296 typedef struct MatroskaTagTarget {
297  char *type;
298  uint64_t typevalue;
299  uint64_t trackuid;
300  uint64_t chapteruid;
301  uint64_t attachuid;
303 
304 typedef struct MatroskaTags {
307 } MatroskaTags;
308 
309 typedef struct MatroskaSeekhead {
310  uint64_t id;
311  uint64_t pos;
313 
314 typedef struct MatroskaLevel {
315  uint64_t start;
316  uint64_t length;
317 } MatroskaLevel;
318 
319 typedef struct MatroskaBlock {
320  uint64_t duration;
322  uint64_t non_simple;
324  uint64_t additional_id;
327 } MatroskaBlock;
328 
329 typedef struct MatroskaCluster {
331  uint64_t timecode;
334 
335 typedef struct MatroskaLevel1Element {
337  uint32_t id;
338  int parsed;
340 
341 typedef struct MatroskaDemuxContext {
342  const AVClass *class;
344 
345  /* EBML stuff */
348  uint32_t current_id;
351 
352  uint64_t time_scale;
353  double duration;
354  char *title;
355  char *muxingapp;
363 
364  /* byte position of the segment inside the stream */
366 
367  /* the packet queue */
370 
371  int done;
372 
373  /* What to skip before effectively reading a packet. */
376 
377  /* File has a CUES element, but we defer parsing until it is needed. */
379 
380  /* Level1 elements and whether they were read yet */
381  MatroskaLevel1Element level1_elems[64];
383 
385 
386  /* WebM DASH Manifest live flag */
387  int is_live;
388 
389  /* Bandwidth value for WebM DASH Manifest */
392 
393 #define CHILD_OF(parent) { .def = { .n = parent } }
394 
395 // The following forward declarations need their size because
396 // a tentative definition with internal linkage must not be an
397 // incomplete type (6.7.2 in C90, 6.9.2 in C99).
398 // Removing the sizes breaks MSVC.
405 
407  { EBML_ID_EBMLREADVERSION, EBML_UINT, 0, offsetof(Ebml, version), { .u = EBML_VERSION } },
408  { EBML_ID_EBMLMAXSIZELENGTH, EBML_UINT, 0, offsetof(Ebml, max_size), { .u = 8 } },
409  { EBML_ID_EBMLMAXIDLENGTH, EBML_UINT, 0, offsetof(Ebml, id_length), { .u = 4 } },
410  { EBML_ID_DOCTYPE, EBML_STR, 0, offsetof(Ebml, doctype), { .s = "(none)" } },
411  { EBML_ID_DOCTYPEREADVERSION, EBML_UINT, 0, offsetof(Ebml, doctype_version), { .u = 1 } },
413  { EBML_ID_DOCTYPEVERSION, EBML_NONE },
414  CHILD_OF(ebml_syntax)
415 };
416 
417 static EbmlSyntax ebml_syntax[] = {
418  { EBML_ID_HEADER, EBML_NEST, 0, 0, { .n = ebml_header } },
420  { 0 }
421 };
422 
424  { MATROSKA_ID_TIMECODESCALE, EBML_UINT, 0, offsetof(MatroskaDemuxContext, time_scale), { .u = 1000000 } },
426  { MATROSKA_ID_TITLE, EBML_UTF8, 0, offsetof(MatroskaDemuxContext, title) },
428  { MATROSKA_ID_MUXINGAPP, EBML_UTF8, 0, offsetof(MatroskaDemuxContext, muxingapp) },
429  { MATROSKA_ID_DATEUTC, EBML_BIN, 0, offsetof(MatroskaDemuxContext, date_utc) },
430  { MATROSKA_ID_SEGMENTUID, EBML_NONE },
431  CHILD_OF(matroska_segment)
432 };
433 
435  { MATROSKA_ID_VIDEOCOLOR_RX, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, r_x), { .f=-1 } },
436  { MATROSKA_ID_VIDEOCOLOR_RY, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, r_y), { .f=-1 } },
437  { MATROSKA_ID_VIDEOCOLOR_GX, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, g_x), { .f=-1 } },
438  { MATROSKA_ID_VIDEOCOLOR_GY, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, g_y), { .f=-1 } },
439  { MATROSKA_ID_VIDEOCOLOR_BX, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, b_x), { .f=-1 } },
440  { MATROSKA_ID_VIDEOCOLOR_BY, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, b_y), { .f=-1 } },
441  { MATROSKA_ID_VIDEOCOLOR_WHITEX, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, white_x), { .f=-1 } },
442  { MATROSKA_ID_VIDEOCOLOR_WHITEY, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, white_y), { .f=-1 } },
443  { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, min_luminance), { .f=-1 } },
444  { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, max_luminance), { .f=-1 } },
445  CHILD_OF(matroska_track_video_color)
446 };
447 
448 static EbmlSyntax matroska_track_video_color[] = {
449  { MATROSKA_ID_VIDEOCOLORMATRIXCOEFF, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, matrix_coefficients), { .u = AVCOL_SPC_UNSPECIFIED } },
450  { MATROSKA_ID_VIDEOCOLORBITSPERCHANNEL, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, bits_per_channel), { .u=0 } },
451  { MATROSKA_ID_VIDEOCOLORCHROMASUBHORZ, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, chroma_sub_horz), { .u=0 } },
452  { MATROSKA_ID_VIDEOCOLORCHROMASUBVERT, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, chroma_sub_vert), { .u=0 } },
453  { MATROSKA_ID_VIDEOCOLORCBSUBHORZ, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, cb_sub_horz), { .u=0 } },
454  { MATROSKA_ID_VIDEOCOLORCBSUBVERT, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, cb_sub_vert), { .u=0 } },
460  { MATROSKA_ID_VIDEOCOLORMAXCLL, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, max_cll), { .u=0 } },
461  { MATROSKA_ID_VIDEOCOLORMAXFALL, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, max_fall), { .u=0 } },
462  { MATROSKA_ID_VIDEOCOLORMASTERINGMETA, EBML_NEST, 0, offsetof(MatroskaTrackVideoColor, mastering_meta), { .n = matroska_mastering_meta } },
463  CHILD_OF(matroska_track_video)
464 };
465 
472  CHILD_OF(matroska_track_video)
473 };
474 
475 static EbmlSyntax matroska_track_video[] = {
476  { MATROSKA_ID_VIDEOFRAMERATE, EBML_FLOAT, 0, offsetof(MatroskaTrackVideo, frame_rate) },
477  { MATROSKA_ID_VIDEODISPLAYWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo, display_width), { .u=-1 } },
478  { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo, display_height), { .u=-1 } },
479  { MATROSKA_ID_VIDEOPIXELWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo, pixel_width) },
480  { MATROSKA_ID_VIDEOPIXELHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo, pixel_height) },
481  { MATROSKA_ID_VIDEOCOLORSPACE, EBML_BIN, 0, offsetof(MatroskaTrackVideo, color_space) },
482  { MATROSKA_ID_VIDEOALPHAMODE, EBML_UINT, 0, offsetof(MatroskaTrackVideo, alpha_mode) },
483  { MATROSKA_ID_VIDEOCOLOR, EBML_NEST, sizeof(MatroskaTrackVideoColor), offsetof(MatroskaTrackVideo, color), { .n = matroska_track_video_color } },
484  { MATROSKA_ID_VIDEOPROJECTION, EBML_NEST, 0, offsetof(MatroskaTrackVideo, projection), { .n = matroska_track_video_projection } },
486  { MATROSKA_ID_VIDEOPIXELCROPT, EBML_NONE },
487  { MATROSKA_ID_VIDEOPIXELCROPL, EBML_NONE },
488  { MATROSKA_ID_VIDEOPIXELCROPR, EBML_NONE },
493  { MATROSKA_ID_VIDEOASPECTRATIO, EBML_NONE },
494  CHILD_OF(matroska_track)
495 };
496 
498  { MATROSKA_ID_AUDIOSAMPLINGFREQ, EBML_FLOAT, 0, offsetof(MatroskaTrackAudio, samplerate), { .f = 8000.0 } },
499  { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, EBML_FLOAT, 0, offsetof(MatroskaTrackAudio, out_samplerate) },
500  { MATROSKA_ID_AUDIOBITDEPTH, EBML_UINT, 0, offsetof(MatroskaTrackAudio, bitdepth) },
501  { MATROSKA_ID_AUDIOCHANNELS, EBML_UINT, 0, offsetof(MatroskaTrackAudio, channels), { .u = 1 } },
502  CHILD_OF(matroska_track)
503 };
504 
508  CHILD_OF(matroska_track_encoding)
509 };
510 
515  { MATROSKA_ID_ENCODINGSIGALGO, EBML_NONE },
516  { MATROSKA_ID_ENCODINGSIGHASHALGO, EBML_NONE },
517  { MATROSKA_ID_ENCODINGSIGKEYID, EBML_NONE },
518  { MATROSKA_ID_ENCODINGSIGNATURE, EBML_NONE },
519  CHILD_OF(matroska_track_encoding)
520 };
521 static EbmlSyntax matroska_track_encoding[] = {
522  { MATROSKA_ID_ENCODINGSCOPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding, scope), { .u = 1 } },
523  { MATROSKA_ID_ENCODINGTYPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding, type), { .u = 0 } },
524  { MATROSKA_ID_ENCODINGCOMPRESSION, EBML_NEST, 0, offsetof(MatroskaTrackEncoding, compression), { .n = matroska_track_encoding_compression } },
525  { MATROSKA_ID_ENCODINGENCRYPTION, EBML_NEST, 0, offsetof(MatroskaTrackEncoding, encryption), { .n = matroska_track_encoding_encryption } },
527  CHILD_OF(matroska_track_encodings)
528 };
529 
530 static EbmlSyntax matroska_track_encodings[] = {
531  { MATROSKA_ID_TRACKCONTENTENCODING, EBML_NEST, sizeof(MatroskaTrackEncoding), offsetof(MatroskaTrack, encodings), { .n = matroska_track_encoding } },
532  CHILD_OF(matroska_track)
533 };
534 
538  CHILD_OF(matroska_track_combine_planes)
539 };
540 
541 static EbmlSyntax matroska_track_combine_planes[] = {
542  { MATROSKA_ID_TRACKPLANE, EBML_NEST, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n = matroska_track_plane} },
543  CHILD_OF(matroska_track_operation)
544 };
545 
546 static EbmlSyntax matroska_track_operation[] = {
547  { MATROSKA_ID_TRACKCOMBINEPLANES, EBML_NEST, 0, 0, {.n = matroska_track_combine_planes} },
548  CHILD_OF(matroska_track)
549 };
550 
551 static EbmlSyntax matroska_track[] = {
552  { MATROSKA_ID_TRACKNUMBER, EBML_UINT, 0, offsetof(MatroskaTrack, num) },
554  { MATROSKA_ID_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTrack, uid) },
557  { MATROSKA_ID_CODECPRIVATE, EBML_BIN, 0, offsetof(MatroskaTrack, codec_priv) },
558  { MATROSKA_ID_CODECDELAY, EBML_UINT, 0, offsetof(MatroskaTrack, codec_delay) },
559  { MATROSKA_ID_TRACKLANGUAGE, EBML_STR, 0, offsetof(MatroskaTrack, language), { .s = "eng" } },
560  { MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, offsetof(MatroskaTrack, default_duration) },
561  { MATROSKA_ID_TRACKTIMECODESCALE, EBML_FLOAT, 0, offsetof(MatroskaTrack, time_scale), { .f = 1.0 } },
562  { MATROSKA_ID_TRACKFLAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTrack, flag_default), { .u = 1 } },
563  { MATROSKA_ID_TRACKFLAGFORCED, EBML_UINT, 0, offsetof(MatroskaTrack, flag_forced), { .u = 0 } },
564  { MATROSKA_ID_TRACKVIDEO, EBML_NEST, 0, offsetof(MatroskaTrack, video), { .n = matroska_track_video } },
565  { MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, offsetof(MatroskaTrack, audio), { .n = matroska_track_audio } },
566  { MATROSKA_ID_TRACKOPERATION, EBML_NEST, 0, offsetof(MatroskaTrack, operation), { .n = matroska_track_operation } },
567  { MATROSKA_ID_TRACKCONTENTENCODINGS, EBML_NEST, 0, 0, { .n = matroska_track_encodings } },
568  { MATROSKA_ID_TRACKMAXBLKADDID, EBML_UINT, 0, offsetof(MatroskaTrack, max_block_additional_id) },
569  { MATROSKA_ID_SEEKPREROLL, EBML_UINT, 0, offsetof(MatroskaTrack, seek_preroll) },
571  { MATROSKA_ID_TRACKFLAGLACING, EBML_NONE },
572  { MATROSKA_ID_CODECNAME, EBML_NONE },
573  { MATROSKA_ID_CODECDECODEALL, EBML_NONE },
574  { MATROSKA_ID_CODECINFOURL, EBML_NONE },
575  { MATROSKA_ID_CODECDOWNLOADURL, EBML_NONE },
576  { MATROSKA_ID_TRACKMINCACHE, EBML_NONE },
577  { MATROSKA_ID_TRACKMAXCACHE, EBML_NONE },
578  CHILD_OF(matroska_tracks)
579 };
580 
581 static EbmlSyntax matroska_tracks[] = {
582  { MATROSKA_ID_TRACKENTRY, EBML_NEST, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext, tracks), { .n = matroska_track } },
583  CHILD_OF(matroska_segment)
584 };
585 
588  { MATROSKA_ID_FILENAME, EBML_UTF8, 0, offsetof(MatroskaAttachment, filename) },
589  { MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, offsetof(MatroskaAttachment, mime) },
590  { MATROSKA_ID_FILEDATA, EBML_BIN, 0, offsetof(MatroskaAttachment, bin) },
591  { MATROSKA_ID_FILEDESC, EBML_UTF8, 0, offsetof(MatroskaAttachment, description) },
592  CHILD_OF(matroska_attachments)
593 };
594 
595 static EbmlSyntax matroska_attachments[] = {
596  { MATROSKA_ID_ATTACHEDFILE, EBML_NEST, sizeof(MatroskaAttachment), offsetof(MatroskaDemuxContext, attachments), { .n = matroska_attachment } },
597  CHILD_OF(matroska_segment)
598 };
599 
601  { MATROSKA_ID_CHAPSTRING, EBML_UTF8, 0, offsetof(MatroskaChapter, title) },
603  { MATROSKA_ID_CHAPCOUNTRY, EBML_NONE },
604  CHILD_OF(matroska_chapter_entry)
605 };
606 
607 static EbmlSyntax matroska_chapter_entry[] = {
608  { MATROSKA_ID_CHAPTERTIMESTART, EBML_UINT, 0, offsetof(MatroskaChapter, start), { .u = AV_NOPTS_VALUE } },
611  { MATROSKA_ID_CHAPTERDISPLAY, EBML_NEST, 0, 0, { .n = matroska_chapter_display } },
613  { MATROSKA_ID_CHAPTERFLAGENABLED, EBML_NONE },
614  { MATROSKA_ID_CHAPTERPHYSEQUIV, EBML_NONE },
615  { MATROSKA_ID_CHAPTERATOM, EBML_NONE },
616  CHILD_OF(matroska_chapter)
617 };
618 
619 static EbmlSyntax matroska_chapter[] = {
620  { MATROSKA_ID_CHAPTERATOM, EBML_NEST, sizeof(MatroskaChapter), offsetof(MatroskaDemuxContext, chapters), { .n = matroska_chapter_entry } },
622  { MATROSKA_ID_EDITIONFLAGHIDDEN, EBML_NONE },
623  { MATROSKA_ID_EDITIONFLAGDEFAULT, EBML_NONE },
624  { MATROSKA_ID_EDITIONFLAGORDERED, EBML_NONE },
625  CHILD_OF(matroska_chapters)
626 };
627 
628 static EbmlSyntax matroska_chapters[] = {
629  { MATROSKA_ID_EDITIONENTRY, EBML_NEST, 0, 0, { .n = matroska_chapter } },
630  CHILD_OF(matroska_segment)
631 };
632 
634  { MATROSKA_ID_CUETRACK, EBML_UINT, 0, offsetof(MatroskaIndexPos, track) },
637  { MATROSKA_ID_CUEDURATION, EBML_NONE },
638  { MATROSKA_ID_CUEBLOCKNUMBER, EBML_NONE },
639  CHILD_OF(matroska_index_entry)
640 };
641 
642 static EbmlSyntax matroska_index_entry[] = {
643  { MATROSKA_ID_CUETIME, EBML_UINT, 0, offsetof(MatroskaIndex, time) },
644  { MATROSKA_ID_CUETRACKPOSITION, EBML_NEST, sizeof(MatroskaIndexPos), offsetof(MatroskaIndex, pos), { .n = matroska_index_pos } },
645  CHILD_OF(matroska_index)
646 };
647 
648 static EbmlSyntax matroska_index[] = {
649  { MATROSKA_ID_POINTENTRY, EBML_NEST, sizeof(MatroskaIndex), offsetof(MatroskaDemuxContext, index), { .n = matroska_index_entry } },
650  CHILD_OF(matroska_segment)
651 };
652 
654  { MATROSKA_ID_TAGNAME, EBML_UTF8, 0, offsetof(MatroskaTag, name) },
655  { MATROSKA_ID_TAGSTRING, EBML_UTF8, 0, offsetof(MatroskaTag, string) },
656  { MATROSKA_ID_TAGLANG, EBML_STR, 0, offsetof(MatroskaTag, lang), { .s = "und" } },
657  { MATROSKA_ID_TAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTag, def) },
659  { MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTag, sub), { .n = matroska_simpletag } },
660  CHILD_OF(matroska_tag)
661 };
662 
665  { MATROSKA_ID_TAGTARGETS_TYPEVALUE, EBML_UINT, 0, offsetof(MatroskaTagTarget, typevalue), { .u = 50 } },
666  { MATROSKA_ID_TAGTARGETS_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, trackuid) },
667  { MATROSKA_ID_TAGTARGETS_CHAPTERUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, chapteruid) },
668  { MATROSKA_ID_TAGTARGETS_ATTACHUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, attachuid) },
669  CHILD_OF(matroska_tag)
670 };
671 
672 static EbmlSyntax matroska_tag[] = {
673  { MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTags, tag), { .n = matroska_simpletag } },
674  { MATROSKA_ID_TAGTARGETS, EBML_NEST, 0, offsetof(MatroskaTags, target), { .n = matroska_tagtargets } },
675  CHILD_OF(matroska_tags)
676 };
677 
678 static EbmlSyntax matroska_tags[] = {
679  { MATROSKA_ID_TAG, EBML_NEST, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext, tags), { .n = matroska_tag } },
680  CHILD_OF(matroska_segment)
681 };
682 
684  { MATROSKA_ID_SEEKID, EBML_UINT, 0, offsetof(MatroskaSeekhead, id) },
685  { MATROSKA_ID_SEEKPOSITION, EBML_UINT, 0, offsetof(MatroskaSeekhead, pos), { .u = -1 } },
686  CHILD_OF(matroska_seekhead)
687 };
688 
689 static EbmlSyntax matroska_seekhead[] = {
690  { MATROSKA_ID_SEEKENTRY, EBML_NEST, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext, seekhead), { .n = matroska_seekhead_entry } },
691  CHILD_OF(matroska_segment)
692 };
693 
694 static EbmlSyntax matroska_segment[] = {
696  { MATROSKA_ID_INFO, EBML_LEVEL1, 0, 0, { .n = matroska_info } },
697  { MATROSKA_ID_TRACKS, EBML_LEVEL1, 0, 0, { .n = matroska_tracks } },
698  { MATROSKA_ID_ATTACHMENTS, EBML_LEVEL1, 0, 0, { .n = matroska_attachments } },
699  { MATROSKA_ID_CHAPTERS, EBML_LEVEL1, 0, 0, { .n = matroska_chapters } },
700  { MATROSKA_ID_CUES, EBML_LEVEL1, 0, 0, { .n = matroska_index } },
701  { MATROSKA_ID_TAGS, EBML_LEVEL1, 0, 0, { .n = matroska_tags } },
702  { MATROSKA_ID_SEEKHEAD, EBML_LEVEL1, 0, 0, { .n = matroska_seekhead } },
703  { 0 } /* We don't want to go back to level 0, so don't add the parent. */
704 };
705 
707  { MATROSKA_ID_SEGMENT, EBML_NEST, 0, 0, { .n = matroska_segment } },
708  { 0 }
709 };
710 
712  { MATROSKA_ID_BLOCKADDID, EBML_UINT, 0, offsetof(MatroskaBlock,additional_id), { .u = 1 } },
713  { MATROSKA_ID_BLOCKADDITIONAL, EBML_BIN, 0, offsetof(MatroskaBlock,additional) },
714  CHILD_OF(matroska_blockadditions)
715 };
716 
717 static EbmlSyntax matroska_blockadditions[] = {
718  { MATROSKA_ID_BLOCKMORE, EBML_NEST, 0, 0, {.n = matroska_blockmore} },
719  CHILD_OF(matroska_blockgroup)
720 };
721 
722 static EbmlSyntax matroska_blockgroup[] = {
723  { MATROSKA_ID_BLOCK, EBML_BIN, 0, offsetof(MatroskaBlock, bin) },
724  { MATROSKA_ID_BLOCKADDITIONS, EBML_NEST, 0, 0, { .n = matroska_blockadditions} },
726  { MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, offsetof(MatroskaBlock, discard_padding) },
727  { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, offsetof(MatroskaBlock, reference), { .i = INT64_MIN } },
729  { 1, EBML_UINT, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
730  CHILD_OF(matroska_cluster_parsing)
731 };
732 
733 // The following array contains SimpleBlock and BlockGroup twice
734 // in order to reuse the other values for matroska_cluster_enter.
735 static EbmlSyntax matroska_cluster_parsing[] = {
736  { MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, offsetof(MatroskaBlock, bin) },
737  { MATROSKA_ID_BLOCKGROUP, EBML_NEST, 0, 0, { .n = matroska_blockgroup } },
738  { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, offsetof(MatroskaCluster, timecode) },
740  { MATROSKA_ID_BLOCKGROUP, EBML_STOP },
742  { MATROSKA_ID_CLUSTERPREVSIZE, EBML_NONE },
743  CHILD_OF(matroska_segment)
744 };
745 
747  { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, { .n = &matroska_cluster_parsing[2] } },
748  { 0 }
749 };
750 #undef CHILD_OF
751 
752 static const CodecMime mkv_image_mime_tags[] = {
753  {"image/gif" , AV_CODEC_ID_GIF},
754  {"image/jpeg" , AV_CODEC_ID_MJPEG},
755  {"image/png" , AV_CODEC_ID_PNG},
756  {"image/tiff" , AV_CODEC_ID_TIFF},
757 
758  {"" , AV_CODEC_ID_NONE}
759 };
760 
761 static const CodecMime mkv_mime_tags[] = {
762  {"text/plain" , AV_CODEC_ID_TEXT},
763  {"application/x-truetype-font", AV_CODEC_ID_TTF},
764  {"application/x-font" , AV_CODEC_ID_TTF},
765  {"application/vnd.ms-opentype", AV_CODEC_ID_OTF},
766  {"binary" , AV_CODEC_ID_BIN_DATA},
767 
768  {"" , AV_CODEC_ID_NONE}
769 };
770 
771 static const char *const matroska_doctypes[] = { "matroska", "webm" };
772 
774 
775 /*
776  * This function prepares the status for parsing of level 1 elements.
777  */
779  uint32_t id, int64_t position)
780 {
781  int64_t err = 0;
782  if (position >= 0) {
783  err = avio_seek(matroska->ctx->pb, position, SEEK_SET);
784  if (err > 0)
785  err = 0;
786  } else
787  position = avio_tell(matroska->ctx->pb);
788 
789  matroska->current_id = id;
790  matroska->num_levels = 1;
791  matroska->unknown_count = 0;
792  matroska->resync_pos = position;
793  if (id)
794  matroska->resync_pos -= (av_log2(id) + 7) / 8;
795 
796  return err;
797 }
798 
799 static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
800 {
801  AVIOContext *pb = matroska->ctx->pb;
802  uint32_t id;
803 
804  /* Try to seek to the last position to resync from. If this doesn't work,
805  * we resync from the earliest position available: The start of the buffer. */
806  if (last_pos < avio_tell(pb) && avio_seek(pb, last_pos + 1, SEEK_SET) < 0) {
807  av_log(matroska->ctx, AV_LOG_WARNING,
808  "Seek to desired resync point failed. Seeking to "
809  "earliest point available instead.\n");
810  avio_seek(pb, FFMAX(avio_tell(pb) + (pb->buffer - pb->buf_ptr),
811  last_pos + 1), SEEK_SET);
812  }
813 
814  id = avio_rb32(pb);
815 
816  // try to find a toplevel element
817  while (!avio_feof(pb)) {
818  if (id == MATROSKA_ID_INFO || id == MATROSKA_ID_TRACKS ||
819  id == MATROSKA_ID_CUES || id == MATROSKA_ID_TAGS ||
821  id == MATROSKA_ID_CLUSTER || id == MATROSKA_ID_CHAPTERS) {
822  /* Prepare the context for parsing of a level 1 element. */
823  matroska_reset_status(matroska, id, -1);
824  /* Given that we are here means that an error has occurred,
825  * so treat the segment as unknown length in order not to
826  * discard valid data that happens to be beyond the designated
827  * end of the segment. */
828  matroska->levels[0].length = EBML_UNKNOWN_LENGTH;
829  return 0;
830  }
831  id = (id << 8) | avio_r8(pb);
832  }
833 
834  matroska->done = 1;
835  return pb->error ? pb->error : AVERROR_EOF;
836 }
837 
838 /*
839  * Read: an "EBML number", which is defined as a variable-length
840  * array of bytes. The first byte indicates the length by giving a
841  * number of 0-bits followed by a one. The position of the first
842  * "one" bit inside the first byte indicates the length of this
843  * number.
844  * Returns: number of bytes read, < 0 on error
845  */
847  int max_size, uint64_t *number, int eof_forbidden)
848 {
849  int read, n = 1;
850  uint64_t total;
851  int64_t pos;
852 
853  /* The first byte tells us the length in bytes - except when it is zero. */
854  total = avio_r8(pb);
855  if (pb->eof_reached)
856  goto err;
857 
858  /* get the length of the EBML number */
859  read = 8 - ff_log2_tab[total];
860 
861  if (!total || read > max_size) {
862  pos = avio_tell(pb) - 1;
863  if (!total) {
864  av_log(matroska->ctx, AV_LOG_ERROR,
865  "0x00 at pos %"PRId64" (0x%"PRIx64") invalid as first byte "
866  "of an EBML number\n", pos, pos);
867  } else {
868  av_log(matroska->ctx, AV_LOG_ERROR,
869  "Length %d indicated by an EBML number's first byte 0x%02x "
870  "at pos %"PRId64" (0x%"PRIx64") exceeds max length %d.\n",
871  read, (uint8_t) total, pos, pos, max_size);
872  }
873  return AVERROR_INVALIDDATA;
874  }
875 
876  /* read out length */
877  total ^= 1 << ff_log2_tab[total];
878  while (n++ < read)
879  total = (total << 8) | avio_r8(pb);
880 
881  if (pb->eof_reached) {
882  eof_forbidden = 1;
883  goto err;
884  }
885 
886  *number = total;
887 
888  return read;
889 
890 err:
891  pos = avio_tell(pb);
892  if (pb->error) {
893  av_log(matroska->ctx, AV_LOG_ERROR,
894  "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
895  pos, pos);
896  return pb->error;
897  }
898  if (eof_forbidden) {
899  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely "
900  "at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
901  return AVERROR(EIO);
902  }
903  return AVERROR_EOF;
904 }
905 
906 /**
907  * Read a EBML length value.
908  * This needs special handling for the "unknown length" case which has multiple
909  * encodings.
910  */
912  uint64_t *number)
913 {
914  int res = ebml_read_num(matroska, pb, 8, number, 1);
915  if (res > 0 && *number + 1 == 1ULL << (7 * res))
916  *number = EBML_UNKNOWN_LENGTH;
917  return res;
918 }
919 
920 /*
921  * Read the next element as an unsigned int.
922  * Returns NEEDS_CHECKING.
923  */
924 static int ebml_read_uint(AVIOContext *pb, int size, uint64_t *num)
925 {
926  int n = 0;
927 
928  /* big-endian ordering; build up number */
929  *num = 0;
930  while (n++ < size)
931  *num = (*num << 8) | avio_r8(pb);
932 
933  return NEEDS_CHECKING;
934 }
935 
936 /*
937  * Read the next element as a signed int.
938  * Returns NEEDS_CHECKING.
939  */
940 static int ebml_read_sint(AVIOContext *pb, int size, int64_t *num)
941 {
942  int n = 1;
943 
944  if (size == 0) {
945  *num = 0;
946  } else {
947  *num = sign_extend(avio_r8(pb), 8);
948 
949  /* big-endian ordering; build up number */
950  while (n++ < size)
951  *num = ((uint64_t)*num << 8) | avio_r8(pb);
952  }
953 
954  return NEEDS_CHECKING;
955 }
956 
957 /*
958  * Read the next element as a float.
959  * Returns NEEDS_CHECKING or < 0 on obvious failure.
960  */
961 static int ebml_read_float(AVIOContext *pb, int size, double *num)
962 {
963  if (size == 0)
964  *num = 0;
965  else if (size == 4)
966  *num = av_int2float(avio_rb32(pb));
967  else if (size == 8)
968  *num = av_int2double(avio_rb64(pb));
969  else
970  return AVERROR_INVALIDDATA;
971 
972  return NEEDS_CHECKING;
973 }
974 
975 /*
976  * Read the next element as an ASCII string.
977  * 0 is success, < 0 or NEEDS_CHECKING is failure.
978  */
979 static int ebml_read_ascii(AVIOContext *pb, int size, char **str)
980 {
981  char *res;
982  int ret;
983 
984  /* EBML strings are usually not 0-terminated, so we allocate one
985  * byte more, read the string and NULL-terminate it ourselves. */
986  if (!(res = av_malloc(size + 1)))
987  return AVERROR(ENOMEM);
988  if ((ret = avio_read(pb, (uint8_t *) res, size)) != size) {
989  av_free(res);
990  return ret < 0 ? ret : NEEDS_CHECKING;
991  }
992  (res)[size] = '\0';
993  av_free(*str);
994  *str = res;
995 
996  return 0;
997 }
998 
999 /*
1000  * Read the next element as binary data.
1001  * 0 is success, < 0 or NEEDS_CHECKING is failure.
1002  */
1003 static int ebml_read_binary(AVIOContext *pb, int length,
1004  int64_t pos, EbmlBin *bin)
1005 {
1006  int ret;
1007 
1008  ret = av_buffer_realloc(&bin->buf, length + AV_INPUT_BUFFER_PADDING_SIZE);
1009  if (ret < 0)
1010  return ret;
1011  memset(bin->buf->data + length, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1012 
1013  bin->data = bin->buf->data;
1014  bin->size = length;
1015  bin->pos = pos;
1016  if ((ret = avio_read(pb, bin->data, length)) != length) {
1017  av_buffer_unref(&bin->buf);
1018  bin->data = NULL;
1019  bin->size = 0;
1020  return ret < 0 ? ret : NEEDS_CHECKING;
1021  }
1022 
1023  return 0;
1024 }
1025 
1026 /*
1027  * Read the next element, but only the header. The contents
1028  * are supposed to be sub-elements which can be read separately.
1029  * 0 is success, < 0 is failure.
1030  */
1032  uint64_t length, int64_t pos)
1033 {
1035 
1036  if (matroska->num_levels >= EBML_MAX_DEPTH) {
1037  av_log(matroska->ctx, AV_LOG_ERROR,
1038  "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
1039  return AVERROR(ENOSYS);
1040  }
1041 
1042  level = &matroska->levels[matroska->num_levels++];
1043  level->start = pos;
1044  level->length = length;
1045 
1046  return 0;
1047 }
1048 
1049 /*
1050  * Read a signed "EBML number"
1051  * Return: number of bytes processed, < 0 on error
1052  */
1054  AVIOContext *pb, int64_t *num)
1055 {
1056  uint64_t unum;
1057  int res;
1058 
1059  /* read as unsigned number first */
1060  if ((res = ebml_read_num(matroska, pb, 8, &unum, 1)) < 0)
1061  return res;
1062 
1063  /* make signed (weird way) */
1064  *num = unum - ((1LL << (7 * res - 1)) - 1);
1065 
1066  return res;
1067 }
1068 
1069 static int ebml_parse(MatroskaDemuxContext *matroska,
1070  EbmlSyntax *syntax, void *data);
1071 
1072 static EbmlSyntax *ebml_parse_id(EbmlSyntax *syntax, uint32_t id)
1073 {
1074  int i;
1075 
1076  // Whoever touches this should be aware of the duplication
1077  // existing in matroska_cluster_parsing.
1078  for (i = 0; syntax[i].id; i++)
1079  if (id == syntax[i].id)
1080  break;
1081 
1082  return &syntax[i];
1083 }
1084 
1085 static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
1086  void *data)
1087 {
1088  int res;
1089 
1090  if (data) {
1091  for (int i = 0; syntax[i].id; i++)
1092  switch (syntax[i].type) {
1093  case EBML_UINT:
1094  *(uint64_t *) ((char *) data + syntax[i].data_offset) = syntax[i].def.u;
1095  break;
1096  case EBML_SINT:
1097  *(int64_t *) ((char *) data + syntax[i].data_offset) = syntax[i].def.i;
1098  break;
1099  case EBML_FLOAT:
1100  *(double *) ((char *) data + syntax[i].data_offset) = syntax[i].def.f;
1101  break;
1102  case EBML_STR:
1103  case EBML_UTF8:
1104  // the default may be NULL
1105  if (syntax[i].def.s) {
1106  uint8_t **dst = (uint8_t **) ((uint8_t *) data + syntax[i].data_offset);
1107  *dst = av_strdup(syntax[i].def.s);
1108  if (!*dst)
1109  return AVERROR(ENOMEM);
1110  }
1111  break;
1112  }
1113 
1114  if (!matroska->levels[matroska->num_levels - 1].length) {
1115  matroska->num_levels--;
1116  return 0;
1117  }
1118  }
1119 
1120  do {
1121  res = ebml_parse(matroska, syntax, data);
1122  } while (!res);
1123 
1124  return res == LEVEL_ENDED ? 0 : res;
1125 }
1126 
1127 static int is_ebml_id_valid(uint32_t id)
1128 {
1129  // Due to endian nonsense in Matroska, the highest byte with any bits set
1130  // will contain the leading length bit. This bit in turn identifies the
1131  // total byte length of the element by its position within the byte.
1132  unsigned int bits = av_log2(id);
1133  return id && (bits + 7) / 8 == (8 - bits % 8);
1134 }
1135 
1136 /*
1137  * Allocate and return the entry for the level1 element with the given ID. If
1138  * an entry already exists, return the existing entry.
1139  */
1141  uint32_t id, int64_t pos)
1142 {
1143  int i;
1144  MatroskaLevel1Element *elem;
1145 
1146  if (!is_ebml_id_valid(id))
1147  return NULL;
1148 
1149  // Some files link to all clusters; useless.
1150  if (id == MATROSKA_ID_CLUSTER)
1151  return NULL;
1152 
1153  // There can be multiple SeekHeads and Tags.
1154  for (i = 0; i < matroska->num_level1_elems; i++) {
1155  if (matroska->level1_elems[i].id == id) {
1156  if (matroska->level1_elems[i].pos == pos ||
1157  id != MATROSKA_ID_SEEKHEAD && id != MATROSKA_ID_TAGS)
1158  return &matroska->level1_elems[i];
1159  }
1160  }
1161 
1162  // Only a completely broken file would have more elements.
1163  if (matroska->num_level1_elems >= FF_ARRAY_ELEMS(matroska->level1_elems)) {
1164  av_log(matroska->ctx, AV_LOG_ERROR, "Too many level1 elements.\n");
1165  return NULL;
1166  }
1167 
1168  elem = &matroska->level1_elems[matroska->num_level1_elems++];
1169  *elem = (MatroskaLevel1Element){.id = id};
1170 
1171  return elem;
1172 }
1173 
1174 static int ebml_parse(MatroskaDemuxContext *matroska,
1175  EbmlSyntax *syntax, void *data)
1176 {
1177  static const uint64_t max_lengths[EBML_TYPE_COUNT] = {
1178  // Forbid unknown-length EBML_NONE elements.
1180  [EBML_UINT] = 8,
1181  [EBML_SINT] = 8,
1182  [EBML_FLOAT] = 8,
1183  // max. 16 MB for strings
1184  [EBML_STR] = 0x1000000,
1185  [EBML_UTF8] = 0x1000000,
1186  // max. 256 MB for binary data
1187  [EBML_BIN] = 0x10000000,
1188  // no limits for anything else
1189  };
1190  AVIOContext *pb = matroska->ctx->pb;
1191  uint32_t id;
1192  uint64_t length;
1193  int64_t pos = avio_tell(pb), pos_alt;
1194  int res, update_pos = 1, level_check;
1195  MatroskaLevel1Element *level1_elem;
1196  MatroskaLevel *level = matroska->num_levels ? &matroska->levels[matroska->num_levels - 1] : NULL;
1197 
1198  if (!matroska->current_id) {
1199  uint64_t id;
1200  res = ebml_read_num(matroska, pb, 4, &id, 0);
1201  if (res < 0) {
1202  if (pb->eof_reached && res == AVERROR_EOF) {
1203  if (matroska->is_live)
1204  // in live mode, finish parsing if EOF is reached.
1205  return 1;
1206  if (level && pos == avio_tell(pb)) {
1207  if (level->length == EBML_UNKNOWN_LENGTH) {
1208  // Unknown-length levels automatically end at EOF.
1209  matroska->num_levels--;
1210  return LEVEL_ENDED;
1211  } else {
1212  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely "
1213  "at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
1214  }
1215  }
1216  }
1217  return res;
1218  }
1219  matroska->current_id = id | 1 << 7 * res;
1220  pos_alt = pos + res;
1221  } else {
1222  pos_alt = pos;
1223  pos -= (av_log2(matroska->current_id) + 7) / 8;
1224  }
1225 
1226  id = matroska->current_id;
1227 
1228  syntax = ebml_parse_id(syntax, id);
1229  if (!syntax->id && id != EBML_ID_VOID && id != EBML_ID_CRC32) {
1230  if (level && level->length == EBML_UNKNOWN_LENGTH) {
1231  // Unknown-length levels end when an element from an upper level
1232  // in the hierarchy is encountered.
1233  while (syntax->def.n) {
1234  syntax = ebml_parse_id(syntax->def.n, id);
1235  if (syntax->id) {
1236  matroska->num_levels--;
1237  return LEVEL_ENDED;
1238  }
1239  };
1240  }
1241 
1242  av_log(matroska->ctx, AV_LOG_DEBUG, "Unknown entry 0x%"PRIX32" at pos. "
1243  "%"PRId64"\n", id, pos);
1244  update_pos = 0; /* Don't update resync_pos as an error might have happened. */
1245  }
1246 
1247  if (data) {
1248  data = (char *) data + syntax->data_offset;
1249  if (syntax->list_elem_size) {
1250  EbmlList *list = data;
1251  void *newelem;
1252 
1253  if ((unsigned)list->nb_elem + 1 >= UINT_MAX / syntax->list_elem_size)
1254  return AVERROR(ENOMEM);
1255  newelem = av_fast_realloc(list->elem,
1256  &list->alloc_elem_size,
1257  (list->nb_elem + 1) * syntax->list_elem_size);
1258  if (!newelem)
1259  return AVERROR(ENOMEM);
1260  list->elem = newelem;
1261  data = (char *) list->elem + list->nb_elem * syntax->list_elem_size;
1262  memset(data, 0, syntax->list_elem_size);
1263  list->nb_elem++;
1264  }
1265  }
1266 
1267  if (syntax->type != EBML_STOP) {
1268  matroska->current_id = 0;
1269  if ((res = ebml_read_length(matroska, pb, &length)) < 0)
1270  return res;
1271 
1272  pos_alt += res;
1273 
1274  if (matroska->num_levels > 0) {
1275  if (length != EBML_UNKNOWN_LENGTH &&
1276  level->length != EBML_UNKNOWN_LENGTH) {
1277  uint64_t elem_end = pos_alt + length,
1278  level_end = level->start + level->length;
1279 
1280  if (elem_end < level_end) {
1281  level_check = 0;
1282  } else if (elem_end == level_end) {
1283  level_check = LEVEL_ENDED;
1284  } else {
1285  av_log(matroska->ctx, AV_LOG_ERROR,
1286  "Element at 0x%"PRIx64" ending at 0x%"PRIx64" exceeds "
1287  "containing master element ending at 0x%"PRIx64"\n",
1288  pos, elem_end, level_end);
1289  return AVERROR_INVALIDDATA;
1290  }
1291  } else if (length != EBML_UNKNOWN_LENGTH) {
1292  level_check = 0;
1293  } else if (level->length != EBML_UNKNOWN_LENGTH) {
1294  av_log(matroska->ctx, AV_LOG_ERROR, "Unknown-sized element "
1295  "at 0x%"PRIx64" inside parent with finite size\n", pos);
1296  return AVERROR_INVALIDDATA;
1297  } else {
1298  level_check = 0;
1299  if (id != MATROSKA_ID_CLUSTER && (syntax->type == EBML_LEVEL1
1300  || syntax->type == EBML_NEST)) {
1301  // According to the current specifications only clusters and
1302  // segments are allowed to be unknown-length. We also accept
1303  // other unknown-length master elements.
1304  av_log(matroska->ctx, AV_LOG_WARNING,
1305  "Found unknown-length element 0x%"PRIX32" other than "
1306  "a cluster at 0x%"PRIx64". Spec-incompliant, but "
1307  "parsing will nevertheless be attempted.\n", id, pos);
1308  update_pos = -1;
1309  }
1310  }
1311  } else
1312  level_check = 0;
1313 
1314  if (max_lengths[syntax->type] && length > max_lengths[syntax->type]) {
1315  if (length != EBML_UNKNOWN_LENGTH) {
1316  av_log(matroska->ctx, AV_LOG_ERROR,
1317  "Invalid length 0x%"PRIx64" > 0x%"PRIx64" for element "
1318  "with ID 0x%"PRIX32" at 0x%"PRIx64"\n",
1319  length, max_lengths[syntax->type], id, pos);
1320  } else if (syntax->type != EBML_NONE) {
1321  av_log(matroska->ctx, AV_LOG_ERROR,
1322  "Element with ID 0x%"PRIX32" at pos. 0x%"PRIx64" has "
1323  "unknown length, yet the length of an element of its "
1324  "type must be known.\n", id, pos);
1325  } else {
1326  av_log(matroska->ctx, AV_LOG_ERROR,
1327  "Found unknown-length element with ID 0x%"PRIX32" at "
1328  "pos. 0x%"PRIx64" for which no syntax for parsing is "
1329  "available.\n", id, pos);
1330  }
1331  return AVERROR_INVALIDDATA;
1332  }
1333 
1334  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1335  // Loosing sync will likely manifest itself as encountering unknown
1336  // elements which are not reliably distinguishable from elements
1337  // belonging to future extensions of the format.
1338  // We use a heuristic to detect such situations: If the current
1339  // element is not expected at the current syntax level and there
1340  // were only a few unknown elements in a row, then the element is
1341  // skipped or considered defective based upon the length of the
1342  // current element (i.e. how much would be skipped); if there were
1343  // more than a few skipped elements in a row and skipping the current
1344  // element would lead us more than SKIP_THRESHOLD away from the last
1345  // known good position, then it is inferred that an error occurred.
1346  // The dependency on the number of unknown elements in a row exists
1347  // because the distance to the last known good position is
1348  // automatically big if the last parsed element was big.
1349  // In both cases, each unknown element is considered equivalent to
1350  // UNKNOWN_EQUIV of skipped bytes for the check.
1351  // The whole check is only done for non-seekable output, because
1352  // in this situation skipped data can't simply be rechecked later.
1353  // This is especially important when using unkown length elements
1354  // as the check for whether a child exceeds its containing master
1355  // element is not effective in this situation.
1356  if (update_pos) {
1357  matroska->unknown_count = 0;
1358  } else {
1359  int64_t dist = length + UNKNOWN_EQUIV * matroska->unknown_count++;
1360 
1361  if (matroska->unknown_count > 3)
1362  dist += pos_alt - matroska->resync_pos;
1363 
1364  if (dist > SKIP_THRESHOLD) {
1365  av_log(matroska->ctx, AV_LOG_ERROR,
1366  "Unknown element %"PRIX32" at pos. 0x%"PRIx64" with "
1367  "length 0x%"PRIx64" considered as invalid data. Last "
1368  "known good position 0x%"PRIx64", %d unknown elements"
1369  " in a row\n", id, pos, length, matroska->resync_pos,
1370  matroska->unknown_count);
1371  return AVERROR_INVALIDDATA;
1372  }
1373  }
1374  }
1375 
1376  if (update_pos > 0) {
1377  // We have found an element that is allowed at this place
1378  // in the hierarchy and it passed all checks, so treat the beginning
1379  // of the element as the "last known good" position.
1380  matroska->resync_pos = pos;
1381  }
1382 
1383  if (!data && length != EBML_UNKNOWN_LENGTH)
1384  goto skip;
1385  }
1386 
1387  switch (syntax->type) {
1388  case EBML_UINT:
1389  res = ebml_read_uint(pb, length, data);
1390  break;
1391  case EBML_SINT:
1392  res = ebml_read_sint(pb, length, data);
1393  break;
1394  case EBML_FLOAT:
1395  res = ebml_read_float(pb, length, data);
1396  break;
1397  case EBML_STR:
1398  case EBML_UTF8:
1399  res = ebml_read_ascii(pb, length, data);
1400  break;
1401  case EBML_BIN:
1402  res = ebml_read_binary(pb, length, pos_alt, data);
1403  break;
1404  case EBML_LEVEL1:
1405  case EBML_NEST:
1406  if ((res = ebml_read_master(matroska, length, pos_alt)) < 0)
1407  return res;
1408  if (id == MATROSKA_ID_SEGMENT)
1409  matroska->segment_start = pos_alt;
1410  if (id == MATROSKA_ID_CUES)
1411  matroska->cues_parsing_deferred = 0;
1412  if (syntax->type == EBML_LEVEL1 &&
1413  (level1_elem = matroska_find_level1_elem(matroska, syntax->id, pos))) {
1414  if (!level1_elem->pos) {
1415  // Zero is not a valid position for a level 1 element.
1416  level1_elem->pos = pos;
1417  } else if (level1_elem->pos != pos)
1418  av_log(matroska->ctx, AV_LOG_ERROR, "Duplicate element\n");
1419  level1_elem->parsed = 1;
1420  }
1421  if (res = ebml_parse_nest(matroska, syntax->def.n, data))
1422  return res;
1423  break;
1424  case EBML_STOP:
1425  return 1;
1426  skip:
1427  default:
1428  if (length) {
1429  int64_t res2;
1430  if (ffio_limit(pb, length) != length) {
1431  // ffio_limit emits its own error message,
1432  // so we don't have to.
1433  return AVERROR(EIO);
1434  }
1435  if ((res2 = avio_skip(pb, length - 1)) >= 0) {
1436  // avio_skip might take us past EOF. We check for this
1437  // by skipping only length - 1 bytes, reading a byte and
1438  // checking the error flags. This is done in order to check
1439  // that the element has been properly skipped even when
1440  // no filesize (that ffio_limit relies on) is available.
1441  avio_r8(pb);
1442  res = NEEDS_CHECKING;
1443  } else
1444  res = res2;
1445  } else
1446  res = 0;
1447  }
1448  if (res) {
1449  if (res == NEEDS_CHECKING) {
1450  if (pb->eof_reached) {
1451  if (pb->error)
1452  res = pb->error;
1453  else
1454  res = AVERROR_EOF;
1455  } else
1456  goto level_check;
1457  }
1458 
1459  if (res == AVERROR_INVALIDDATA)
1460  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
1461  else if (res == AVERROR(EIO))
1462  av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
1463  else if (res == AVERROR_EOF) {
1464  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely\n");
1465  res = AVERROR(EIO);
1466  }
1467 
1468  return res;
1469  }
1470 
1471 level_check:
1472  if (level_check == LEVEL_ENDED && matroska->num_levels) {
1473  level = &matroska->levels[matroska->num_levels - 1];
1474  pos = avio_tell(pb);
1475 
1476  // Given that pos >= level->start no check for
1477  // level->length != EBML_UNKNOWN_LENGTH is necessary.
1478  while (matroska->num_levels && pos == level->start + level->length) {
1479  matroska->num_levels--;
1480  level--;
1481  }
1482  }
1483 
1484  return level_check;
1485 }
1486 
1487 static void ebml_free(EbmlSyntax *syntax, void *data)
1488 {
1489  int i, j;
1490  for (i = 0; syntax[i].id; i++) {
1491  void *data_off = (char *) data + syntax[i].data_offset;
1492  switch (syntax[i].type) {
1493  case EBML_STR:
1494  case EBML_UTF8:
1495  av_freep(data_off);
1496  break;
1497  case EBML_BIN:
1498  av_buffer_unref(&((EbmlBin *) data_off)->buf);
1499  break;
1500  case EBML_LEVEL1:
1501  case EBML_NEST:
1502  if (syntax[i].list_elem_size) {
1503  EbmlList *list = data_off;
1504  char *ptr = list->elem;
1505  for (j = 0; j < list->nb_elem;
1506  j++, ptr += syntax[i].list_elem_size)
1507  ebml_free(syntax[i].def.n, ptr);
1508  av_freep(&list->elem);
1509  list->nb_elem = 0;
1510  list->alloc_elem_size = 0;
1511  } else
1512  ebml_free(syntax[i].def.n, data_off);
1513  default:
1514  break;
1515  }
1516  }
1517 }
1518 
1519 /*
1520  * Autodetecting...
1521  */
1522 static int matroska_probe(const AVProbeData *p)
1523 {
1524  uint64_t total = 0;
1525  int len_mask = 0x80, size = 1, n = 1, i;
1526 
1527  /* EBML header? */
1528  if (AV_RB32(p->buf) != EBML_ID_HEADER)
1529  return 0;
1530 
1531  /* length of header */
1532  total = p->buf[4];
1533  while (size <= 8 && !(total & len_mask)) {
1534  size++;
1535  len_mask >>= 1;
1536  }
1537  if (size > 8)
1538  return 0;
1539  total &= (len_mask - 1);
1540  while (n < size)
1541  total = (total << 8) | p->buf[4 + n++];
1542 
1543  if (total + 1 == 1ULL << (7 * size)){
1544  /* Unknown-length header - simply parse the whole buffer. */
1545  total = p->buf_size - 4 - size;
1546  } else {
1547  /* Does the probe data contain the whole header? */
1548  if (p->buf_size < 4 + size + total)
1549  return 0;
1550  }
1551 
1552  /* The header should contain a known document type. For now,
1553  * we don't parse the whole header but simply check for the
1554  * availability of that array of characters inside the header.
1555  * Not fully fool-proof, but good enough. */
1556  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++) {
1557  size_t probelen = strlen(matroska_doctypes[i]);
1558  if (total < probelen)
1559  continue;
1560  for (n = 4 + size; n <= 4 + size + total - probelen; n++)
1561  if (!memcmp(p->buf + n, matroska_doctypes[i], probelen))
1562  return AVPROBE_SCORE_MAX;
1563  }
1564 
1565  // probably valid EBML header but no recognized doctype
1566  return AVPROBE_SCORE_EXTENSION;
1567 }
1568 
1570  uint64_t num)
1571 {
1572  MatroskaTrack *tracks = matroska->tracks.elem;
1573  int i;
1574 
1575  for (i = 0; i < matroska->tracks.nb_elem; i++)
1576  if (tracks[i].num == num)
1577  return &tracks[i];
1578 
1579  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %"PRIu64"\n", num);
1580  return NULL;
1581 }
1582 
1583 static int matroska_decode_buffer(uint8_t **buf, int *buf_size,
1584  MatroskaTrack *track)
1585 {
1586  MatroskaTrackEncoding *encodings = track->encodings.elem;
1587  uint8_t *data = *buf;
1588  int isize = *buf_size;
1589  uint8_t *pkt_data = NULL;
1590  uint8_t av_unused *newpktdata;
1591  int pkt_size = isize;
1592  int result = 0;
1593  int olen;
1594 
1595  if (pkt_size >= 10000000U)
1596  return AVERROR_INVALIDDATA;
1597 
1598  switch (encodings[0].compression.algo) {
1600  {
1601  int header_size = encodings[0].compression.settings.size;
1602  uint8_t *header = encodings[0].compression.settings.data;
1603 
1604  if (header_size && !header) {
1605  av_log(NULL, AV_LOG_ERROR, "Compression size but no data in headerstrip\n");
1606  return -1;
1607  }
1608 
1609  if (!header_size)
1610  return 0;
1611 
1612  pkt_size = isize + header_size;
1613  pkt_data = av_malloc(pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1614  if (!pkt_data)
1615  return AVERROR(ENOMEM);
1616 
1617  memcpy(pkt_data, header, header_size);
1618  memcpy(pkt_data + header_size, data, isize);
1619  break;
1620  }
1621 #if CONFIG_LZO
1623  do {
1624  int insize = isize;
1625  olen = pkt_size *= 3;
1626  newpktdata = av_realloc(pkt_data, pkt_size + AV_LZO_OUTPUT_PADDING
1628  if (!newpktdata) {
1629  result = AVERROR(ENOMEM);
1630  goto failed;
1631  }
1632  pkt_data = newpktdata;
1633  result = av_lzo1x_decode(pkt_data, &olen, data, &insize);
1634  } while (result == AV_LZO_OUTPUT_FULL && pkt_size < 10000000);
1635  if (result) {
1636  result = AVERROR_INVALIDDATA;
1637  goto failed;
1638  }
1639  pkt_size -= olen;
1640  break;
1641 #endif
1642 #if CONFIG_ZLIB
1644  {
1645  z_stream zstream = { 0 };
1646  if (!pkt_size || inflateInit(&zstream) != Z_OK)
1647  return -1;
1648  zstream.next_in = data;
1649  zstream.avail_in = isize;
1650  do {
1651  pkt_size *= 3;
1652  newpktdata = av_realloc(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1653  if (!newpktdata) {
1654  inflateEnd(&zstream);
1655  result = AVERROR(ENOMEM);
1656  goto failed;
1657  }
1658  pkt_data = newpktdata;
1659  zstream.avail_out = pkt_size - zstream.total_out;
1660  zstream.next_out = pkt_data + zstream.total_out;
1661  result = inflate(&zstream, Z_NO_FLUSH);
1662  } while (result == Z_OK && pkt_size < 10000000);
1663  pkt_size = zstream.total_out;
1664  inflateEnd(&zstream);
1665  if (result != Z_STREAM_END) {
1666  if (result == Z_MEM_ERROR)
1667  result = AVERROR(ENOMEM);
1668  else
1669  result = AVERROR_INVALIDDATA;
1670  goto failed;
1671  }
1672  break;
1673  }
1674 #endif
1675 #if CONFIG_BZLIB
1677  {
1678  bz_stream bzstream = { 0 };
1679  if (!pkt_size || BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
1680  return -1;
1681  bzstream.next_in = data;
1682  bzstream.avail_in = isize;
1683  do {
1684  pkt_size *= 3;
1685  newpktdata = av_realloc(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1686  if (!newpktdata) {
1687  BZ2_bzDecompressEnd(&bzstream);
1688  result = AVERROR(ENOMEM);
1689  goto failed;
1690  }
1691  pkt_data = newpktdata;
1692  bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
1693  bzstream.next_out = pkt_data + bzstream.total_out_lo32;
1694  result = BZ2_bzDecompress(&bzstream);
1695  } while (result == BZ_OK && pkt_size < 10000000);
1696  pkt_size = bzstream.total_out_lo32;
1697  BZ2_bzDecompressEnd(&bzstream);
1698  if (result != BZ_STREAM_END) {
1699  if (result == BZ_MEM_ERROR)
1700  result = AVERROR(ENOMEM);
1701  else
1702  result = AVERROR_INVALIDDATA;
1703  goto failed;
1704  }
1705  break;
1706  }
1707 #endif
1708  default:
1709  return AVERROR_INVALIDDATA;
1710  }
1711 
1712  memset(pkt_data + pkt_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1713 
1714  *buf = pkt_data;
1715  *buf_size = pkt_size;
1716  return 0;
1717 
1718 failed:
1719  av_free(pkt_data);
1720  return result;
1721 }
1722 
1724  AVDictionary **metadata, char *prefix)
1725 {
1726  MatroskaTag *tags = list->elem;
1727  char key[1024];
1728  int i;
1729 
1730  for (i = 0; i < list->nb_elem; i++) {
1731  const char *lang = tags[i].lang &&
1732  strcmp(tags[i].lang, "und") ? tags[i].lang : NULL;
1733 
1734  if (!tags[i].name) {
1735  av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no TagName.\n");
1736  continue;
1737  }
1738  if (prefix)
1739  snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
1740  else
1741  av_strlcpy(key, tags[i].name, sizeof(key));
1742  if (tags[i].def || !lang) {
1743  av_dict_set(metadata, key, tags[i].string, 0);
1744  if (tags[i].sub.nb_elem)
1745  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1746  }
1747  if (lang) {
1748  av_strlcat(key, "-", sizeof(key));
1749  av_strlcat(key, lang, sizeof(key));
1750  av_dict_set(metadata, key, tags[i].string, 0);
1751  if (tags[i].sub.nb_elem)
1752  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1753  }
1754  }
1756 }
1757 
1759 {
1760  MatroskaDemuxContext *matroska = s->priv_data;
1761  MatroskaTags *tags = matroska->tags.elem;
1762  int i, j;
1763 
1764  for (i = 0; i < matroska->tags.nb_elem; i++) {
1765  if (tags[i].target.attachuid) {
1766  MatroskaAttachment *attachment = matroska->attachments.elem;
1767  int found = 0;
1768  for (j = 0; j < matroska->attachments.nb_elem; j++) {
1769  if (attachment[j].uid == tags[i].target.attachuid &&
1770  attachment[j].stream) {
1771  matroska_convert_tag(s, &tags[i].tag,
1772  &attachment[j].stream->metadata, NULL);
1773  found = 1;
1774  }
1775  }
1776  if (!found) {
1778  "The tags at index %d refer to a "
1779  "non-existent attachment %"PRId64".\n",
1780  i, tags[i].target.attachuid);
1781  }
1782  } else if (tags[i].target.chapteruid) {
1783  MatroskaChapter *chapter = matroska->chapters.elem;
1784  int found = 0;
1785  for (j = 0; j < matroska->chapters.nb_elem; j++) {
1786  if (chapter[j].uid == tags[i].target.chapteruid &&
1787  chapter[j].chapter) {
1788  matroska_convert_tag(s, &tags[i].tag,
1789  &chapter[j].chapter->metadata, NULL);
1790  found = 1;
1791  }
1792  }
1793  if (!found) {
1795  "The tags at index %d refer to a non-existent chapter "
1796  "%"PRId64".\n",
1797  i, tags[i].target.chapteruid);
1798  }
1799  } else if (tags[i].target.trackuid) {
1800  MatroskaTrack *track = matroska->tracks.elem;
1801  int found = 0;
1802  for (j = 0; j < matroska->tracks.nb_elem; j++) {
1803  if (track[j].uid == tags[i].target.trackuid &&
1804  track[j].stream) {
1805  matroska_convert_tag(s, &tags[i].tag,
1806  &track[j].stream->metadata, NULL);
1807  found = 1;
1808  }
1809  }
1810  if (!found) {
1812  "The tags at index %d refer to a non-existent track "
1813  "%"PRId64".\n",
1814  i, tags[i].target.trackuid);
1815  }
1816  } else {
1817  matroska_convert_tag(s, &tags[i].tag, &s->metadata,
1818  tags[i].target.type);
1819  }
1820  }
1821 }
1822 
1824  int64_t pos)
1825 {
1826  uint32_t saved_id = matroska->current_id;
1827  int64_t before_pos = avio_tell(matroska->ctx->pb);
1828  int ret = 0;
1829  int ret2;
1830 
1831  /* seek */
1832  if (avio_seek(matroska->ctx->pb, pos, SEEK_SET) == pos) {
1833  /* We don't want to lose our seekhead level, so we add
1834  * a dummy. This is a crude hack. */
1835  if (matroska->num_levels == EBML_MAX_DEPTH) {
1836  av_log(matroska->ctx, AV_LOG_INFO,
1837  "Max EBML element depth (%d) reached, "
1838  "cannot parse further.\n", EBML_MAX_DEPTH);
1839  ret = AVERROR_INVALIDDATA;
1840  } else {
1841  matroska->levels[matroska->num_levels] = (MatroskaLevel) { 0, EBML_UNKNOWN_LENGTH };
1842  matroska->num_levels++;
1843  matroska->current_id = 0;
1844 
1845  ret = ebml_parse(matroska, matroska_segment, matroska);
1846  if (ret == LEVEL_ENDED) {
1847  /* This can only happen if the seek brought us beyond EOF. */
1848  ret = AVERROR_EOF;
1849  }
1850  }
1851  }
1852  /* Seek back - notice that in all instances where this is used
1853  * it is safe to set the level to 1. */
1854  ret2 = matroska_reset_status(matroska, saved_id, before_pos);
1855  if (ret >= 0)
1856  ret = ret2;
1857 
1858  return ret;
1859 }
1860 
1862 {
1863  EbmlList *seekhead_list = &matroska->seekhead;
1864  int i;
1865 
1866  // we should not do any seeking in the streaming case
1867  if (!(matroska->ctx->pb->seekable & AVIO_SEEKABLE_NORMAL))
1868  return;
1869 
1870  for (i = 0; i < seekhead_list->nb_elem; i++) {
1871  MatroskaSeekhead *seekheads = seekhead_list->elem;
1872  uint32_t id = seekheads[i].id;
1873  int64_t pos = seekheads[i].pos + matroska->segment_start;
1874  MatroskaLevel1Element *elem;
1875 
1876  if (id != seekheads[i].id || pos < matroska->segment_start)
1877  continue;
1878 
1879  elem = matroska_find_level1_elem(matroska, id, pos);
1880  if (!elem || elem->parsed)
1881  continue;
1882 
1883  elem->pos = pos;
1884 
1885  // defer cues parsing until we actually need cue data.
1886  if (id == MATROSKA_ID_CUES)
1887  continue;
1888 
1889  if (matroska_parse_seekhead_entry(matroska, pos) < 0) {
1890  // mark index as broken
1891  matroska->cues_parsing_deferred = -1;
1892  break;
1893  }
1894 
1895  elem->parsed = 1;
1896  }
1897 }
1898 
1900 {
1901  EbmlList *index_list;
1903  uint64_t index_scale = 1;
1904  int i, j;
1905 
1906  if (matroska->ctx->flags & AVFMT_FLAG_IGNIDX)
1907  return;
1908 
1909  index_list = &matroska->index;
1910  index = index_list->elem;
1911  if (index_list->nb_elem < 2)
1912  return;
1913  if (index[1].time > 1E14 / matroska->time_scale) {
1914  av_log(matroska->ctx, AV_LOG_WARNING, "Dropping apparently-broken index.\n");
1915  return;
1916  }
1917  for (i = 0; i < index_list->nb_elem; i++) {
1918  EbmlList *pos_list = &index[i].pos;
1919  MatroskaIndexPos *pos = pos_list->elem;
1920  for (j = 0; j < pos_list->nb_elem; j++) {
1921  MatroskaTrack *track = matroska_find_track_by_num(matroska,
1922  pos[j].track);
1923  if (track && track->stream)
1924  av_add_index_entry(track->stream,
1925  pos[j].pos + matroska->segment_start,
1926  index[i].time / index_scale, 0, 0,
1928  }
1929  }
1930 }
1931 
1933  int i;
1934 
1935  if (matroska->ctx->flags & AVFMT_FLAG_IGNIDX)
1936  return;
1937 
1938  for (i = 0; i < matroska->num_level1_elems; i++) {
1939  MatroskaLevel1Element *elem = &matroska->level1_elems[i];
1940  if (elem->id == MATROSKA_ID_CUES && !elem->parsed) {
1941  if (matroska_parse_seekhead_entry(matroska, elem->pos) < 0)
1942  matroska->cues_parsing_deferred = -1;
1943  elem->parsed = 1;
1944  break;
1945  }
1946  }
1947 
1948  matroska_add_index_entries(matroska);
1949 }
1950 
1952 {
1953  static const char *const aac_profiles[] = { "MAIN", "LC", "SSR" };
1954  int profile;
1955 
1956  for (profile = 0; profile < FF_ARRAY_ELEMS(aac_profiles); profile++)
1957  if (strstr(codec_id, aac_profiles[profile]))
1958  break;
1959  return profile + 1;
1960 }
1961 
1962 static int matroska_aac_sri(int samplerate)
1963 {
1964  int sri;
1965 
1966  for (sri = 0; sri < FF_ARRAY_ELEMS(avpriv_mpeg4audio_sample_rates); sri++)
1967  if (avpriv_mpeg4audio_sample_rates[sri] == samplerate)
1968  break;
1969  return sri;
1970 }
1971 
1972 static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
1973 {
1974  /* Convert to seconds and adjust by number of seconds between 2001-01-01 and Epoch */
1975  avpriv_dict_set_timestamp(metadata, "creation_time", date_utc / 1000 + 978307200000000LL);
1976 }
1977 
1979  MatroskaTrack *track,
1980  int *offset)
1981 {
1982  AVStream *st = track->stream;
1983  uint8_t *p = track->codec_priv.data;
1984  int size = track->codec_priv.size;
1985 
1986  if (size < 8 + FLAC_STREAMINFO_SIZE || p[4] & 0x7f) {
1987  av_log(s, AV_LOG_WARNING, "Invalid FLAC private data\n");
1988  track->codec_priv.size = 0;
1989  return 0;
1990  }
1991  *offset = 8;
1992  track->codec_priv.size = 8 + FLAC_STREAMINFO_SIZE;
1993 
1994  p += track->codec_priv.size;
1995  size -= track->codec_priv.size;
1996 
1997  /* parse the remaining metadata blocks if present */
1998  while (size >= 4) {
1999  int block_last, block_type, block_size;
2000 
2001  flac_parse_block_header(p, &block_last, &block_type, &block_size);
2002 
2003  p += 4;
2004  size -= 4;
2005  if (block_size > size)
2006  return 0;
2007 
2008  /* check for the channel mask */
2009  if (block_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
2010  AVDictionary *dict = NULL;
2011  AVDictionaryEntry *chmask;
2012 
2013  ff_vorbis_comment(s, &dict, p, block_size, 0);
2014  chmask = av_dict_get(dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);
2015  if (chmask) {
2016  uint64_t mask = strtol(chmask->value, NULL, 0);
2017  if (!mask || mask & ~0x3ffffULL) {
2019  "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
2020  } else
2021  st->codecpar->channel_layout = mask;
2022  }
2023  av_dict_free(&dict);
2024  }
2025 
2026  p += block_size;
2027  size -= block_size;
2028  }
2029 
2030  return 0;
2031 }
2032 
2033 static int mkv_field_order(MatroskaDemuxContext *matroska, int64_t field_order)
2034 {
2035  int major, minor, micro, bttb = 0;
2036 
2037  /* workaround a bug in our Matroska muxer, introduced in version 57.36 alongside
2038  * this function, and fixed in 57.52 */
2039  if (matroska->muxingapp && sscanf(matroska->muxingapp, "Lavf%d.%d.%d", &major, &minor, &micro) == 3)
2040  bttb = (major == 57 && minor >= 36 && minor <= 51 && micro >= 100);
2041 
2042  switch (field_order) {
2044  return AV_FIELD_PROGRESSIVE;
2046  return AV_FIELD_UNKNOWN;
2048  return AV_FIELD_TT;
2050  return AV_FIELD_BB;
2052  return bttb ? AV_FIELD_TB : AV_FIELD_BT;
2054  return bttb ? AV_FIELD_BT : AV_FIELD_TB;
2055  default:
2056  return AV_FIELD_UNKNOWN;
2057  }
2058 }
2059 
2060 static void mkv_stereo_mode_display_mul(int stereo_mode,
2061  int *h_width, int *h_height)
2062 {
2063  switch (stereo_mode) {
2069  break;
2074  *h_width = 2;
2075  break;
2080  *h_height = 2;
2081  break;
2082  }
2083 }
2084 
2085 static int mkv_parse_video_color(AVStream *st, const MatroskaTrack *track) {
2086  const MatroskaTrackVideoColor *color = track->video.color.elem;
2087  const MatroskaMasteringMeta *mastering_meta;
2088  int has_mastering_primaries, has_mastering_luminance;
2089 
2090  if (!track->video.color.nb_elem)
2091  return 0;
2092 
2093  mastering_meta = &color->mastering_meta;
2094  // Mastering primaries are CIE 1931 coords, and must be > 0.
2095  has_mastering_primaries =
2096  mastering_meta->r_x > 0 && mastering_meta->r_y > 0 &&
2097  mastering_meta->g_x > 0 && mastering_meta->g_y > 0 &&
2098  mastering_meta->b_x > 0 && mastering_meta->b_y > 0 &&
2099  mastering_meta->white_x > 0 && mastering_meta->white_y > 0;
2100  has_mastering_luminance = mastering_meta->max_luminance > 0;
2101 
2104  if (color->primaries != AVCOL_PRI_RESERVED &&
2105  color->primaries != AVCOL_PRI_RESERVED0)
2106  st->codecpar->color_primaries = color->primaries;
2110  if (color->range != AVCOL_RANGE_UNSPECIFIED &&
2111  color->range <= AVCOL_RANGE_JPEG)
2112  st->codecpar->color_range = color->range;
2117  st->codecpar->chroma_location =
2119  (color->chroma_siting_vert - 1) << 7);
2120  }
2121  if (color->max_cll && color->max_fall) {
2122  size_t size = 0;
2123  int ret;
2125  if (!metadata)
2126  return AVERROR(ENOMEM);
2128  (uint8_t *)metadata, size);
2129  if (ret < 0) {
2130  av_freep(&metadata);
2131  return ret;
2132  }
2133  metadata->MaxCLL = color->max_cll;
2134  metadata->MaxFALL = color->max_fall;
2135  }
2136 
2137  if (has_mastering_primaries || has_mastering_luminance) {
2138  AVMasteringDisplayMetadata *metadata =
2141  sizeof(AVMasteringDisplayMetadata));
2142  if (!metadata) {
2143  return AVERROR(ENOMEM);
2144  }
2145  memset(metadata, 0, sizeof(AVMasteringDisplayMetadata));
2146  if (has_mastering_primaries) {
2147  metadata->display_primaries[0][0] = av_d2q(mastering_meta->r_x, INT_MAX);
2148  metadata->display_primaries[0][1] = av_d2q(mastering_meta->r_y, INT_MAX);
2149  metadata->display_primaries[1][0] = av_d2q(mastering_meta->g_x, INT_MAX);
2150  metadata->display_primaries[1][1] = av_d2q(mastering_meta->g_y, INT_MAX);
2151  metadata->display_primaries[2][0] = av_d2q(mastering_meta->b_x, INT_MAX);
2152  metadata->display_primaries[2][1] = av_d2q(mastering_meta->b_y, INT_MAX);
2153  metadata->white_point[0] = av_d2q(mastering_meta->white_x, INT_MAX);
2154  metadata->white_point[1] = av_d2q(mastering_meta->white_y, INT_MAX);
2155  metadata->has_primaries = 1;
2156  }
2157  if (has_mastering_luminance) {
2158  metadata->max_luminance = av_d2q(mastering_meta->max_luminance, INT_MAX);
2159  metadata->min_luminance = av_d2q(mastering_meta->min_luminance, INT_MAX);
2160  metadata->has_luminance = 1;
2161  }
2162  }
2163  return 0;
2164 }
2165 
2167  void *logctx)
2168 {
2169  AVSphericalMapping *spherical;
2170  const MatroskaTrackVideoProjection *mkv_projection = &track->video.projection;
2171  const uint8_t *priv_data = mkv_projection->private.data;
2172  enum AVSphericalProjection projection;
2173  size_t spherical_size;
2174  uint32_t l = 0, t = 0, r = 0, b = 0;
2175  uint32_t padding = 0;
2176  int ret;
2177 
2178  if (mkv_projection->private.size && priv_data[0] != 0) {
2179  av_log(logctx, AV_LOG_WARNING, "Unknown spherical metadata\n");
2180  return 0;
2181  }
2182 
2183  switch (track->video.projection.type) {
2185  if (track->video.projection.private.size == 20) {
2186  t = AV_RB32(priv_data + 4);
2187  b = AV_RB32(priv_data + 8);
2188  l = AV_RB32(priv_data + 12);
2189  r = AV_RB32(priv_data + 16);
2190 
2191  if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
2192  av_log(logctx, AV_LOG_ERROR,
2193  "Invalid bounding rectangle coordinates "
2194  "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n",
2195  l, t, r, b);
2196  return AVERROR_INVALIDDATA;
2197  }
2198  } else if (track->video.projection.private.size != 0) {
2199  av_log(logctx, AV_LOG_ERROR, "Unknown spherical metadata\n");
2200  return AVERROR_INVALIDDATA;
2201  }
2202 
2203  if (l || t || r || b)
2204  projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
2205  else
2206  projection = AV_SPHERICAL_EQUIRECTANGULAR;
2207  break;
2209  if (track->video.projection.private.size < 4) {
2210  av_log(logctx, AV_LOG_ERROR, "Missing projection private properties\n");
2211  return AVERROR_INVALIDDATA;
2212  } else if (track->video.projection.private.size == 12) {
2213  uint32_t layout = AV_RB32(priv_data + 4);
2214  if (layout) {
2215  av_log(logctx, AV_LOG_WARNING,
2216  "Unknown spherical cubemap layout %"PRIu32"\n", layout);
2217  return 0;
2218  }
2219  projection = AV_SPHERICAL_CUBEMAP;
2220  padding = AV_RB32(priv_data + 8);
2221  } else {
2222  av_log(logctx, AV_LOG_ERROR, "Unknown spherical metadata\n");
2223  return AVERROR_INVALIDDATA;
2224  }
2225  break;
2227  /* No Spherical metadata */
2228  return 0;
2229  default:
2230  av_log(logctx, AV_LOG_WARNING,
2231  "Unknown spherical metadata type %"PRIu64"\n",
2232  track->video.projection.type);
2233  return 0;
2234  }
2235 
2236  spherical = av_spherical_alloc(&spherical_size);
2237  if (!spherical)
2238  return AVERROR(ENOMEM);
2239 
2240  spherical->projection = projection;
2241 
2242  spherical->yaw = (int32_t) (track->video.projection.yaw * (1 << 16));
2243  spherical->pitch = (int32_t) (track->video.projection.pitch * (1 << 16));
2244  spherical->roll = (int32_t) (track->video.projection.roll * (1 << 16));
2245 
2246  spherical->padding = padding;
2247 
2248  spherical->bound_left = l;
2249  spherical->bound_top = t;
2250  spherical->bound_right = r;
2251  spherical->bound_bottom = b;
2252 
2253  ret = av_stream_add_side_data(st, AV_PKT_DATA_SPHERICAL, (uint8_t *)spherical,
2254  spherical_size);
2255  if (ret < 0) {
2256  av_freep(&spherical);
2257  return ret;
2258  }
2259 
2260  return 0;
2261 }
2262 
2263 static int get_qt_codec(MatroskaTrack *track, uint32_t *fourcc, enum AVCodecID *codec_id)
2264 {
2265  const AVCodecTag *codec_tags;
2266 
2267  codec_tags = track->type == MATROSKA_TRACK_TYPE_VIDEO ?
2269 
2270  /* Normalize noncompliant private data that starts with the fourcc
2271  * by expanding/shifting the data by 4 bytes and storing the data
2272  * size at the start. */
2273  if (ff_codec_get_id(codec_tags, AV_RL32(track->codec_priv.data))) {
2274  int ret = av_buffer_realloc(&track->codec_priv.buf,
2276  if (ret < 0)
2277  return ret;
2278 
2279  track->codec_priv.data = track->codec_priv.buf->data;
2280  memmove(track->codec_priv.data + 4, track->codec_priv.data, track->codec_priv.size);
2281  track->codec_priv.size += 4;
2282  AV_WB32(track->codec_priv.data, track->codec_priv.size);
2283  }
2284 
2285  *fourcc = AV_RL32(track->codec_priv.data + 4);
2286  *codec_id = ff_codec_get_id(codec_tags, *fourcc);
2287 
2288  return 0;
2289 }
2290 
2292 {
2293  MatroskaDemuxContext *matroska = s->priv_data;
2294  MatroskaTrack *tracks = matroska->tracks.elem;
2295  AVStream *st;
2296  int i, j, ret;
2297  int k;
2298 
2299  for (i = 0; i < matroska->tracks.nb_elem; i++) {
2300  MatroskaTrack *track = &tracks[i];
2302  EbmlList *encodings_list = &track->encodings;
2303  MatroskaTrackEncoding *encodings = encodings_list->elem;
2304  uint8_t *extradata = NULL;
2305  int extradata_size = 0;
2306  int extradata_offset = 0;
2307  uint32_t fourcc = 0;
2308  AVIOContext b;
2309  char* key_id_base64 = NULL;
2310  int bit_depth = -1;
2311 
2312  /* Apply some sanity checks. */
2313  if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
2314  track->type != MATROSKA_TRACK_TYPE_AUDIO &&
2315  track->type != MATROSKA_TRACK_TYPE_SUBTITLE &&
2316  track->type != MATROSKA_TRACK_TYPE_METADATA) {
2317  av_log(matroska->ctx, AV_LOG_INFO,
2318  "Unknown or unsupported track type %"PRIu64"\n",
2319  track->type);
2320  continue;
2321  }
2322  if (!track->codec_id)
2323  continue;
2324 
2325  if ( track->type == MATROSKA_TRACK_TYPE_AUDIO && track->codec_id[0] != 'A'
2326  || track->type == MATROSKA_TRACK_TYPE_VIDEO && track->codec_id[0] != 'V'
2327  || track->type == MATROSKA_TRACK_TYPE_SUBTITLE && track->codec_id[0] != 'D' && track->codec_id[0] != 'S'
2328  || track->type == MATROSKA_TRACK_TYPE_METADATA && track->codec_id[0] != 'D' && track->codec_id[0] != 'S'
2329  ) {
2330  av_log(matroska->ctx, AV_LOG_INFO, "Inconsistent track type\n");
2331  continue;
2332  }
2333 
2334  if (track->audio.samplerate < 0 || track->audio.samplerate > INT_MAX ||
2335  isnan(track->audio.samplerate)) {
2336  av_log(matroska->ctx, AV_LOG_WARNING,
2337  "Invalid sample rate %f, defaulting to 8000 instead.\n",
2338  track->audio.samplerate);
2339  track->audio.samplerate = 8000;
2340  }
2341 
2342  if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2343  if (!track->default_duration && track->video.frame_rate > 0) {
2344  double default_duration = 1000000000 / track->video.frame_rate;
2345  if (default_duration > UINT64_MAX || default_duration < 0) {
2346  av_log(matroska->ctx, AV_LOG_WARNING,
2347  "Invalid frame rate %e. Cannot calculate default duration.\n",
2348  track->video.frame_rate);
2349  } else {
2350  track->default_duration = default_duration;
2351  }
2352  }
2353  if (track->video.display_width == -1)
2354  track->video.display_width = track->video.pixel_width;
2355  if (track->video.display_height == -1)
2356  track->video.display_height = track->video.pixel_height;
2357  if (track->video.color_space.size == 4)
2358  fourcc = AV_RL32(track->video.color_space.data);
2359  } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2360  if (!track->audio.out_samplerate)
2361  track->audio.out_samplerate = track->audio.samplerate;
2362  }
2363  if (encodings_list->nb_elem > 1) {
2364  av_log(matroska->ctx, AV_LOG_ERROR,
2365  "Multiple combined encodings not supported");
2366  } else if (encodings_list->nb_elem == 1) {
2367  if (encodings[0].type) {
2368  if (encodings[0].encryption.key_id.size > 0) {
2369  /* Save the encryption key id to be stored later as a
2370  metadata tag. */
2371  const int b64_size = AV_BASE64_SIZE(encodings[0].encryption.key_id.size);
2372  key_id_base64 = av_malloc(b64_size);
2373  if (key_id_base64 == NULL)
2374  return AVERROR(ENOMEM);
2375 
2376  av_base64_encode(key_id_base64, b64_size,
2377  encodings[0].encryption.key_id.data,
2378  encodings[0].encryption.key_id.size);
2379  } else {
2380  encodings[0].scope = 0;
2381  av_log(matroska->ctx, AV_LOG_ERROR,
2382  "Unsupported encoding type");
2383  }
2384  } else if (
2385 #if CONFIG_ZLIB
2386  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB &&
2387 #endif
2388 #if CONFIG_BZLIB
2390 #endif
2391 #if CONFIG_LZO
2393 #endif
2395  encodings[0].scope = 0;
2396  av_log(matroska->ctx, AV_LOG_ERROR,
2397  "Unsupported encoding type");
2398  } else if (track->codec_priv.size && encodings[0].scope & 2) {
2399  uint8_t *codec_priv = track->codec_priv.data;
2400  int ret = matroska_decode_buffer(&track->codec_priv.data,
2401  &track->codec_priv.size,
2402  track);
2403  if (ret < 0) {
2404  track->codec_priv.data = NULL;
2405  track->codec_priv.size = 0;
2406  av_log(matroska->ctx, AV_LOG_ERROR,
2407  "Failed to decode codec private data\n");
2408  }
2409 
2410  if (codec_priv != track->codec_priv.data) {
2411  av_buffer_unref(&track->codec_priv.buf);
2412  if (track->codec_priv.data) {
2413  track->codec_priv.buf = av_buffer_create(track->codec_priv.data,
2415  NULL, NULL, 0);
2416  if (!track->codec_priv.buf) {
2417  av_freep(&track->codec_priv.data);
2418  track->codec_priv.size = 0;
2419  return AVERROR(ENOMEM);
2420  }
2421  }
2422  }
2423  }
2424  }
2425  track->needs_decoding = encodings && !encodings[0].type &&
2426  encodings[0].scope & 1 &&
2427  (encodings[0].compression.algo !=
2429  encodings[0].compression.settings.size);
2430 
2431  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
2432  if (!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
2433  strlen(ff_mkv_codec_tags[j].str))) {
2434  codec_id = ff_mkv_codec_tags[j].id;
2435  break;
2436  }
2437  }
2438 
2439  st = track->stream = avformat_new_stream(s, NULL);
2440  if (!st) {
2441  av_free(key_id_base64);
2442  return AVERROR(ENOMEM);
2443  }
2444 
2445  if (key_id_base64) {
2446  /* export encryption key id as base64 metadata tag */
2447  av_dict_set(&st->metadata, "enc_key_id", key_id_base64,
2449  }
2450 
2451  if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC") &&
2452  track->codec_priv.size >= 40 &&
2453  track->codec_priv.data) {
2454  track->ms_compat = 1;
2455  bit_depth = AV_RL16(track->codec_priv.data + 14);
2456  fourcc = AV_RL32(track->codec_priv.data + 16);
2458  fourcc);
2459  if (!codec_id)
2461  fourcc);
2462  extradata_offset = 40;
2463  } else if (!strcmp(track->codec_id, "A_MS/ACM") &&
2464  track->codec_priv.size >= 14 &&
2465  track->codec_priv.data) {
2466  int ret;
2467  ffio_init_context(&b, track->codec_priv.data,
2468  track->codec_priv.size,
2469  0, NULL, NULL, NULL, NULL);
2470  ret = ff_get_wav_header(s, &b, st->codecpar, track->codec_priv.size, 0);
2471  if (ret < 0)
2472  return ret;
2473  codec_id = st->codecpar->codec_id;
2474  fourcc = st->codecpar->codec_tag;
2475  extradata_offset = FFMIN(track->codec_priv.size, 18);
2476  } else if (!strcmp(track->codec_id, "A_QUICKTIME")
2477  /* Normally 36, but allow noncompliant private data */
2478  && (track->codec_priv.size >= 32)
2479  && (track->codec_priv.data)) {
2480  uint16_t sample_size;
2481  int ret = get_qt_codec(track, &fourcc, &codec_id);
2482  if (ret < 0)
2483  return ret;
2484  sample_size = AV_RB16(track->codec_priv.data + 26);
2485  if (fourcc == 0) {
2486  if (sample_size == 8) {
2487  fourcc = MKTAG('r','a','w',' ');
2488  codec_id = ff_codec_get_id(ff_codec_movaudio_tags, fourcc);
2489  } else if (sample_size == 16) {
2490  fourcc = MKTAG('t','w','o','s');
2491  codec_id = ff_codec_get_id(ff_codec_movaudio_tags, fourcc);
2492  }
2493  }
2494  if ((fourcc == MKTAG('t','w','o','s') ||
2495  fourcc == MKTAG('s','o','w','t')) &&
2496  sample_size == 8)
2497  codec_id = AV_CODEC_ID_PCM_S8;
2498  } else if (!strcmp(track->codec_id, "V_QUICKTIME") &&
2499  (track->codec_priv.size >= 21) &&
2500  (track->codec_priv.data)) {
2501  int ret = get_qt_codec(track, &fourcc, &codec_id);
2502  if (ret < 0)
2503  return ret;
2504  if (codec_id == AV_CODEC_ID_NONE && AV_RL32(track->codec_priv.data+4) == AV_RL32("SMI ")) {
2505  fourcc = MKTAG('S','V','Q','3');
2506  codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
2507  }
2508  if (codec_id == AV_CODEC_ID_NONE)
2509  av_log(matroska->ctx, AV_LOG_ERROR,
2510  "mov FourCC not found %s.\n", av_fourcc2str(fourcc));
2511  if (track->codec_priv.size >= 86) {
2512  bit_depth = AV_RB16(track->codec_priv.data + 82);
2513  ffio_init_context(&b, track->codec_priv.data,
2514  track->codec_priv.size,
2515  0, NULL, NULL, NULL, NULL);
2516  if (ff_get_qtpalette(codec_id, &b, track->palette)) {
2517  bit_depth &= 0x1F;
2518  track->has_palette = 1;
2519  }
2520  }
2521  } else if (codec_id == AV_CODEC_ID_PCM_S16BE) {
2522  switch (track->audio.bitdepth) {
2523  case 8:
2524  codec_id = AV_CODEC_ID_PCM_U8;
2525  break;
2526  case 24:
2527  codec_id = AV_CODEC_ID_PCM_S24BE;
2528  break;
2529  case 32:
2530  codec_id = AV_CODEC_ID_PCM_S32BE;
2531  break;
2532  }
2533  } else if (codec_id == AV_CODEC_ID_PCM_S16LE) {
2534  switch (track->audio.bitdepth) {
2535  case 8:
2536  codec_id = AV_CODEC_ID_PCM_U8;
2537  break;
2538  case 24:
2539  codec_id = AV_CODEC_ID_PCM_S24LE;
2540  break;
2541  case 32:
2542  codec_id = AV_CODEC_ID_PCM_S32LE;
2543  break;
2544  }
2545  } else if (codec_id == AV_CODEC_ID_PCM_F32LE &&
2546  track->audio.bitdepth == 64) {
2547  codec_id = AV_CODEC_ID_PCM_F64LE;
2548  } else if (codec_id == AV_CODEC_ID_AAC && !track->codec_priv.size) {
2549  int profile = matroska_aac_profile(track->codec_id);
2550  int sri = matroska_aac_sri(track->audio.samplerate);
2551  extradata = av_mallocz(5 + AV_INPUT_BUFFER_PADDING_SIZE);
2552  if (!extradata)
2553  return AVERROR(ENOMEM);
2554  extradata[0] = (profile << 3) | ((sri & 0x0E) >> 1);
2555  extradata[1] = ((sri & 0x01) << 7) | (track->audio.channels << 3);
2556  if (strstr(track->codec_id, "SBR")) {
2557  sri = matroska_aac_sri(track->audio.out_samplerate);
2558  extradata[2] = 0x56;
2559  extradata[3] = 0xE5;
2560  extradata[4] = 0x80 | (sri << 3);
2561  extradata_size = 5;
2562  } else
2563  extradata_size = 2;
2564  } else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size && track->codec_priv.size < INT_MAX - 12 - AV_INPUT_BUFFER_PADDING_SIZE) {
2565  /* Only ALAC's magic cookie is stored in Matroska's track headers.
2566  * Create the "atom size", "tag", and "tag version" fields the
2567  * decoder expects manually. */
2568  extradata_size = 12 + track->codec_priv.size;
2569  extradata = av_mallocz(extradata_size +
2571  if (!extradata)
2572  return AVERROR(ENOMEM);
2573  AV_WB32(extradata, extradata_size);
2574  memcpy(&extradata[4], "alac", 4);
2575  AV_WB32(&extradata[8], 0);
2576  memcpy(&extradata[12], track->codec_priv.data,
2577  track->codec_priv.size);
2578  } else if (codec_id == AV_CODEC_ID_TTA) {
2579  uint8_t *ptr;
2580  if (track->audio.channels > UINT16_MAX ||
2581  track->audio.bitdepth > UINT16_MAX) {
2582  av_log(matroska->ctx, AV_LOG_WARNING,
2583  "Too large audio channel number %"PRIu64
2584  " or bitdepth %"PRIu64". Skipping track.\n",
2585  track->audio.channels, track->audio.bitdepth);
2586  if (matroska->ctx->error_recognition & AV_EF_EXPLODE)
2587  return AVERROR_INVALIDDATA;
2588  else
2589  continue;
2590  }
2591  if (track->audio.out_samplerate < 0 || track->audio.out_samplerate > INT_MAX)
2592  return AVERROR_INVALIDDATA;
2593  extradata_size = 22;
2594  extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
2595  if (!extradata)
2596  return AVERROR(ENOMEM);
2597  ptr = extradata;
2598  bytestream_put_be32(&ptr, AV_RB32("TTA1"));
2599  bytestream_put_le16(&ptr, 1);
2600  bytestream_put_le16(&ptr, track->audio.channels);
2601  bytestream_put_le16(&ptr, track->audio.bitdepth);
2602  bytestream_put_le32(&ptr, track->audio.out_samplerate);
2603  bytestream_put_le32(&ptr, av_rescale(matroska->duration * matroska->time_scale,
2604  track->audio.out_samplerate,
2605  AV_TIME_BASE * 1000));
2606  } else if (codec_id == AV_CODEC_ID_RV10 ||
2607  codec_id == AV_CODEC_ID_RV20 ||
2608  codec_id == AV_CODEC_ID_RV30 ||
2609  codec_id == AV_CODEC_ID_RV40) {
2610  extradata_offset = 26;
2611  } else if (codec_id == AV_CODEC_ID_RA_144) {
2612  track->audio.out_samplerate = 8000;
2613  track->audio.channels = 1;
2614  } else if ((codec_id == AV_CODEC_ID_RA_288 ||
2615  codec_id == AV_CODEC_ID_COOK ||
2616  codec_id == AV_CODEC_ID_ATRAC3 ||
2617  codec_id == AV_CODEC_ID_SIPR)
2618  && track->codec_priv.data) {
2619  int flavor;
2620 
2621  ffio_init_context(&b, track->codec_priv.data,
2622  track->codec_priv.size,
2623  0, NULL, NULL, NULL, NULL);
2624  avio_skip(&b, 22);
2625  flavor = avio_rb16(&b);
2626  track->audio.coded_framesize = avio_rb32(&b);
2627  avio_skip(&b, 12);
2628  track->audio.sub_packet_h = avio_rb16(&b);
2629  track->audio.frame_size = avio_rb16(&b);
2630  track->audio.sub_packet_size = avio_rb16(&b);
2631  if (track->audio.coded_framesize <= 0 ||
2632  track->audio.sub_packet_h <= 0 ||
2633  track->audio.frame_size <= 0)
2634  return AVERROR_INVALIDDATA;
2635 
2636  if (codec_id == AV_CODEC_ID_RA_288) {
2637  if (track->audio.sub_packet_h & 1 || 2 * track->audio.frame_size
2638  != (int64_t)track->audio.sub_packet_h * track->audio.coded_framesize)
2639  return AVERROR_INVALIDDATA;
2640  st->codecpar->block_align = track->audio.coded_framesize;
2641  track->codec_priv.size = 0;
2642  } else {
2643  if (codec_id == AV_CODEC_ID_SIPR) {
2644  static const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
2645  if (flavor > 3)
2646  return AVERROR_INVALIDDATA;
2647  track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
2648  st->codecpar->bit_rate = sipr_bit_rate[flavor];
2649  } else if (track->audio.sub_packet_size <= 0 ||
2650  track->audio.frame_size % track->audio.sub_packet_size)
2651  return AVERROR_INVALIDDATA;
2652  st->codecpar->block_align = track->audio.sub_packet_size;
2653  extradata_offset = 78;
2654  }
2655  track->audio.buf = av_malloc_array(track->audio.sub_packet_h,
2656  track->audio.frame_size);
2657  if (!track->audio.buf)
2658  return AVERROR(ENOMEM);
2659  } else if (codec_id == AV_CODEC_ID_FLAC && track->codec_priv.size) {
2660  ret = matroska_parse_flac(s, track, &extradata_offset);
2661  if (ret < 0)
2662  return ret;
2663  } else if (codec_id == AV_CODEC_ID_WAVPACK && track->codec_priv.size < 2) {
2664  av_log(matroska->ctx, AV_LOG_INFO, "Assuming WavPack version 4.10 "
2665  "in absence of valid CodecPrivate.\n");
2666  extradata_size = 2;
2667  extradata = av_mallocz(2 + AV_INPUT_BUFFER_PADDING_SIZE);
2668  if (!extradata)
2669  return AVERROR(ENOMEM);
2670  AV_WL16(extradata, 0x410);
2671  } else if (codec_id == AV_CODEC_ID_PRORES && track->codec_priv.size == 4) {
2672  fourcc = AV_RL32(track->codec_priv.data);
2673  } else if (codec_id == AV_CODEC_ID_VP9 && track->codec_priv.size) {
2674  /* we don't need any value stored in CodecPrivate.
2675  make sure that it's not exported as extradata. */
2676  track->codec_priv.size = 0;
2677  } else if (codec_id == AV_CODEC_ID_AV1 && track->codec_priv.size) {
2678  /* For now, propagate only the OBUs, if any. Once libavcodec is
2679  updated to handle isobmff style extradata this can be removed. */
2680  extradata_offset = 4;
2681  }
2682  track->codec_priv.size -= extradata_offset;
2683 
2684  if (codec_id == AV_CODEC_ID_NONE)
2685  av_log(matroska->ctx, AV_LOG_INFO,
2686  "Unknown/unsupported AVCodecID %s.\n", track->codec_id);
2687 
2688  if (track->time_scale < 0.01)
2689  track->time_scale = 1.0;
2690 
2691  if (matroska->time_scale * track->time_scale > UINT_MAX)
2692  return AVERROR_INVALIDDATA;
2693 
2694  avpriv_set_pts_info(st, 64, matroska->time_scale * track->time_scale,
2695  1000 * 1000 * 1000); /* 64 bit pts in ns */
2696 
2697  /* convert the delay from ns to the track timebase */
2699  (AVRational){ 1, 1000000000 },
2700  st->time_base);
2701 
2702  st->codecpar->codec_id = codec_id;
2703 
2704  if (strcmp(track->language, "und"))
2705  av_dict_set(&st->metadata, "language", track->language, 0);
2706  av_dict_set(&st->metadata, "title", track->name, 0);
2707 
2708  if (track->flag_default)
2710  if (track->flag_forced)
2712 
2713  if (!st->codecpar->extradata) {
2714  if (extradata) {
2715  st->codecpar->extradata = extradata;
2716  st->codecpar->extradata_size = extradata_size;
2717  } else if (track->codec_priv.data && track->codec_priv.size > 0) {
2718  if (ff_alloc_extradata(st->codecpar, track->codec_priv.size))
2719  return AVERROR(ENOMEM);
2720  memcpy(st->codecpar->extradata,
2721  track->codec_priv.data + extradata_offset,
2722  track->codec_priv.size);
2723  }
2724  }
2725 
2726  if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
2728  int display_width_mul = 1;
2729  int display_height_mul = 1;
2730 
2732  st->codecpar->codec_tag = fourcc;
2733  if (bit_depth >= 0)
2735  st->codecpar->width = track->video.pixel_width;
2736  st->codecpar->height = track->video.pixel_height;
2737 
2739  st->codecpar->field_order = mkv_field_order(matroska, track->video.field_order);
2742 
2744  mkv_stereo_mode_display_mul(track->video.stereo_mode, &display_width_mul, &display_height_mul);
2745 
2748  &st->sample_aspect_ratio.den,
2749  st->codecpar->height * track->video.display_width * display_width_mul,
2750  st->codecpar->width * track->video.display_height * display_height_mul,
2751  255);
2752  }
2753  if (st->codecpar->codec_id != AV_CODEC_ID_HEVC)
2755 
2756  if (track->default_duration) {
2757  int div = track->default_duration <= INT64_MAX ? 1 : 2;
2759  1000000000 / div, track->default_duration / div, 30000);
2760 #if FF_API_R_FRAME_RATE
2761  if ( st->avg_frame_rate.num < st->avg_frame_rate.den * 1000LL
2762  && st->avg_frame_rate.num > st->avg_frame_rate.den * 5LL)
2763  st->r_frame_rate = st->avg_frame_rate;
2764 #endif
2765  }
2766 
2767  /* export stereo mode flag as metadata tag */
2769  av_dict_set(&st->metadata, "stereo_mode", ff_matroska_video_stereo_mode[track->video.stereo_mode], 0);
2770 
2771  /* export alpha mode flag as metadata tag */
2772  if (track->video.alpha_mode)
2773  av_dict_set(&st->metadata, "alpha_mode", "1", 0);
2774 
2775  /* if we have virtual track, mark the real tracks */
2776  for (j=0; j < track->operation.combine_planes.nb_elem; j++) {
2777  char buf[32];
2778  if (planes[j].type >= MATROSKA_VIDEO_STEREO_PLANE_COUNT)
2779  continue;
2780  snprintf(buf, sizeof(buf), "%s_%d",
2781  ff_matroska_video_stereo_plane[planes[j].type], i);
2782  for (k=0; k < matroska->tracks.nb_elem; k++)
2783  if (planes[j].uid == tracks[k].uid && tracks[k].stream) {
2784  av_dict_set(&tracks[k].stream->metadata,
2785  "stereo_mode", buf, 0);
2786  break;
2787  }
2788  }
2789  // add stream level stereo3d side data if it is a supported format
2791  track->video.stereo_mode != 10 && track->video.stereo_mode != 12) {
2792  int ret = ff_mkv_stereo3d_conv(st, track->video.stereo_mode);
2793  if (ret < 0)
2794  return ret;
2795  }
2796 
2797  ret = mkv_parse_video_color(st, track);
2798  if (ret < 0)
2799  return ret;
2800  ret = mkv_parse_video_projection(st, track, matroska->ctx);
2801  if (ret < 0)
2802  return ret;
2803  } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
2805  st->codecpar->codec_tag = fourcc;
2806  st->codecpar->sample_rate = track->audio.out_samplerate;
2807  st->codecpar->channels = track->audio.channels;
2808  if (!st->codecpar->bits_per_coded_sample)
2810  if (st->codecpar->codec_id == AV_CODEC_ID_MP3 ||
2811  st->codecpar->codec_id == AV_CODEC_ID_MLP ||
2814  else if (st->codecpar->codec_id != AV_CODEC_ID_AAC)
2816  if (track->codec_delay > 0) {
2818  (AVRational){1, 1000000000},
2819  (AVRational){1, st->codecpar->codec_id == AV_CODEC_ID_OPUS ?
2820  48000 : st->codecpar->sample_rate});
2821  }
2822  if (track->seek_preroll > 0) {
2824  (AVRational){1, 1000000000},
2825  (AVRational){1, st->codecpar->sample_rate});
2826  }
2827  } else if (codec_id == AV_CODEC_ID_WEBVTT) {
2829 
2830  if (!strcmp(track->codec_id, "D_WEBVTT/CAPTIONS")) {
2832  } else if (!strcmp(track->codec_id, "D_WEBVTT/DESCRIPTIONS")) {
2834  } else if (!strcmp(track->codec_id, "D_WEBVTT/METADATA")) {
2836  }
2837  } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
2839  }
2840  }
2841 
2842  return 0;
2843 }
2844 
2846 {
2847  MatroskaDemuxContext *matroska = s->priv_data;
2848  EbmlList *attachments_list = &matroska->attachments;
2849  EbmlList *chapters_list = &matroska->chapters;
2850  MatroskaAttachment *attachments;
2851  MatroskaChapter *chapters;
2852  uint64_t max_start = 0;
2853  int64_t pos;
2854  Ebml ebml = { 0 };
2855  int i, j, res;
2856 
2857  matroska->ctx = s;
2858  matroska->cues_parsing_deferred = 1;
2859 
2860  /* First read the EBML header. */
2861  if (ebml_parse(matroska, ebml_syntax, &ebml) || !ebml.doctype) {
2862  av_log(matroska->ctx, AV_LOG_ERROR, "EBML header parsing failed\n");
2863  ebml_free(ebml_syntax, &ebml);
2864  return AVERROR_INVALIDDATA;
2865  }
2866  if (ebml.version > EBML_VERSION ||
2867  ebml.max_size > sizeof(uint64_t) ||
2868  ebml.id_length > sizeof(uint32_t) ||
2869  ebml.doctype_version > 3) {
2871  "EBML version %"PRIu64", doctype %s, doc version %"PRIu64,
2872  ebml.version, ebml.doctype, ebml.doctype_version);
2873  ebml_free(ebml_syntax, &ebml);
2874  return AVERROR_PATCHWELCOME;
2875  } else if (ebml.doctype_version == 3) {
2876  av_log(matroska->ctx, AV_LOG_WARNING,
2877  "EBML header using unsupported features\n"
2878  "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
2879  ebml.version, ebml.doctype, ebml.doctype_version);
2880  }
2881  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++)
2882  if (!strcmp(ebml.doctype, matroska_doctypes[i]))
2883  break;
2884  if (i >= FF_ARRAY_ELEMS(matroska_doctypes)) {
2885  av_log(s, AV_LOG_WARNING, "Unknown EBML doctype '%s'\n", ebml.doctype);
2886  if (matroska->ctx->error_recognition & AV_EF_EXPLODE) {
2887  ebml_free(ebml_syntax, &ebml);
2888  return AVERROR_INVALIDDATA;
2889  }
2890  }
2891  ebml_free(ebml_syntax, &ebml);
2892 
2893  /* The next thing is a segment. */
2894  pos = avio_tell(matroska->ctx->pb);
2895  res = ebml_parse(matroska, matroska_segments, matroska);
2896  // Try resyncing until we find an EBML_STOP type element.
2897  while (res != 1) {
2898  res = matroska_resync(matroska, pos);
2899  if (res < 0)
2900  goto fail;
2901  pos = avio_tell(matroska->ctx->pb);
2902  res = ebml_parse(matroska, matroska_segment, matroska);
2903  if (res == AVERROR(EIO)) // EOF is translated to EIO, this exists the loop on EOF
2904  goto fail;
2905  }
2906  /* Set data_offset as it might be needed later by seek_frame_generic. */
2907  if (matroska->current_id == MATROSKA_ID_CLUSTER)
2908  s->internal->data_offset = avio_tell(matroska->ctx->pb) - 4;
2909  matroska_execute_seekhead(matroska);
2910 
2911  if (!matroska->time_scale)
2912  matroska->time_scale = 1000000;
2913  if (isnan(matroska->duration))
2914  matroska->duration = 0;
2915  if (matroska->duration)
2916  matroska->ctx->duration = matroska->duration * matroska->time_scale *
2917  1000 / AV_TIME_BASE;
2918  av_dict_set(&s->metadata, "title", matroska->title, 0);
2919  av_dict_set(&s->metadata, "encoder", matroska->muxingapp, 0);
2920 
2921  if (matroska->date_utc.size == 8)
2923 
2924  res = matroska_parse_tracks(s);
2925  if (res < 0)
2926  goto fail;
2927 
2928  attachments = attachments_list->elem;
2929  for (j = 0; j < attachments_list->nb_elem; j++) {
2930  if (!(attachments[j].filename && attachments[j].mime &&
2931  attachments[j].bin.data && attachments[j].bin.size > 0)) {
2932  av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
2933  } else {
2934  AVStream *st = avformat_new_stream(s, NULL);
2935  if (!st)
2936  break;
2937  av_dict_set(&st->metadata, "filename", attachments[j].filename, 0);
2938  av_dict_set(&st->metadata, "mimetype", attachments[j].mime, 0);
2939  if (attachments[j].description)
2940  av_dict_set(&st->metadata, "title", attachments[j].description, 0);
2942 
2943  for (i = 0; mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
2944  if (!strncmp(mkv_image_mime_tags[i].str, attachments[j].mime,
2945  strlen(mkv_image_mime_tags[i].str))) {
2946  st->codecpar->codec_id = mkv_image_mime_tags[i].id;
2947  break;
2948  }
2949  }
2950 
2951  attachments[j].stream = st;
2952 
2953  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
2954  AVPacket *pkt = &st->attached_pic;
2955 
2958 
2959  av_init_packet(pkt);
2960  pkt->buf = attachments[j].bin.buf;
2961  attachments[j].bin.buf = NULL;
2962  pkt->data = attachments[j].bin.data;
2963  pkt->size = attachments[j].bin.size;
2964  pkt->stream_index = st->index;
2965  pkt->flags |= AV_PKT_FLAG_KEY;
2966  } else {
2968  if (ff_alloc_extradata(st->codecpar, attachments[j].bin.size))
2969  break;
2970  memcpy(st->codecpar->extradata, attachments[j].bin.data,
2971  attachments[j].bin.size);
2972 
2973  for (i = 0; mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
2974  if (!strncmp(mkv_mime_tags[i].str, attachments[j].mime,
2975  strlen(mkv_mime_tags[i].str))) {
2976  st->codecpar->codec_id = mkv_mime_tags[i].id;
2977  break;
2978  }
2979  }
2980  }
2981  }
2982  }
2983 
2984  chapters = chapters_list->elem;
2985  for (i = 0; i < chapters_list->nb_elem; i++)
2986  if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid &&
2987  (max_start == 0 || chapters[i].start > max_start)) {
2988  chapters[i].chapter =
2989  avpriv_new_chapter(s, chapters[i].uid,
2990  (AVRational) { 1, 1000000000 },
2991  chapters[i].start, chapters[i].end,
2992  chapters[i].title);
2993  max_start = chapters[i].start;
2994  }
2995 
2996  matroska_add_index_entries(matroska);
2997 
2999 
3000  return 0;
3001 fail:
3003  return res;
3004 }
3005 
3006 /*
3007  * Put one packet in an application-supplied AVPacket struct.
3008  * Returns 0 on success or -1 on failure.
3009  */
3011  AVPacket *pkt)
3012 {
3013  if (matroska->queue) {
3014  MatroskaTrack *tracks = matroska->tracks.elem;
3015  MatroskaTrack *track;
3016 
3017  ff_packet_list_get(&matroska->queue, &matroska->queue_end, pkt);
3018  track = &tracks[pkt->stream_index];
3019  if (track->has_palette) {
3021  if (!pal) {
3022  av_log(matroska->ctx, AV_LOG_ERROR, "Cannot append palette to packet\n");
3023  } else {
3024  memcpy(pal, track->palette, AVPALETTE_SIZE);
3025  }
3026  track->has_palette = 0;
3027  }
3028  return 0;
3029  }
3030 
3031  return -1;
3032 }
3033 
3034 /*
3035  * Free all packets in our internal queue.
3036  */
3038 {
3039  ff_packet_list_free(&matroska->queue, &matroska->queue_end);
3040 }
3041 
3043  int size, int type, AVIOContext *pb,
3044  uint32_t lace_size[256], int *laces)
3045 {
3046  int n;
3047  uint8_t *data = *buf;
3048 
3049  if (!type) {
3050  *laces = 1;
3051  lace_size[0] = size;
3052  return 0;
3053  }
3054 
3055  if (size <= 0)
3056  return AVERROR_INVALIDDATA;
3057 
3058  *laces = *data + 1;
3059  data += 1;
3060  size -= 1;
3061 
3062  switch (type) {
3063  case 0x1: /* Xiph lacing */
3064  {
3065  uint8_t temp;
3066  uint32_t total = 0;
3067  for (n = 0; n < *laces - 1; n++) {
3068  lace_size[n] = 0;
3069 
3070  do {
3071  if (size <= total)
3072  return AVERROR_INVALIDDATA;
3073  temp = *data;
3074  total += temp;
3075  lace_size[n] += temp;
3076  data += 1;
3077  size -= 1;
3078  } while (temp == 0xff);
3079  }
3080  if (size < total)
3081  return AVERROR_INVALIDDATA;
3082 
3083  lace_size[n] = size - total;
3084  break;
3085  }
3086 
3087  case 0x2: /* fixed-size lacing */
3088  if (size % (*laces))
3089  return AVERROR_INVALIDDATA;
3090  for (n = 0; n < *laces; n++)
3091  lace_size[n] = size / *laces;
3092  break;
3093 
3094  case 0x3: /* EBML lacing */
3095  {
3096  uint64_t num;
3097  uint64_t total;
3098  int offset;
3099 
3100  avio_skip(pb, 4);
3101 
3102  n = ebml_read_num(matroska, pb, 8, &num, 1);
3103  if (n < 0)
3104  return n;
3105  if (num > INT_MAX)
3106  return AVERROR_INVALIDDATA;
3107 
3108  total = lace_size[0] = num;
3109  offset = n;
3110  for (n = 1; n < *laces - 1; n++) {
3111  int64_t snum;
3112  int r;
3113  r = matroska_ebmlnum_sint(matroska, pb, &snum);
3114  if (r < 0)
3115  return r;
3116  if (lace_size[n - 1] + snum > (uint64_t)INT_MAX)
3117  return AVERROR_INVALIDDATA;
3118 
3119  lace_size[n] = lace_size[n - 1] + snum;
3120  total += lace_size[n];
3121  offset += r;
3122  }
3123  data += offset;
3124  size -= offset;
3125  if (size < total)
3126  return AVERROR_INVALIDDATA;
3127 
3128  lace_size[*laces - 1] = size - total;
3129  break;
3130  }
3131  }
3132 
3133  *buf = data;
3134 
3135  return 0;
3136 }
3137 
3139  MatroskaTrack *track, AVStream *st,
3140  uint8_t *data, int size, uint64_t timecode,
3141  int64_t pos)
3142 {
3143  const int a = st->codecpar->block_align;
3144  const int sps = track->audio.sub_packet_size;
3145  const int cfs = track->audio.coded_framesize;
3146  const int h = track->audio.sub_packet_h;
3147  const int w = track->audio.frame_size;
3148  int y = track->audio.sub_packet_cnt;
3149  int x;
3150 
3151  if (!track->audio.pkt_cnt) {
3152  if (track->audio.sub_packet_cnt == 0)
3153  track->audio.buf_timecode = timecode;
3154  if (st->codecpar->codec_id == AV_CODEC_ID_RA_288) {
3155  if (size < cfs * h / 2) {
3156  av_log(matroska->ctx, AV_LOG_ERROR,
3157  "Corrupt int4 RM-style audio packet size\n");
3158  return AVERROR_INVALIDDATA;
3159  }
3160  for (x = 0; x < h / 2; x++)
3161  memcpy(track->audio.buf + x * 2 * w + y * cfs,
3162  data + x * cfs, cfs);
3163  } else if (st->codecpar->codec_id == AV_CODEC_ID_SIPR) {
3164  if (size < w) {
3165  av_log(matroska->ctx, AV_LOG_ERROR,
3166  "Corrupt sipr RM-style audio packet size\n");
3167  return AVERROR_INVALIDDATA;
3168  }
3169  memcpy(track->audio.buf + y * w, data, w);
3170  } else {
3171  if (size < w) {
3172  av_log(matroska->ctx, AV_LOG_ERROR,
3173  "Corrupt generic RM-style audio packet size\n");
3174  return AVERROR_INVALIDDATA;
3175  }
3176  for (x = 0; x < w / sps; x++)
3177  memcpy(track->audio.buf +
3178  sps * (h * x + ((h + 1) / 2) * (y & 1) + (y >> 1)),
3179  data + x * sps, sps);
3180  }
3181 
3182  if (++track->audio.sub_packet_cnt >= h) {
3183  if (st->codecpar->codec_id == AV_CODEC_ID_SIPR)
3184  ff_rm_reorder_sipr_data(track->audio.buf, h, w);
3185  track->audio.sub_packet_cnt = 0;
3186  track->audio.pkt_cnt = h * w / a;
3187  }
3188  }
3189 
3190  while (track->audio.pkt_cnt) {
3191  int ret;
3192  AVPacket pktl, *pkt = &pktl;
3193 
3194  ret = av_new_packet(pkt, a);
3195  if (ret < 0) {
3196  return ret;
3197  }
3198  memcpy(pkt->data,
3199  track->audio.buf + a * (h * w / a - track->audio.pkt_cnt--),
3200  a);
3201  pkt->pts = track->audio.buf_timecode;
3203  pkt->pos = pos;
3204  pkt->stream_index = st->index;
3205  ret = ff_packet_list_put(&matroska->queue, &matroska->queue_end, pkt, 0);
3206  if (ret < 0) {
3207  av_packet_unref(pkt);
3208  return AVERROR(ENOMEM);
3209  }
3210  }
3211 
3212  return 0;
3213 }
3214 
3215 /* reconstruct full wavpack blocks from mangled matroska ones */
3217  uint8_t **data, int *size)
3218 {
3219  uint8_t *dst = NULL;
3220  uint8_t *src = *data;
3221  int dstlen = 0;
3222  int srclen = *size;
3223  uint32_t samples;
3224  uint16_t ver;
3225  int ret, offset = 0;
3226 
3227  if (srclen < 12)
3228  return AVERROR_INVALIDDATA;
3229 
3230  av_assert1(track->stream->codecpar->extradata_size >= 2);
3231  ver = AV_RL16(track->stream->codecpar->extradata);
3232 
3233  samples = AV_RL32(src);
3234  src += 4;
3235  srclen -= 4;
3236 
3237  while (srclen >= 8) {
3238  int multiblock;
3239  uint32_t blocksize;
3240  uint8_t *tmp;
3241 
3242  uint32_t flags = AV_RL32(src);
3243  uint32_t crc = AV_RL32(src + 4);
3244  src += 8;
3245  srclen -= 8;
3246 
3247  multiblock = (flags & 0x1800) != 0x1800;
3248  if (multiblock) {
3249  if (srclen < 4) {
3250  ret = AVERROR_INVALIDDATA;
3251  goto fail;
3252  }
3253  blocksize = AV_RL32(src);
3254  src += 4;
3255  srclen -= 4;
3256  } else
3257  blocksize = srclen;
3258 
3259  if (blocksize > srclen) {
3260  ret = AVERROR_INVALIDDATA;
3261  goto fail;
3262  }
3263 
3264  tmp = av_realloc(dst, dstlen + blocksize + 32 + AV_INPUT_BUFFER_PADDING_SIZE);
3265  if (!tmp) {
3266  ret = AVERROR(ENOMEM);
3267  goto fail;
3268  }
3269  dst = tmp;
3270  dstlen += blocksize + 32;
3271 
3272  AV_WL32(dst + offset, MKTAG('w', 'v', 'p', 'k')); // tag
3273  AV_WL32(dst + offset + 4, blocksize + 24); // blocksize - 8
3274  AV_WL16(dst + offset + 8, ver); // version
3275  AV_WL16(dst + offset + 10, 0); // track/index_no
3276  AV_WL32(dst + offset + 12, 0); // total samples
3277  AV_WL32(dst + offset + 16, 0); // block index
3278  AV_WL32(dst + offset + 20, samples); // number of samples
3279  AV_WL32(dst + offset + 24, flags); // flags
3280  AV_WL32(dst + offset + 28, crc); // crc
3281  memcpy(dst + offset + 32, src, blocksize); // block data
3282 
3283  src += blocksize;
3284  srclen -= blocksize;
3285  offset += blocksize + 32;
3286  }
3287 
3288  memset(dst + dstlen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3289 
3290  *data = dst;
3291  *size = dstlen;
3292 
3293  return 0;
3294 
3295 fail:
3296  av_freep(&dst);
3297  return ret;
3298 }
3299 
3301  uint8_t **data, int *size)
3302 {
3303  uint8_t *dst;
3304  int dstlen = *size + 8;
3305 
3306  dst = av_malloc(dstlen + AV_INPUT_BUFFER_PADDING_SIZE);
3307  if (!dst)
3308  return AVERROR(ENOMEM);
3309 
3310  AV_WB32(dst, dstlen);
3311  AV_WB32(dst + 4, MKBETAG('i', 'c', 'p', 'f'));
3312  memcpy(dst + 8, *data, dstlen - 8);
3313  memset(dst + dstlen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3314 
3315  *data = dst;
3316  *size = dstlen;
3317 
3318  return 0;
3319 }
3320 
3322  MatroskaTrack *track,
3323  AVStream *st,
3324  uint8_t *data, int data_len,
3325  uint64_t timecode,
3326  uint64_t duration,
3327  int64_t pos)
3328 {
3329  AVPacket pktl, *pkt = &pktl;
3330  uint8_t *id, *settings, *text, *buf;
3331  int id_len, settings_len, text_len;
3332  uint8_t *p, *q;
3333  int err;
3334 
3335  if (data_len <= 0)
3336  return AVERROR_INVALIDDATA;
3337 
3338  p = data;
3339  q = data + data_len;
3340 
3341  id = p;
3342  id_len = -1;
3343  while (p < q) {
3344  if (*p == '\r' || *p == '\n') {
3345  id_len = p - id;
3346  if (*p == '\r')
3347  p++;
3348  break;
3349  }
3350  p++;
3351  }
3352 
3353  if (p >= q || *p != '\n')
3354  return AVERROR_INVALIDDATA;
3355  p++;
3356 
3357  settings = p;
3358  settings_len = -1;
3359  while (p < q) {
3360  if (*p == '\r' || *p == '\n') {
3361  settings_len = p - settings;
3362  if (*p == '\r')
3363  p++;
3364  break;
3365  }
3366  p++;
3367  }
3368 
3369  if (p >= q || *p != '\n')
3370  return AVERROR_INVALIDDATA;
3371  p++;
3372 
3373  text = p;
3374  text_len = q - p;
3375  while (text_len > 0) {
3376  const int len = text_len - 1;
3377  const uint8_t c = p[len];
3378  if (c != '\r' && c != '\n')
3379  break;
3380  text_len = len;
3381  }
3382 
3383  if (text_len <= 0)
3384  return AVERROR_INVALIDDATA;
3385 
3386  err = av_new_packet(pkt, text_len);
3387  if (err < 0) {
3388  return err;
3389  }
3390 
3391  memcpy(pkt->data, text, text_len);
3392 
3393  if (id_len > 0) {
3394  buf = av_packet_new_side_data(pkt,
3396  id_len);
3397  if (!buf) {
3398  av_packet_unref(pkt);
3399  return AVERROR(ENOMEM);
3400  }
3401  memcpy(buf, id, id_len);
3402  }
3403 
3404  if (settings_len > 0) {
3405  buf = av_packet_new_side_data(pkt,
3407  settings_len);
3408  if (!buf) {
3409  av_packet_unref(pkt);
3410  return AVERROR(ENOMEM);
3411  }
3412  memcpy(buf, settings, settings_len);
3413  }
3414 
3415  // Do we need this for subtitles?
3416  // pkt->flags = AV_PKT_FLAG_KEY;
3417 
3418  pkt->stream_index = st->index;
3419  pkt->pts = timecode;
3420 
3421  // Do we need this for subtitles?
3422  // pkt->dts = timecode;
3423 
3424  pkt->duration = duration;
3425  pkt->pos = pos;
3426 
3427  err = ff_packet_list_put(&matroska->queue, &matroska->queue_end, pkt, 0);
3428  if (err < 0) {
3429  av_packet_unref(pkt);
3430  return AVERROR(ENOMEM);
3431  }
3432 
3433  return 0;
3434 }
3435 
3437  MatroskaTrack *track, AVStream *st,
3438  AVBufferRef *buf, uint8_t *data, int pkt_size,
3439  uint64_t timecode, uint64_t lace_duration,
3440  int64_t pos, int is_keyframe,
3441  uint8_t *additional, uint64_t additional_id, int additional_size,
3442  int64_t discard_padding)
3443 {
3444  uint8_t *pkt_data = data;
3445  int res = 0;
3446  AVPacket pktl, *pkt = &pktl;
3447 
3448  if (st->codecpar->codec_id == AV_CODEC_ID_WAVPACK) {
3449  res = matroska_parse_wavpack(track, &pkt_data, &pkt_size);
3450  if (res < 0) {
3451  av_log(matroska->ctx, AV_LOG_ERROR,
3452  "Error parsing a wavpack block.\n");
3453  goto fail;
3454  }
3455  if (!buf)
3456  av_freep(&data);
3457  buf = NULL;
3458  }
3459 
3460  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES &&
3461  AV_RB32(pkt_data + 4) != MKBETAG('i', 'c', 'p', 'f')) {
3462  res = matroska_parse_prores(track, &pkt_data, &pkt_size);
3463  if (res < 0) {
3464  av_log(matroska->ctx, AV_LOG_ERROR,
3465  "Error parsing a prores block.\n");
3466  goto fail;
3467  }
3468  if (!buf)
3469  av_freep(&data);
3470  buf = NULL;
3471  }
3472 
3473  if (!pkt_size && !additional_size)
3474  goto no_output;
3475 
3476  av_init_packet(pkt);
3477  if (!buf)
3478  pkt->buf = av_buffer_create(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE,
3479  NULL, NULL, 0);
3480  else
3481  pkt->buf = av_buffer_ref(buf);
3482 
3483  if (!pkt->buf) {
3484  res = AVERROR(ENOMEM);
3485  goto fail;
3486  }
3487 
3488  pkt->data = pkt_data;
3489  pkt->size = pkt_size;
3490  pkt->flags = is_keyframe;
3491  pkt->stream_index = st->index;
3492 
3493  if (additional_size > 0) {
3494  uint8_t *side_data = av_packet_new_side_data(pkt,
3496  additional_size + 8);
3497  if (!side_data) {
3498  av_packet_unref(pkt);
3499  return AVERROR(ENOMEM);
3500  }
3501  AV_WB64(side_data, additional_id);
3502  memcpy(side_data + 8, additional, additional_size);
3503  }
3504 
3505  if (discard_padding) {
3506  uint8_t *side_data = av_packet_new_side_data(pkt,
3508  10);
3509  if (!side_data) {
3510  av_packet_unref(pkt);
3511  return AVERROR(ENOMEM);
3512  }
3513  discard_padding = av_rescale_q(discard_padding,
3514  (AVRational){1, 1000000000},
3515  (AVRational){1, st->codecpar->sample_rate});
3516  if (discard_padding > 0) {
3517  AV_WL32(side_data + 4, discard_padding);
3518  } else {
3519  AV_WL32(side_data, -discard_padding);
3520  }
3521  }
3522 
3523  if (track->ms_compat)
3524  pkt->dts = timecode;
3525  else
3526  pkt->pts = timecode;
3527  pkt->pos = pos;
3528  pkt->duration = lace_duration;
3529 
3530 #if FF_API_CONVERGENCE_DURATION
3532  if (st->codecpar->codec_id == AV_CODEC_ID_SUBRIP) {
3533  pkt->convergence_duration = lace_duration;
3534  }
3536 #endif
3537 
3538  res = ff_packet_list_put(&matroska->queue, &matroska->queue_end, pkt, 0);
3539  if (res < 0) {
3540  av_packet_unref(pkt);
3541  return AVERROR(ENOMEM);
3542  }
3543 
3544  return 0;
3545 
3546 no_output:
3547 fail:
3548  if (!buf)
3549  av_free(pkt_data);
3550  return res;
3551 }
3552 
3554  int size, int64_t pos, uint64_t cluster_time,
3555  uint64_t block_duration, int is_keyframe,
3556  uint8_t *additional, uint64_t additional_id, int additional_size,
3557  int64_t cluster_pos, int64_t discard_padding)
3558 {
3559  uint64_t timecode = AV_NOPTS_VALUE;
3560  MatroskaTrack *track;
3561  AVIOContext pb;
3562  int res = 0;
3563  AVStream *st;
3564  int16_t block_time;
3565  uint32_t lace_size[256];
3566  int n, flags, laces = 0;
3567  uint64_t num;
3568  int trust_default_duration = 1;
3569 
3570  ffio_init_context(&pb, data, size, 0, NULL, NULL, NULL, NULL);
3571 
3572  if ((n = ebml_read_num(matroska, &pb, 8, &num, 1)) < 0)
3573  return n;
3574  data += n;
3575  size -= n;
3576 
3577  track = matroska_find_track_by_num(matroska, num);
3578  if (!track || size < 3)
3579  return AVERROR_INVALIDDATA;
3580 
3581  if (!(st = track->stream)) {
3582  av_log(matroska->ctx, AV_LOG_VERBOSE,
3583  "No stream associated to TrackNumber %"PRIu64". "
3584  "Ignoring Block with this TrackNumber.\n", num);
3585  return 0;
3586  }
3587 
3588  if (st->discard >= AVDISCARD_ALL)
3589  return res;
3590  if (block_duration > INT64_MAX)
3591  block_duration = INT64_MAX;
3592 
3593  block_time = sign_extend(AV_RB16(data), 16);
3594  data += 2;
3595  flags = *data++;
3596  size -= 3;
3597  if (is_keyframe == -1)
3598  is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
3599 
3600  if (cluster_time != (uint64_t) -1 &&
3601  (block_time >= 0 || cluster_time >= -block_time)) {
3602  timecode = cluster_time + block_time - track->codec_delay_in_track_tb;
3603  if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
3604  timecode < track->end_timecode)
3605  is_keyframe = 0; /* overlapping subtitles are not key frame */
3606  if (is_keyframe) {
3607  ff_reduce_index(matroska->ctx, st->index);
3608  av_add_index_entry(st, cluster_pos, timecode, 0, 0,
3610  }
3611  }
3612 
3613  if (matroska->skip_to_keyframe &&
3614  track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
3615  // Compare signed timecodes. Timecode may be negative due to codec delay
3616  // offset. We don't support timestamps greater than int64_t anyway - see
3617  // AVPacket's pts.
3618  if ((int64_t)timecode < (int64_t)matroska->skip_to_timecode)
3619  return res;
3620  if (is_keyframe)
3621  matroska->skip_to_keyframe = 0;
3622  else if (!st->skip_to_keyframe) {
3623  av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
3624  matroska->skip_to_keyframe = 0;
3625  }
3626  }
3627 
3628  res = matroska_parse_laces(matroska, &data, size, (flags & 0x06) >> 1,
3629  &pb, lace_size, &laces);
3630  if (res < 0) {
3631  av_log(matroska->ctx, AV_LOG_ERROR, "Error parsing frame sizes.\n");
3632  return res;
3633  }
3634 
3635  if (track->audio.samplerate == 8000) {
3636  // If this is needed for more codecs, then add them here
3637  if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
3638  if (track->audio.samplerate != st->codecpar->sample_rate || !st->codecpar->frame_size)
3639  trust_default_duration = 0;
3640  }
3641  }
3642 
3643  if (!block_duration && trust_default_duration)
3644  block_duration = track->default_duration * laces / matroska->time_scale;
3645 
3646  if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
3647  track->end_timecode =
3648  FFMAX(track->end_timecode, timecode + block_duration);
3649 
3650  for (n = 0; n < laces; n++) {
3651  int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
3652  uint8_t *out_data = data;
3653  int out_size = lace_size[n];
3654 
3655  if (track->needs_decoding) {
3656  res = matroska_decode_buffer(&out_data, &out_size, track);
3657  if (res < 0)
3658  return res;
3659  /* Given that we are here means that out_data is no longer
3660  * owned by buf, so set it to NULL. This depends upon
3661  * zero-length header removal compression being ignored. */
3662  av_assert1(out_data != data);
3663  buf = NULL;
3664  }
3665 
3666  if (track->audio.buf) {
3667  res = matroska_parse_rm_audio(matroska, track, st,
3668  out_data, out_size,
3669  timecode, pos);
3670  if (!buf)
3671  av_free(out_data);
3672  if (res)
3673  return res;
3674  } else if (st->codecpar->codec_id == AV_CODEC_ID_WEBVTT) {
3675  res = matroska_parse_webvtt(matroska, track, st,
3676  out_data, out_size,
3677  timecode, lace_duration,
3678  pos);
3679  if (!buf)
3680  av_free(out_data);
3681  if (res)
3682  return res;
3683  } else {
3684  res = matroska_parse_frame(matroska, track, st, buf, out_data,
3685  out_size, timecode, lace_duration,
3686  pos, !n ? is_keyframe : 0,
3687  additional, additional_id, additional_size,
3688  discard_padding);
3689  if (res)
3690  return res;
3691  }
3692 
3693  if (timecode != AV_NOPTS_VALUE)
3694  timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
3695  data += lace_size[n];
3696  }
3697 
3698  return 0;
3699 }
3700 
3702 {
3703  MatroskaCluster *cluster = &matroska->current_cluster;
3704  MatroskaBlock *block = &cluster->block;
3705  int res;
3706 
3707  av_assert0(matroska->num_levels <= 2U);
3708 
3709  if (matroska->num_levels == 1) {
3710  res = ebml_parse(matroska, matroska_segment, NULL);
3711 
3712  if (res == 1) {
3713  /* Found a cluster: subtract the size of the ID already read. */
3714  cluster->pos = avio_tell(matroska->ctx->pb) - 4;
3715 
3716  res = ebml_parse(matroska, matroska_cluster_enter, cluster);
3717  if (res < 0)
3718  return res;
3719  }
3720  }
3721 
3722  if (matroska->num_levels == 2) {
3723  /* We are inside a cluster. */
3724  res = ebml_parse(matroska, matroska_cluster_parsing, cluster);
3725 
3726  if (res >= 0 && block->bin.size > 0) {
3727  int is_keyframe = block->non_simple ? block->reference == INT64_MIN : -1;
3728  uint8_t* additional = block->additional.size > 0 ?
3729  block->additional.data : NULL;
3730 
3731  res = matroska_parse_block(matroska, block->bin.buf, block->bin.data,
3732  block->bin.size, block->bin.pos,
3733  cluster->timecode, block->duration,
3734  is_keyframe, additional, block->additional_id,
3735  block->additional.size, cluster->pos,
3736  block->discard_padding);
3737  }
3738 
3739  ebml_free(matroska_blockgroup, block);
3740  memset(block, 0, sizeof(*block));
3741  } else if (!matroska->num_levels) {
3742  if (!avio_feof(matroska->ctx->pb)) {
3743  avio_r8(matroska->ctx->pb);
3744  if (!avio_feof(matroska->ctx->pb)) {
3745  av_log(matroska->ctx, AV_LOG_WARNING, "File extends beyond "
3746  "end of segment.\n");
3747  return AVERROR_INVALIDDATA;
3748  }
3749  }
3750  matroska->done = 1;
3751  return AVERROR_EOF;
3752  }
3753 
3754  return res;
3755 }
3756 
3758 {
3759  MatroskaDemuxContext *matroska = s->priv_data;
3760  int ret = 0;
3761 
3762  if (matroska->resync_pos == -1) {
3763  // This can only happen if generic seeking has been used.
3764  matroska->resync_pos = avio_tell(s->pb);
3765  }
3766 
3767  while (matroska_deliver_packet(matroska, pkt)) {
3768  if (matroska->done)
3769  return (ret < 0) ? ret : AVERROR_EOF;
3770  if (matroska_parse_cluster(matroska) < 0 && !matroska->done)
3771  ret = matroska_resync(matroska, matroska->resync_pos);
3772  }
3773 
3774  return 0;
3775 }
3776 
3777 static int matroska_read_seek(AVFormatContext *s, int stream_index,
3778  int64_t timestamp, int flags)
3779 {
3780  MatroskaDemuxContext *matroska = s->priv_data;
3781  MatroskaTrack *tracks = NULL;
3782  AVStream *st = s->streams[stream_index];
3783  int i, index;
3784 
3785  /* Parse the CUES now since we need the index data to seek. */
3786  if (matroska->cues_parsing_deferred > 0) {
3787  matroska->cues_parsing_deferred = 0;
3788  matroska_parse_cues(matroska);
3789  }
3790 
3791  if (!st->nb_index_entries)
3792  goto err;
3793  timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
3794 
3795  if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 || index == st->nb_index_entries - 1) {
3796  matroska_reset_status(matroska, 0, st->index_entries[st->nb_index_entries - 1].pos);
3797  while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 || index == st->nb_index_entries - 1) {
3798  matroska_clear_queue(matroska);
3799  if (matroska_parse_cluster(matroska) < 0)
3800  break;
3801  }
3802  }
3803 
3804  matroska_clear_queue(matroska);
3805  if (index < 0 || (matroska->cues_parsing_deferred < 0 && index == st->nb_index_entries - 1))
3806  goto err;
3807 
3808  tracks = matroska->tracks.elem;
3809  for (i = 0; i < matroska->tracks.nb_elem; i++) {
3810  tracks[i].audio.pkt_cnt = 0;
3811  tracks[i].audio.sub_packet_cnt = 0;
3812  tracks[i].audio.buf_timecode = AV_NOPTS_VALUE;
3813  tracks[i].end_timecode = 0;
3814  }
3815 
3816  /* We seek to a level 1 element, so set the appropriate status. */
3817  matroska_reset_status(matroska, 0, st->index_entries[index].pos);
3818  if (flags & AVSEEK_FLAG_ANY) {
3819  st->skip_to_keyframe = 0;
3820  matroska->skip_to_timecode = timestamp;
3821  } else {
3822  st->skip_to_keyframe = 1;
3823  matroska->skip_to_timecode = st->index_entries[index].timestamp;
3824  }
3825  matroska->skip_to_keyframe = 1;
3826  matroska->done = 0;
3827  ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
3828  return 0;
3829 err:
3830  // slightly hackish but allows proper fallback to
3831  // the generic seeking code.
3832  matroska_reset_status(matroska, 0, -1);
3833  matroska->resync_pos = -1;
3834  matroska_clear_queue(matroska);
3835  st->skip_to_keyframe =
3836  matroska->skip_to_keyframe = 0;
3837  matroska->done = 0;
3838  return -1;
3839 }
3840 
3842 {
3843  MatroskaDemuxContext *matroska = s->priv_data;
3844  MatroskaTrack *tracks = matroska->tracks.elem;
3845  int n;
3846 
3847  matroska_clear_queue(matroska);
3848 
3849  for (n = 0; n < matroska->tracks.nb_elem; n++)
3850  if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
3851  av_freep(&tracks[n].audio.buf);
3852  ebml_free(matroska_segment, matroska);
3853 
3854  return 0;
3855 }
3856 
3857 typedef struct {
3862 } CueDesc;
3863 
3864 /* This function searches all the Cues and returns the CueDesc corresponding to
3865  * the timestamp ts. Returned CueDesc will be such that start_time_ns <= ts <
3866  * end_time_ns. All 4 fields will be set to -1 if ts >= file's duration.
3867  */
3869  MatroskaDemuxContext *matroska = s->priv_data;
3870  CueDesc cue_desc;
3871  int i;
3872  int nb_index_entries = s->streams[0]->nb_index_entries;
3873  AVIndexEntry *index_entries = s->streams[0]->index_entries;
3874 
3875  if (ts >= (int64_t)(matroska->duration * matroska->time_scale))
3876  return (CueDesc) {-1, -1, -1, -1};
3877  for (i = 1; i < nb_index_entries; i++) {
3878  if (index_entries[i - 1].timestamp * matroska->time_scale <= ts &&
3879  index_entries[i].timestamp * matroska->time_scale > ts) {
3880  break;
3881  }
3882  }
3883  --i;
3884  cue_desc.start_time_ns = index_entries[i].timestamp * matroska->time_scale;
3885  cue_desc.start_offset = index_entries[i].pos - matroska->segment_start;
3886  if (i != nb_index_entries - 1) {
3887  cue_desc.end_time_ns = index_entries[i + 1].timestamp * matroska->time_scale;
3888  cue_desc.end_offset = index_entries[i + 1].pos - matroska->segment_start;
3889  } else {
3890  cue_desc.end_time_ns = matroska->duration * matroska->time_scale;
3891  // FIXME: this needs special handling for files where Cues appear
3892  // before Clusters. the current logic assumes Cues appear after
3893  // Clusters.
3894  cue_desc.end_offset = cues_start - matroska->segment_start;
3895  }
3896  return cue_desc;
3897 }
3898 
3900 {
3901  MatroskaDemuxContext *matroska = s->priv_data;
3902  uint32_t id = matroska->current_id;
3903  int64_t cluster_pos, before_pos;
3904  int index, rv = 1;
3905  if (s->streams[0]->nb_index_entries <= 0) return 0;
3906  // seek to the first cluster using cues.
3907  index = av_index_search_timestamp(s->streams[0], 0, 0);
3908  if (index < 0) return 0;
3909  cluster_pos = s->streams[0]->index_entries[index].pos;
3910  before_pos = avio_tell(s->pb);
3911  while (1) {
3912  uint64_t cluster_id, cluster_length;
3913  int read;
3914  AVPacket *pkt;
3915  avio_seek(s->pb, cluster_pos, SEEK_SET);
3916  // read cluster id and length
3917  read = ebml_read_num(matroska, matroska->ctx->pb, 4, &cluster_id, 1);
3918  if (read < 0 || cluster_id != 0xF43B675) // done with all clusters
3919  break;
3920  read = ebml_read_length(matroska, matroska->ctx->pb, &cluster_length);
3921  if (read < 0)
3922  break;
3923 
3924  matroska_reset_status(matroska, 0, cluster_pos);
3925  matroska_clear_queue(matroska);
3926  if (matroska_parse_cluster(matroska) < 0 ||
3927  !matroska->queue) {
3928  break;
3929  }
3930  pkt = &matroska->queue->pkt;
3931  // 4 + read is the length of the cluster id and the cluster length field.
3932  cluster_pos += 4 + read + cluster_length;
3933  if (!(pkt->flags & AV_PKT_FLAG_KEY)) {
3934  rv = 0;
3935  break;
3936  }
3937  }
3938 
3939  /* Restore the status after matroska_read_header: */
3940  matroska_reset_status(matroska, id, before_pos);
3941 
3942  return rv;
3943 }
3944 
3945 static int buffer_size_after_time_downloaded(int64_t time_ns, double search_sec, int64_t bps,
3946  double min_buffer, double* buffer,
3947  double* sec_to_download, AVFormatContext *s,
3948  int64_t cues_start)
3949 {
3950  double nano_seconds_per_second = 1000000000.0;
3951  double time_sec = time_ns / nano_seconds_per_second;
3952  int rv = 0;
3953  int64_t time_to_search_ns = (int64_t)(search_sec * nano_seconds_per_second);
3954  int64_t end_time_ns = time_ns + time_to_search_ns;
3955  double sec_downloaded = 0.0;
3956  CueDesc desc_curr = get_cue_desc(s, time_ns, cues_start);
3957  if (desc_curr.start_time_ns == -1)
3958  return -1;
3959  *sec_to_download = 0.0;
3960 
3961  // Check for non cue start time.
3962  if (time_ns > desc_curr.start_time_ns) {
3963  int64_t cue_nano = desc_curr.end_time_ns - time_ns;
3964  double percent = (double)(cue_nano) / (desc_curr.end_time_ns - desc_curr.start_time_ns);
3965  double cueBytes = (desc_curr.end_offset - desc_curr.start_offset) * percent;
3966  double timeToDownload = (cueBytes * 8.0) / bps;
3967 
3968  sec_downloaded += (cue_nano / nano_seconds_per_second) - timeToDownload;
3969  *sec_to_download += timeToDownload;
3970 
3971  // Check if the search ends within the first cue.
3972  if (desc_curr.end_time_ns >= end_time_ns) {
3973  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
3974  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
3975  sec_downloaded = percent_to_sub * sec_downloaded;
3976  *sec_to_download = percent_to_sub * *sec_to_download;
3977  }
3978 
3979  if ((sec_downloaded + *buffer) <= min_buffer) {
3980  return 1;
3981  }
3982 
3983  // Get the next Cue.
3984  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
3985  }
3986 
3987  while (desc_curr.start_time_ns != -1) {
3988  int64_t desc_bytes = desc_curr.end_offset - desc_curr.start_offset;
3989  int64_t desc_ns = desc_curr.end_time_ns - desc_curr.start_time_ns;
3990  double desc_sec = desc_ns / nano_seconds_per_second;
3991  double bits = (desc_bytes * 8.0);
3992  double time_to_download = bits / bps;
3993 
3994  sec_downloaded += desc_sec - time_to_download;
3995  *sec_to_download += time_to_download;
3996 
3997  if (desc_curr.end_time_ns >= end_time_ns) {
3998  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
3999  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
4000  sec_downloaded = percent_to_sub * sec_downloaded;
4001  *sec_to_download = percent_to_sub * *sec_to_download;
4002 
4003  if ((sec_downloaded + *buffer) <= min_buffer)
4004  rv = 1;
4005  break;
4006  }
4007 
4008  if ((sec_downloaded + *buffer) <= min_buffer) {
4009  rv = 1;
4010  break;
4011  }
4012 
4013  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
4014  }
4015  *buffer = *buffer + sec_downloaded;
4016  return rv;
4017 }
4018 
4019 /* This function computes the bandwidth of the WebM file with the help of
4020  * buffer_size_after_time_downloaded() function. Both of these functions are
4021  * adapted from WebM Tools project and are adapted to work with FFmpeg's
4022  * Matroska parsing mechanism.
4023  *
4024  * Returns the bandwidth of the file on success; -1 on error.
4025  * */
4027 {
4028  MatroskaDemuxContext *matroska = s->priv_data;
4029  AVStream *st = s->streams[0];
4030  double bandwidth = 0.0;
4031  int i;
4032 
4033  for (i = 0; i < st->nb_index_entries; i++) {
4034  int64_t prebuffer_ns = 1000000000;
4035  int64_t time_ns = st->index_entries[i].timestamp * matroska->time_scale;
4036  double nano_seconds_per_second = 1000000000.0;
4037  int64_t prebuffered_ns;
4038  double prebuffer_bytes = 0.0;
4039  int64_t temp_prebuffer_ns = prebuffer_ns;
4040  int64_t pre_bytes, pre_ns;
4041  double pre_sec, prebuffer, bits_per_second;
4042  CueDesc desc_beg = get_cue_desc(s, time_ns, cues_start);
4043  // Start with the first Cue.
4044  CueDesc desc_end = desc_beg;
4045 
4046  if (time_ns > INT64_MAX - prebuffer_ns)
4047  return -1;
4048  prebuffered_ns = time_ns + prebuffer_ns;
4049 
4050  // Figure out how much data we have downloaded for the prebuffer. This will
4051  // be used later to adjust the bits per sample to try.
4052  while (desc_end.start_time_ns != -1 && desc_end.end_time_ns < prebuffered_ns) {
4053  // Prebuffered the entire Cue.
4054  prebuffer_bytes += desc_end.end_offset - desc_end.start_offset;
4055  temp_prebuffer_ns -= desc_end.end_time_ns - desc_end.start_time_ns;
4056  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
4057  }
4058  if (desc_end.start_time_ns == -1) {
4059  // The prebuffer is larger than the duration.
4060  if (matroska->duration * matroska->time_scale >= prebuffered_ns)
4061  return -1;
4062  bits_per_second = 0.0;
4063  } else {
4064  // The prebuffer ends in the last Cue. Estimate how much data was
4065  // prebuffered.
4066  pre_bytes = desc_end.end_offset - desc_end.start_offset;
4067  pre_ns = desc_end.end_time_ns - desc_end.start_time_ns;
4068  if (pre_ns <= 0)
4069  return -1;
4070  pre_sec = pre_ns / nano_seconds_per_second;
4071  prebuffer_bytes +=
4072  pre_bytes * ((temp_prebuffer_ns / nano_seconds_per_second) / pre_sec);
4073 
4074  prebuffer = prebuffer_ns / nano_seconds_per_second;
4075 
4076  // Set this to 0.0 in case our prebuffer buffers the entire video.
4077  bits_per_second = 0.0;
4078  do {
4079  int64_t desc_bytes = desc_end.end_offset - desc_beg.start_offset;
4080  int64_t desc_ns = desc_end.end_time_ns - desc_beg.start_time_ns;
4081  double desc_sec, calc_bits_per_second, percent, mod_bits_per_second;
4082  if (desc_bytes <= 0)
4083  return -1;
4084 
4085  desc_sec = desc_ns / nano_seconds_per_second;
4086  calc_bits_per_second = (desc_bytes * 8) / desc_sec;
4087 
4088  // Drop the bps by the percentage of bytes buffered.
4089  percent = (desc_bytes - prebuffer_bytes) / desc_bytes;
4090  mod_bits_per_second = calc_bits_per_second * percent;
4091 
4092  if (prebuffer < desc_sec) {
4093  double search_sec =
4094  (double)(matroska->duration * matroska->time_scale) / nano_seconds_per_second;
4095 
4096  // Add 1 so the bits per second should be a little bit greater than file
4097  // datarate.
4098  int64_t bps = (int64_t)(mod_bits_per_second) + 1;
4099  const double min_buffer = 0.0;
4100  double buffer = prebuffer;
4101  double sec_to_download = 0.0;
4102 
4103  int rv = buffer_size_after_time_downloaded(prebuffered_ns, search_sec, bps,
4104  min_buffer, &buffer, &sec_to_download,
4105  s, cues_start);
4106  if (rv < 0) {
4107  return -1;
4108  } else if (rv == 0) {
4109  bits_per_second = (double)(bps);
4110  break;
4111  }
4112  }
4113 
4114  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
4115  } while (desc_end.start_time_ns != -1);
4116  }
4117  if (bandwidth < bits_per_second) bandwidth = bits_per_second;
4118  }
4119  return (int64_t)bandwidth;
4120 }
4121 
4123 {
4124  MatroskaDemuxContext *matroska = s->priv_data;
4125  EbmlList *seekhead_list = &matroska->seekhead;
4126  MatroskaSeekhead *seekhead = seekhead_list->elem;
4127  char *buf;
4128  int64_t cues_start = -1, cues_end = -1, before_pos, bandwidth;
4129  int i;
4130  int end = 0;
4131 
4132  // determine cues start and end positions
4133  for (i = 0; i < seekhead_list->nb_elem; i++)
4134  if (seekhead[i].id == MATROSKA_ID_CUES)
4135  break;
4136 
4137  if (i >= seekhead_list->nb_elem) return -1;
4138 
4139  before_pos = avio_tell(matroska->ctx->pb);
4140  cues_start = seekhead[i].pos + matroska->segment_start;
4141  if (avio_seek(matroska->ctx->pb, cues_start, SEEK_SET) == cues_start) {
4142  // cues_end is computed as cues_start + cues_length + length of the
4143  // Cues element ID (i.e. 4) + EBML length of the Cues element.
4144  // cues_end is inclusive and the above sum is reduced by 1.
4145  uint64_t cues_length, cues_id;
4146  int bytes_read;
4147  bytes_read = ebml_read_num (matroska, matroska->ctx->pb, 4, &cues_id, 1);
4148  if (bytes_read < 0 || cues_id != (MATROSKA_ID_CUES & 0xfffffff))
4149  return bytes_read < 0 ? bytes_read : AVERROR_INVALIDDATA;
4150  bytes_read = ebml_read_length(matroska, matroska->ctx->pb, &cues_length);
4151  if (bytes_read < 0)
4152  return bytes_read;
4153  cues_end = cues_start + 4 + bytes_read + cues_length - 1;
4154  }
4155  avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
4156  if (cues_start == -1 || cues_end == -1) return -1;
4157 
4158  // parse the cues
4159  matroska_parse_cues(matroska);
4160 
4161  // cues start
4162  av_dict_set_int(&s->streams[0]->metadata, CUES_START, cues_start, 0);
4163 
4164  // cues end
4165  av_dict_set_int(&s->streams[0]->metadata, CUES_END, cues_end, 0);
4166 
4167  // if the file has cues at the start, fix up the init range so that
4168  // it does not include it
4169  if (cues_start <= init_range)
4170  av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, cues_start - 1, 0);
4171 
4172  // bandwidth
4173  bandwidth = webm_dash_manifest_compute_bandwidth(s, cues_start);
4174  if (bandwidth < 0) return -1;
4175  av_dict_set_int(&s->streams[0]->metadata, BANDWIDTH, bandwidth, 0);
4176 
4177  // check if all clusters start with key frames
4179 
4180  // store cue point timestamps as a comma separated list for checking subsegment alignment in
4181  // the muxer. assumes that each timestamp cannot be more than 20 characters long.
4182  buf = av_malloc_array(s->streams[0]->nb_index_entries, 20);
4183  if (!buf) return -1;
4184  strcpy(buf, "");
4185  for (i = 0; i < s->streams[0]->nb_index_entries; i++) {
4186  int ret = snprintf(buf + end, 20,
4187  "%" PRId64"%s", s->streams[0]->index_entries[i].timestamp,
4188  i != s->streams[0]->nb_index_entries - 1 ? "," : "");
4189  if (ret <= 0 || (ret == 20 && i == s->streams[0]->nb_index_entries - 1)) {
4190  av_log(s, AV_LOG_ERROR, "timestamp too long.\n");
4191  av_free(buf);
4192  return AVERROR_INVALIDDATA;
4193  }
4194  end += ret;
4195  }
4198 
4199  return 0;
4200 }
4201 
4203 {
4204  char *buf;
4205  int ret = matroska_read_header(s);
4206  int64_t init_range;
4207  MatroskaTrack *tracks;
4208  MatroskaDemuxContext *matroska = s->priv_data;
4209  if (ret) {
4210  av_log(s, AV_LOG_ERROR, "Failed to read file headers\n");
4211  return -1;
4212  }
4213  if (!matroska->tracks.nb_elem || !s->nb_streams) {
4214  av_log(s, AV_LOG_ERROR, "No track found\n");
4215  ret = AVERROR_INVALIDDATA;
4216  goto fail;
4217  }
4218 
4219  if (!matroska->is_live) {
4220  buf = av_asprintf("%g", matroska->duration);
4221  if (!buf) {
4222  ret = AVERROR(ENOMEM);
4223  goto fail;
4224  }
4227 
4228  // initialization range
4229  // 5 is the offset of Cluster ID.
4230  init_range = avio_tell(s->pb) - 5;
4231  av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, init_range, 0);
4232  }
4233 
4234  // basename of the file
4235  buf = strrchr(s->url, '/');
4236  av_dict_set(&s->streams[0]->metadata, FILENAME, buf ? ++buf : s->url, 0);
4237 
4238  // track number
4239  tracks = matroska->tracks.elem;
4240  av_dict_set_int(&s->streams[0]->metadata, TRACK_NUMBER, tracks[0].num, 0);
4241 
4242  // parse the cues and populate Cue related fields
4243  if (!matroska->is_live) {
4244  ret = webm_dash_manifest_cues(s, init_range);
4245  if (ret < 0) {
4246  av_log(s, AV_LOG_ERROR, "Error parsing Cues\n");
4247  goto fail;
4248  }
4249  }
4250 
4251  // use the bandwidth from the command line if it was provided
4252  if (matroska->bandwidth > 0) {
4254  matroska->bandwidth, 0);
4255  }
4256  return 0;
4257 fail:
4259  return ret;
4260 }
4261 
4263 {
4264  return AVERROR_EOF;
4265 }
4266 
4267 #define OFFSET(x) offsetof(MatroskaDemuxContext, x)
4268 static const AVOption options[] = {
4269  { "live", "flag indicating that the input is a live file that only has the headers.", OFFSET(is_live), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
4270  { "bandwidth", "bandwidth of this stream to be specified in the DASH manifest.", OFFSET(bandwidth), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
4271  { NULL },
4272 };
4273 
4274 static const AVClass webm_dash_class = {
4275  .class_name = "WebM DASH Manifest demuxer",
4276  .item_name = av_default_item_name,
4277  .option = options,
4278  .version = LIBAVUTIL_VERSION_INT,
4279 };
4280 
4282  .name = "matroska,webm",
4283  .long_name = NULL_IF_CONFIG_SMALL("Matroska / WebM"),
4284  .extensions = "mkv,mk3d,mka,mks",
4285  .priv_data_size = sizeof(MatroskaDemuxContext),
4291  .mime_type = "audio/webm,audio/x-matroska,video/webm,video/x-matroska"
4292 };
4293 
4295  .name = "webm_dash_manifest",
4296  .long_name = NULL_IF_CONFIG_SMALL("WebM DASH Manifest"),
4297  .priv_data_size = sizeof(MatroskaDemuxContext),
4301  .priv_class = &webm_dash_class,
4302 };
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:127
#define MATROSKA_ID_SEEKPREROLL
Definition: matroska.h:95
const char * s
Definition: matroskadec.c:106
#define MATROSKA_ID_VIDEOPROJECTIONPOSEYAW
Definition: matroska.h:159
AVSphericalMapping * av_spherical_alloc(size_t *size)
Allocate a AVSphericalVideo structure and initialize its fields to default values.
Definition: spherical.c:24
uint64_t codec_delay_in_track_tb
Definition: matroskadec.c:247
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
#define AV_DISPOSITION_METADATA
Definition: avformat.h:858
#define NULL
Definition: coverity.c:32
MatroskaBlock block
Definition: matroskadec.c:330
static EbmlSyntax matroska_simpletag[]
Definition: matroskadec.c:653
#define MATROSKA_ID_BLOCKADDID
Definition: matroska.h:230
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:104
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska, MatroskaTrack *track, AVStream *st, uint8_t *data, int size, uint64_t timecode, int64_t pos)
Definition: matroskadec.c:3138
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:148
#define MATROSKA_ID_VIDEOFLAGINTERLACED
Definition: matroska.h:121
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define MATROSKA_ID_VIDEOCOLOR_GX
Definition: matroska.h:147
uint64_t seek_preroll
Definition: matroskadec.c:241
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
const char *const ff_matroska_video_stereo_plane[MATROSKA_VIDEO_STEREO_PLANE_COUNT]
Definition: matroska.c:146
version
Definition: libkvazaar.c:292
static void matroska_convert_tags(AVFormatContext *s)
Definition: matroskadec.c:1758
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:71
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
int size
The optional first identifier line of a WebVTT cue.
Definition: packet.h:196
uint64_t type
Definition: matroskadec.c:232
#define MATROSKA_ID_TRACKFLAGLACING
Definition: matroska.h:101
static int webm_dash_manifest_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskadec.c:4262
#define MATROSKA_ID_TRACKENTRY
Definition: matroska.h:75
static int matroska_deliver_packet(MatroskaDemuxContext *matroska, AVPacket *pkt)
Definition: matroskadec.c:3010
static const CodecMime mkv_image_mime_tags[]
Definition: matroskadec.c:752
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:113
uint64_t version
Definition: matroskadec.c:125
AVOption.
Definition: opt.h:246
static EbmlSyntax matroska_blockmore[]
Definition: matroskadec.c:711
AVInputFormat ff_matroska_demuxer
Definition: matroskadec.c:4281
static int is_keyframe(NalUnitType naltype)
Definition: libx265.c:60
int ff_packet_list_put(AVPacketList **head, AVPacketList **tail, AVPacket *pkt, int flags)
Append an AVPacket to the list.
Definition: utils.c:444
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:2052
AVPacketList * queue
Definition: matroskadec.c:368
#define MATROSKA_ID_VIDEOPROJECTIONPOSEROLL
Definition: matroska.h:161
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:192
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3165
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:89
const unsigned char ff_sipr_subpk_size[4]
Definition: rmsipr.c:25
#define MATROSKA_ID_TAGTARGETS_TYPE
Definition: matroska.h:210
uint64_t display_unit
Definition: matroskadec.c:194
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static EbmlSyntax matroska_track_video[19]
Definition: matroskadec.c:399
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
#define INITIALIZATION_RANGE
Definition: matroska.h:370
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:375
#define AV_RB64
Definition: intreadwrite.h:164
static int webm_clusters_start_with_keyframe(AVFormatContext *s)
Definition: matroskadec.c:3899
else temp
Definition: vf_mcdeint.c:256
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4948
int64_t pos
Definition: avformat.h:805
#define MATROSKA_ID_ENCODINGTYPE
Definition: matroska.h:173
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:167
uint64_t chapteruid
Definition: matroskadec.c:300
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2514
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:99
uint64_t additional_id
Definition: matroskadec.c:324
EbmlList tag
Definition: matroskadec.c:306
static int segment_start(AVFormatContext *s, int write_header)
Definition: segment.c:239
uint64_t uid
Definition: matroskadec.c:231
int64_t data_offset
offset of the first packet
Definition: internal.h:80
static EbmlSyntax matroska_segments[]
Definition: matroskadec.c:706
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
MatroskaCluster current_cluster
Definition: matroskadec.c:384
uint32_t fourcc
Definition: vaapi_decode.c:239
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection...
Definition: spherical.h:72
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:938
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:214
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:877
int size
Definition: packet.h:356
static EbmlSyntax matroska_track_video_projection[]
Definition: matroskadec.c:466
#define MATROSKA_ID_CLUSTERPOSITION
Definition: matroska.h:225
const char * b
Definition: vf_curves.c:116
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
#define MATROSKA_ID_FILEDATA
Definition: matroska.h:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1105
MatroskaTrackVideoProjection projection
Definition: matroskadec.c:200
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1804
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:42
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:237
uint64_t flag_forced
Definition: matroskadec.c:240
uint64_t max_size
Definition: matroskadec.c:126
#define MATROSKA_ID_TRACKTYPE
Definition: matroska.h:80
unsigned char * buffer
Start of the buffer.
Definition: avio.h:226
#define MATROSKA_ID_TAGTARGETS_CHAPTERUID
Definition: matroska.h:213
#define AV_RL16
Definition: intreadwrite.h:42
uint64_t flag_default
Definition: matroskadec.c:239
#define MATROSKA_ID_VIDEOCOLOR_RX
Definition: matroska.h:145
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:56
#define MATROSKA_ID_VIDEOASPECTRATIO
Definition: matroska.h:125
int out_size
Definition: movenc.c:55
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:70
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:168
char * name
Definition: matroskadec.c:289
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
const char * key
static EbmlSyntax matroska_index[2]
Definition: matroskadec.c:399
discard all
Definition: avcodec.h:236
#define MATROSKA_ID_VIDEOPROJECTIONTYPE
Definition: matroska.h:157
MatroskaLevel levels[EBML_MAX_DEPTH]
Definition: matroskadec.c:346
static EbmlSyntax matroska_track_audio[]
Definition: matroskadec.c:497
static AVPacket pkt
#define MATROSKA_ID_CUECLUSTERPOSITION
Definition: matroska.h:196
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
Definition: matroska.h:153
static int ebml_read_binary(AVIOContext *pb, int length, int64_t pos, EbmlBin *bin)
Definition: matroskadec.c:1003
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:763
MatroskaTrackAudio audio
Definition: matroskadec.c:243
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
Definition: matroska.h:135
uint64_t duration
Definition: matroskadec.c:320
const struct EbmlSyntax * n
Definition: matroskadec.c:107
#define MATROSKA_ID_EDITIONFLAGDEFAULT
Definition: matroska.h:260
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:224
#define EBML_ID_DOCTYPE
Definition: matroska.h:40
#define MATROSKA_ID_ENCODINGENCALGO
Definition: matroska.h:180
static EbmlSyntax matroska_attachment[]
Definition: matroskadec.c:586
#define MATROSKA_ID_CHAPTERTIMEEND
Definition: matroska.h:253
enum AVColorSpace color_space
Definition: codec_par.h:149
#define MATROSKA_ID_TRACKCONTENTENCODINGS
Definition: matroska.h:105
int frame_size
Audio only.
Definition: codec_par.h:181
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
#define AV_LZO_OUTPUT_FULL
decoded data did not fit into output buffer
Definition: lzo.h:39
AVChapter * avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: utils.c:4654
#define EBML_VERSION
Definition: matroska.h:30
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:243
Format I/O context.
Definition: avformat.h:1351
#define EBML_ID_CRC32
Definition: matroska.h:46
uint64_t def
Definition: matroskadec.c:292
UID uid
Definition: mxfenc.c:2136
static int16_t block[64]
Definition: dct.c:115
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: utils.c:1966
#define MATROSKA_ID_TRACKCONTENTENCODING
Definition: matroska.h:106
#define MATROSKA_ID_CODECDOWNLOADURL
Definition: matroska.h:92
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
int64_t end_timecode
Definition: matroskadec.c:250
static int webm_dash_manifest_read_header(AVFormatContext *s)
Definition: matroskadec.c:4202
static EbmlSyntax matroska_mastering_meta[]
Definition: matroskadec.c:434
static int ebml_read_sint(AVIOContext *pb, int size, int64_t *num)
Definition: matroskadec.c:940
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: utils.c:1980
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1484
Public dictionary API.
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: dict.c:258
int ffio_limit(AVIOContext *s, int size)
Definition: utils.c:243
static char buffer[20]
Definition: seek.c:32
static int matroska_parse_prores(MatroskaTrack *track, uint8_t **data, int *size)
Definition: matroskadec.c:3300
uint64_t pixel_height
Definition: matroskadec.c:192
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
uint8_t
#define MATROSKA_ID_VIDEOCOLOR_BX
Definition: matroska.h:149
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:256
#define av_malloc(s)
uint64_t stereo_mode
Definition: matroskadec.c:197
MatroskaTrackOperation operation
Definition: matroskadec.c:244
MatroskaTrackVideo video
Definition: matroskadec.c:242
#define MATROSKA_ID_EDITIONFLAGORDERED
Definition: matroska.h:261
int width
Video only.
Definition: codec_par.h:126
static EbmlSyntax matroska_cluster_parsing[8]
Definition: matroskadec.c:399
static CueDesc get_cue_desc(AVFormatContext *s, int64_t ts, int64_t cues_start)
Definition: matroskadec.c:3868
static const AVProfile aac_profiles[]
void * elem
Definition: matroskadec.c:114
AVOptions.
#define MATROSKA_ID_TRACKLANGUAGE
Definition: matroska.h:97
MatroskaTrackCompression compression
Definition: matroskadec.c:145
uint8_t * data
Definition: matroskadec.c:120
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom.c:75
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
AVPacket pkt
Definition: avformat.h:2025
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
uint64_t time
Definition: matroskadec.c:284
#define AV_RB32
Definition: intreadwrite.h:130
int ff_mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
Definition: matroska.c:152
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
#define MATROSKA_ID_VIDEOPIXELCROPT
Definition: matroska.h:117
#define TRACK_NUMBER
Definition: matroska.h:378
#define MATROSKA_ID_TIMECODESCALE
Definition: matroska.h:66
static int matroska_aac_sri(int samplerate)
Definition: matroskadec.c:1962
enum AVStreamParseType need_parsing
Definition: avformat.h:1094
#define MATROSKA_ID_VIDEOCOLORCBSUBVERT
Definition: matroska.h:134
#define MATROSKA_ID_SIMPLEBLOCK
Definition: matroska.h:232
#define MATROSKA_ID_TAGTARGETS_TYPEVALUE
Definition: matroska.h:211
#define MATROSKA_ID_EDITIONFLAGHIDDEN
Definition: matroska.h:259
#define AV_LZO_OUTPUT_PADDING
Definition: lzo.h:47
AVStream * stream
Definition: matroskadec.c:266
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4526
#define MATROSKA_ID_CODECNAME
Definition: matroska.h:90
char * language
Definition: matroskadec.c:236
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:229
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
int64_t duration
Definition: movenc.c:63
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:197
#define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
Definition: matroska.h:165
#define MATROSKA_ID_VIDEOCOLOR
Definition: matroska.h:127
int initial_padding
Audio only.
Definition: codec_par.h:189
const char data[16]
Definition: mxf.c:91
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1482
uint8_t * data
Definition: packet.h:355
uint64_t typevalue
Definition: matroskadec.c:298
uint64_t codec_delay
Definition: matroskadec.c:246
static EbmlSyntax matroska_tags[2]
Definition: matroskadec.c:399
#define MATROSKA_ID_VIDEODISPLAYWIDTH
Definition: matroska.h:112
#define MATROSKA_ID_EDITIONUID
Definition: matroska.h:258
int ff_vorbis_comment(AVFormatContext *ms, AVDictionary **m, const uint8_t *buf, int size, int parse_picture)
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:228
uint32_t tag
Definition: movenc.c:1532
int64_t start_time_ns
Definition: matroskadec.c:3858
static EbmlSyntax ebml_header[]
Definition: matroskadec.c:406
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define MATROSKA_ID_CODECDECODEALL
Definition: matroska.h:93
#define MATROSKA_ID_ENCODINGENCRYPTION
Definition: matroska.h:178
size_t list_elem_size
Definition: matroskadec.c:100
enum AVCodecID id
Definition: internal.h:49
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define MATROSKA_ID_CUES
Definition: matroska.h:58
#define EBML_MAX_DEPTH
Definition: matroska.h:359
static int mkv_parse_video_color(AVStream *st, const MatroskaTrack *track)
Definition: matroskadec.c:2085
static EbmlSyntax matroska_track_operation[2]
Definition: matroskadec.c:399
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:899
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
unsigned int alloc_elem_size
Definition: matroskadec.c:113
static const uint8_t header[24]
Definition: sdr2.c:67
static EbmlSyntax matroska_blockadditions[2]
Definition: matroskadec.c:399
#define MATROSKA_ID_TRACKNUMBER
Definition: matroska.h:78
#define MATROSKA_ID_VIDEOCOLOR_WHITEY
Definition: matroska.h:152
channels
Definition: aptx.h:33
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:72
#define EBML_UNKNOWN_LENGTH
Definition: matroskadec.c:71
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:856
EbmlList sub
Definition: matroskadec.c:293
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:3701
static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax, void *data)
Definition: matroskadec.c:1085
#define MATROSKA_ID_CUEBLOCKNUMBER
Definition: matroska.h:199
#define MATROSKA_ID_TRACKUID
Definition: matroska.h:79
static EbmlSyntax matroska_tracks[2]
Definition: matroskadec.c:399
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
uint64_t display_height
Definition: matroskadec.c:190
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:254
static EbmlSyntax matroska_info[]
Definition: matroskadec.c:423
#define MATROSKA_ID_ENCODINGORDER
Definition: matroska.h:171
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:123
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
#define AVINDEX_KEYFRAME
Definition: avformat.h:812
#define FILENAME
Definition: matroska.h:373
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
EbmlType type
Definition: matroskadec.c:99
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define MATROSKA_ID_VIDEOCOLOR_BY
Definition: matroska.h:150
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:236
int64_t end_offset
Definition: matroskadec.c:3861
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:37
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2169
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:141
MatroskaMasteringMeta mastering_meta
Definition: matroskadec.c:176
#define MATROSKA_ID_VIDEOCOLOR_WHITEX
Definition: matroska.h:151
static const uint16_t mask[17]
Definition: lzw.c:38
FLAC (Free Lossless Audio Codec) decoder/demuxer common functions.
static int ebml_read_length(MatroskaDemuxContext *matroska, AVIOContext *pb, uint64_t *number)
Read a EBML length value.
Definition: matroskadec.c:911
#define AV_RB16
Definition: intreadwrite.h:53
AVChapter * chapter
Definition: matroskadec.c:275
#define AVERROR(e)
Definition: error.h:43
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:806
#define MATROSKA_ID_CLUSTER
Definition: matroska.h:62
static EbmlSyntax matroska_track_encodings[2]
Definition: matroskadec.c:399
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT
Definition: matroska.h:136
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
#define MATROSKA_ID_FILEMIMETYPE
Definition: matroska.h:245
char * url
input or output URL.
Definition: avformat.h:1447
const char * r
Definition: vf_curves.c:114
uint64_t display_width
Definition: matroskadec.c:189
union EbmlSyntax::@259 def
unsigned int pos
Definition: spdifenc.c:412
#define MATROSKA_ID_WRITINGAPP
Definition: matroska.h:69
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
EbmlBin additional
Definition: matroskadec.c:325
static int matroska_parse_wavpack(MatroskaTrack *track, uint8_t **data, int *size)
Definition: matroskadec.c:3216
const char *const ff_matroska_video_stereo_mode[MATROSKA_VIDEO_STEREOMODE_TYPE_NB]
Definition: matroska.c:128
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:338
static int matroska_ebmlnum_sint(MatroskaDemuxContext *matroska, AVIOContext *pb, int64_t *num)
Definition: matroskadec.c:1053
static int matroska_probe(const AVProbeData *p)
Definition: matroskadec.c:1522
#define MATROSKA_ID_TAGDEFAULT_BUG
Definition: matroska.h:208
enum AVCodecID id
Definition: matroska.h:355
#define MATROSKA_ID_VIDEOPIXELCROPR
Definition: matroska.h:119
#define MATROSKA_ID_TRACKPLANEUID
Definition: matroska.h:86
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define MATROSKA_ID_ENCODINGCOMPSETTINGS
Definition: matroska.h:176
uint8_t bits
Definition: vp3data.h:202
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:38
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
#define MATROSKA_ID_CHAPTERFLAGHIDDEN
Definition: matroska.h:263
int av_buffer_realloc(AVBufferRef **pbuf, int size)
Reallocate a given buffer.
Definition: buffer.c:169
static const uint8_t offset[127][2]
Definition: vf_spp.c:93
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:140
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:949
uint64_t timecode
Definition: matroskadec.c:331
#define CONFIG_ZLIB
Definition: config.h:523
#define FFMAX(a, b)
Definition: common.h:94
static EbmlSyntax matroska_chapter_entry[9]
Definition: matroskadec.c:399
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
AVPacketList * queue_end
Definition: matroskadec.c:369
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:123
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
Only parse headers, do not repack.
Definition: avformat.h:796
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
static void ebml_free(EbmlSyntax *syntax, void *data)
Definition: matroskadec.c:1487
int nb_elem
Definition: matroskadec.c:112
#define MATROSKA_ID_TAG
Definition: matroska.h:202
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
static int matroska_reset_status(MatroskaDemuxContext *matroska, uint32_t id, int64_t position)
Definition: matroskadec.c:778
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
static EbmlSyntax matroska_track[27]
Definition: matroskadec.c:399
char * lang
Definition: matroskadec.c:291
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:833
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:170
static EbmlSyntax matroska_index_entry[3]
Definition: matroskadec.c:399
static EbmlSyntax matroska_track_combine_planes[2]
Definition: matroskadec.c:399
#define MATROSKA_ID_ENCODINGSIGHASHALGO
Definition: matroska.h:183
static const struct @315 planes[]
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
uint64_t skip_to_timecode
Definition: matroskadec.c:375
Definition: dct.c:52
#define SKIP_THRESHOLD
Definition: matroskadec.c:76
int block_align
Audio only.
Definition: codec_par.h:177
static int matroska_read_header(AVFormatContext *s)
Definition: matroskadec.c:2845
static MatroskaTrack * matroska_find_track_by_num(MatroskaDemuxContext *matroska, uint64_t num)
Definition: matroskadec.c:1569
static void matroska_parse_cues(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:1932
const char * name
Definition: qsvenc.c:46
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int64_t i
Definition: matroskadec.c:103
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:65
static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:1861
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN
Definition: matroska.h:154
uint64_t start
Definition: matroskadec.c:270
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3328
#define EBML_ID_EBMLVERSION
Definition: matroska.h:36
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
Spherical video.
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
#define MATROSKA_ID_TAGTARGETS
Definition: matroska.h:209
#define MATROSKA_ID_VIDEOCOLORBITSPERCHANNEL
Definition: matroska.h:130
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as stream side data.
Definition: utils.c:5525
#define MATROSKA_VIDEO_STEREO_PLANE_COUNT
Definition: matroska.h:361
uint8_t interlaced
Definition: mxfenc.c:2139
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:204
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
#define MATROSKA_ID_TRACKTIMECODESCALE
Definition: matroska.h:107
#define MATROSKA_ID_CHAPTERFLAGENABLED
Definition: matroska.h:264
uint64_t id_length
Definition: matroskadec.c:127
uint8_t w
Definition: llviddspenc.c:38
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
static int webm_dash_manifest_cues(AVFormatContext *s, int64_t init_range)
Definition: matroskadec.c:4122
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:228
uint32_t bound_right
Distance from the right edge.
Definition: spherical.h:169
#define UNKNOWN_EQUIV
Definition: matroskadec.c:79
#define CLUSTER_KEYFRAME
Definition: matroska.h:376
#define MATROSKA_ID_SIMPLETAG
Definition: matroska.h:203
uint64_t doctype_version
Definition: matroskadec.c:129
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
int32_t
#define MATROSKA_ID_TRACKMAXCACHE
Definition: matroska.h:103
static EbmlSyntax matroska_chapter[6]
Definition: matroskadec.c:399
static int matroska_parse_laces(MatroskaDemuxContext *matroska, uint8_t **buf, int size, int type, AVIOContext *pb, uint32_t lace_size[256], int *laces)
Definition: matroskadec.c:3042
#define DURATION
Definition: matroska.h:375
#define MATROSKA_ID_CHAPTERPHYSEQUIV
Definition: matroska.h:265
static int matroska_read_close(AVFormatContext *s)
Definition: matroskadec.c:3841
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
EbmlBin codec_priv
Definition: matroskadec.c:235
static int ebml_read_ascii(AVIOContext *pb, int size, char **str)
Definition: matroskadec.c:979
static int matroska_decode_buffer(uint8_t **buf, int *buf_size, MatroskaTrack *track)
Definition: matroskadec.c:1583
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:251
#define OFFSET(x)
Definition: matroskadec.c:4267
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:478
#define AV_RL32
Definition: intreadwrite.h:146
int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen)
Decodes LZO 1x compressed data.
Definition: lzo.c:134
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:126
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
AVDictionary * metadata
Definition: avformat.h:940
uint8_t * av_stream_new_side_data(AVStream *stream, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
Definition: utils.c:5561
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
enum AVColorRange color_range
Video only.
Definition: codec_par.h:146
Opaque data information usually sparse.
Definition: avutil.h:205
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:126
#define MATROSKA_ID_CHAPTERS
Definition: matroska.h:63
#define EBML_ID_VOID
Definition: matroska.h:45
static void mkv_stereo_mode_display_mul(int stereo_mode, int *h_width, int *h_height)
Definition: matroskadec.c:2060
static void matroska_convert_tag(AVFormatContext *s, EbmlList *list, AVDictionary **metadata, char *prefix)
Definition: matroskadec.c:1723
uint64_t max_block_additional_id
Definition: matroskadec.c:253
#define MATROSKA_ID_VIDEOCOLORCHROMASUBVERT
Definition: matroska.h:132
const uint8_t ff_log2_tab[256]
Definition: log2_tab.c:23
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:164
#define FF_ARRAY_ELEMS(a)
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:844
double f
Definition: matroskadec.c:105
#define MATROSKA_ID_TRACKMINCACHE
Definition: matroska.h:102
#define av_log2
Definition: intmath.h:83
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
Definition: matroskadec.c:1972
static int matroska_parse_flac(AVFormatContext *s, MatroskaTrack *track, int *offset)
Definition: matroskadec.c:1978
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:545
static EbmlSyntax matroska_track_video_color[15]
Definition: matroskadec.c:399
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:182
static int matroska_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: matroskadec.c:3777
Stream structure.
Definition: avformat.h:876
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define MATROSKA_ID_TRACKPLANETYPE
Definition: matroska.h:87
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVSphericalProjection
Projection of the video surface(s) on a sphere.
Definition: spherical.h:51
Content light level (based on CTA-861.3).
Definition: packet.h:235
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
EbmlList encodings
Definition: matroskadec.c:245
#define CUES_END
Definition: matroska.h:372
char * codec_id
Definition: matroskadec.c:234
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:821
#define MATROSKA_ID_VIDEOPIXELCROPB
Definition: matroska.h:116
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define MATROSKA_ID_VIDEOCOLORMATRIXCOEFF
Definition: matroska.h:129
static int matroska_parse_tracks(AVFormatContext *s)
Definition: matroskadec.c:2291
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:857
int ff_get_qtpalette(int codec_id, AVIOContext *pb, uint32_t *palette)
Retrieve the palette (or "color table" in QuickTime terms), either from the video sample description...
Definition: qtpalette.c:31
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
#define MATROSKA_ID_TRACKFLAGFORCED
Definition: matroska.h:100
#define MATROSKA_ID_TAGS
Definition: matroska.h:59
static EbmlSyntax matroska_track_plane[]
Definition: matroskadec.c:535
#define MATROSKA_ID_VIDEOCOLORPRIMARIES
Definition: matroska.h:140
const AVCodecTag ff_codec_movaudio_tags[]
Definition: isom.c:321
#define MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH
Definition: matroska.h:160
#define MATROSKA_ID_TAGDEFAULT
Definition: matroska.h:207
#define BANDWIDTH
Definition: matroska.h:374
#define MATROSKA_ID_SEEKID
Definition: matroska.h:220
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
#define MATROSKA_ID_ENCODINGCOMPALGO
Definition: matroska.h:175
#define MATROSKA_ID_BLOCK
Definition: matroska.h:235
#define MATROSKA_ID_INFO
Definition: matroska.h:56
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
long long int64_t
Definition: coverity.c:34
#define MATROSKA_ID_TAGTARGETS_TRACKUID
Definition: matroska.h:212
uint8_t * data
The data buffer.
Definition: buffer.h:89
#define CUE_TIMESTAMPS
Definition: matroska.h:377
#define MATROSKA_ID_TAGLANG
Definition: matroska.h:206
uint64_t pixel_width
Definition: matroskadec.c:191
#define MATROSKA_ID_TRACKCOMBINEPLANES
Definition: matroska.h:84
static const AVClass webm_dash_class
Definition: matroskadec.c:4274
static EbmlSyntax matroska_segment[9]
Definition: matroskadec.c:399
int64_t start_offset
Definition: matroskadec.c:3860
#define MATROSKA_ID_TRACKFLAGENABLED
Definition: matroska.h:98
#define MATROSKA_ID_TRACKS
Definition: matroska.h:57
static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb, int max_size, uint64_t *number, int eof_forbidden)
Definition: matroskadec.c:846
#define MATROSKA_ID_TRACKPLANE
Definition: matroska.h:85
Data found in BlockAdditional element of matroska container.
Definition: packet.h:191
#define CHILD_OF(parent)
Definition: matroskadec.c:393
#define MATROSKA_ID_VIDEOCOLORCHROMASUBHORZ
Definition: matroska.h:131
#define MATROSKA_ID_TRACKNAME
Definition: matroska.h:96
uint64_t start
Definition: matroskadec.c:315
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int nb_index_entries
Definition: avformat.h:1107
#define MATROSKA_ID_SEEKENTRY
Definition: matroska.h:217
Describe the class of an AVClass context structure.
Definition: log.h:67
EbmlList pos
Definition: matroskadec.c:285
static int mkv_parse_video_projection(AVStream *st, const MatroskaTrack *track, void *logctx)
Definition: matroskadec.c:2166
uint64_t u
Definition: matroskadec.c:104
#define MATROSKA_ID_CHAPCOUNTRY
Definition: matroska.h:257
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define MATROSKA_ID_EDITIONENTRY
Definition: matroska.h:250
int index
Definition: gxfenc.c:89
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:227
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:115
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:128
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:198
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define isnan(x)
Definition: libm.h:340
Mastering display metadata capable of representing the color volume of the display used to master the...
#define MATROSKA_ID_CUEDURATION
Definition: matroska.h:198
AVStream * stream
Definition: matroskadec.c:249
#define MATROSKA_ID_CUETIME
Definition: matroska.h:191
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
#define MATROSKA_ID_ENCODINGSIGALGO
Definition: matroska.h:182
static int matroska_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskadec.c:3757
static EbmlSyntax matroska_track_encoding_encryption[]
Definition: matroskadec.c:511
Recommmends skipping the specified number of samples.
Definition: packet.h:156
static int get_qt_codec(MatroskaTrack *track, uint32_t *fourcc, enum AVCodecID *codec_id)
Definition: matroskadec.c:2263
static int ebml_parse(MatroskaDemuxContext *matroska, EbmlSyntax *syntax, void *data)
Definition: matroskadec.c:1174
static av_always_inline void flac_parse_block_header(const uint8_t *block_header, int *last, int *type, int *size)
Parse the metadata block parameters from the header.
Definition: flac.h:145
#define MATROSKA_ID_ENCODINGSIGKEYID
Definition: matroska.h:184
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
#define MATROSKA_ID_VIDEOCOLORTRANSFERCHARACTERISTICS
Definition: matroska.h:138
void ff_packet_list_free(AVPacketList **head, AVPacketList **tail)
Wipe the list and unref all the packets in it.
Definition: utils.c:1429
static int matroska_parse_seekhead_entry(MatroskaDemuxContext *matroska, int64_t pos)
Definition: matroskadec.c:1823
#define MATROSKA_ID_TITLE
Definition: matroska.h:68
#define snprintf
Definition: snprintf.h:34
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
AVFormatContext * ctx
Definition: matroskadec.c:343
#define MATROSKA_ID_TRACKVIDEO
Definition: matroska.h:81
int64_t discard_padding
Definition: matroskadec.c:326
int size
Definition: matroskadec.c:118
This structure describes how to handle spherical videos, outlining information about projection...
Definition: spherical.h:82
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
#define MATROSKA_ID_VIDEOPROJECTION
Definition: matroska.h:156
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:144
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:93
#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE
Definition: matroska.h:158
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
mfxU16 profile
Definition: qsvenc.c:45
uint64_t field_order
Definition: matroskadec.c:196
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
int seek_preroll
Audio only.
Definition: codec_par.h:200
#define MATROSKA_ID_VIDEOFRAMERATE
Definition: matroska.h:111
int64_t end_time_ns
Definition: matroskadec.c:3859
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
#define MATROSKA_ID_ATTACHMENTS
Definition: matroska.h:61
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static EbmlSyntax ebml_syntax[3]
Definition: matroskadec.c:399
#define MATROSKA_ID_TRACKOPERATION
Definition: matroska.h:83
int64_t pos
Definition: matroskadec.c:121
#define flags(name, subs,...)
Definition: cbs_av1.c:576
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:254
MatroskaLevel1Element level1_elems[64]
Definition: matroskadec.c:381
uint8_t level
Definition: svq3.c:210
#define MATROSKA_ID_FILENAME
Definition: matroska.h:244
#define MATROSKA_ID_BLOCKADDITIONAL
Definition: matroska.h:231
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
uint32_t bound_top
Distance from the top edge.
Definition: spherical.h:168
const int avpriv_mpeg4audio_sample_rates[16]
Definition: mpeg4audio.c:62
const AVMetadataConv ff_mkv_metadata_conv[]
Definition: matroska.c:122
static int mkv_field_order(MatroskaDemuxContext *matroska, int64_t field_order)
Definition: matroskadec.c:2033
#define CONFIG_LZO
Definition: config.h:580
#define MATROSKA_ID_CODECID
Definition: matroska.h:88
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:122
static EbmlSyntax matroska_seekhead[2]
Definition: matroskadec.c:399
int sample_rate
Audio only.
Definition: codec_par.h:170
#define MATROSKA_ID_VIDEOALPHAMODE
Definition: matroska.h:124
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
int ff_packet_list_get(AVPacketList **head, AVPacketList **tail, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: utils.c:1560
A reference to a data buffer.
Definition: buffer.h:81
full parsing and repack
Definition: avformat.h:795
int64_t reference
Definition: matroskadec.c:321
void ff_rm_reorder_sipr_data(uint8_t *buf, int sub_packet_h, int framesize)
Perform 4-bit block reordering for SIPR data.
Definition: rmsipr.c:41
Main libavformat public API header.
uint64_t buf_timecode
Definition: matroskadec.c:216
static const CodecMime mkv_mime_tags[]
Definition: matroskadec.c:761
#define MATROSKA_ID_ENCODINGENCAESSETTINGS
Definition: matroska.h:179
uint64_t num
Definition: matroskadec.c:230
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:195
static EbmlSyntax matroska_track_encoding_compression[]
Definition: matroskadec.c:505
EbmlType
Definition: matroskadec.c:83
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:221
static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
Definition: matroskadec.c:799
#define MATROSKA_ID_CODECDELAY
Definition: matroska.h:94
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:252
double time_scale
Definition: matroskadec.c:237
enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
Converts swscale x/y chroma position to AVChromaLocation.
Definition: utils.c:384
#define MATROSKA_ID_VIDEOCOLORRANGE
Definition: matroska.h:137
if(ret< 0)
Definition: vf_mcdeint.c:279
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:86
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:76
raw UTF-8 text
Definition: codec_id.h:510
char * string
Definition: matroskadec.c:290
static EbmlSyntax matroska_chapters[2]
Definition: matroskadec.c:399
static double c[64]
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:147
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1618
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:929
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
AVBufferRef * buf
Definition: matroskadec.c:119
char * doctype
Definition: matroskadec.c:128
static EbmlSyntax matroska_seekhead_entry[]
Definition: matroskadec.c:683
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
int den
Denominator.
Definition: rational.h:60
static EbmlSyntax matroska_blockgroup[8]
Definition: matroskadec.c:399
#define MATROSKA_ID_ENCODINGSIGNATURE
Definition: matroska.h:185
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:53
uint32_t id
Definition: matroskadec.c:98
unsigned bps
Definition: movenc.c:1533
size_t data_offset
Definition: matroskadec.c:101
static EbmlSyntax matroska_tagtargets[]
Definition: matroskadec.c:663
MatroskaTagTarget target
Definition: matroskadec.c:305
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:202
#define MKBETAG(a, b, c, d)
Definition: common.h:407
static int ebml_read_master(MatroskaDemuxContext *matroska, uint64_t length, int64_t pos)
Definition: matroskadec.c:1031
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
#define MATROSKA_ID_SEEKHEAD
Definition: matroska.h:60
static int matroska_parse_webvtt(MatroskaDemuxContext *matroska, MatroskaTrack *track, AVStream *st, uint8_t *data, int data_len, uint64_t timecode, uint64_t duration, int64_t pos)
Definition: matroskadec.c:3321
#define EBML_ID_HEADER
Definition: matroska.h:33
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: avformat.h:1138
#define MATROSKA_ID_ENCODINGCOMPRESSION
Definition: matroska.h:174
#define MATROSKA_ID_CLUSTERPREVSIZE
Definition: matroska.h:226
#define av_free(p)
static MatroskaLevel1Element * matroska_find_level1_elem(MatroskaDemuxContext *matroska, uint32_t id, int64_t pos)
Definition: matroskadec.c:1140
char * value
Definition: dict.h:87
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:188
int len
static EbmlSyntax matroska_attachments[2]
Definition: matroskadec.c:399
#define update_pos(td, mb_y, mb_x)
Definition: vp8.c:2366
#define MATROSKA_ID_FILEUID
Definition: matroska.h:247
static int matroska_parse_block(MatroskaDemuxContext *matroska, AVBufferRef *buf, uint8_t *data, int size, int64_t pos, uint64_t cluster_time, uint64_t block_duration, int is_keyframe, uint8_t *additional, uint64_t additional_id, int additional_size, int64_t cluster_pos, int64_t discard_padding)
Definition: matroskadec.c:3553
#define MATROSKA_ID_VIDEOPIXELCROPL
Definition: matroska.h:118
void * priv_data
Format private data.
Definition: avformat.h:1379
uint64_t non_simple
Definition: matroskadec.c:322
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:262
static EbmlSyntax matroska_track_encoding[6]
Definition: matroskadec.c:399
uint32_t bound_left
Distance from the left edge.
Definition: spherical.h:167
uint64_t layout
static EbmlSyntax matroska_tag[3]
Definition: matroskadec.c:399
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
#define MATROSKA_ID_VIDEOCOLORMAXFALL
Definition: matroska.h:142
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:120
int channels
Audio only.
Definition: codec_par.h:166
static int ebml_read_uint(AVIOContext *pb, int size, uint64_t *num)
Definition: matroskadec.c:924
#define MATROSKA_ID_TRACKMAXBLKADDID
Definition: matroska.h:108
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:354
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:39
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1466
MatroskaTrackEncryption encryption
Definition: matroskadec.c:146
static EbmlSyntax * ebml_parse_id(EbmlSyntax *syntax, uint32_t id)
Definition: matroskadec.c:1072
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:255
#define MATROSKA_ID_VIDEOCOLORCBSUBHORZ
Definition: matroska.h:133
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:205
static const AVOption options[]
Definition: matroskadec.c:4268
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
#define av_malloc_array(a, b)
static EbmlSyntax matroska_index_pos[]
Definition: matroskadec.c:633
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
static int buffer_size_after_time_downloaded(int64_t time_ns, double search_sec, int64_t bps, double min_buffer, double *buffer, double *sec_to_download, AVFormatContext *s, int64_t cues_start)
Definition: matroskadec.c:3945
uint64_t transfer_characteristics
Definition: matroskadec.c:172
static int ebml_read_float(AVIOContext *pb, int size, double *num)
Definition: matroskadec.c:961
#define MATROSKA_ID_DURATION
Definition: matroska.h:67
uint64_t length
Definition: matroskadec.c:316
static int matroska_aac_profile(char *codec_id)
Definition: matroskadec.c:1951
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
int stream_index
Definition: packet.h:357
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:41
static void matroska_clear_queue(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:3037
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
#define CUES_START
Definition: matroska.h:371
#define CONFIG_BZLIB
Definition: config.h:509
#define MKTAG(a, b, c, d)
Definition: common.h:406
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:931
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1000
#define MATROSKA_ID_ATTACHEDFILE
Definition: matroska.h:242
#define MATROSKA_ID_VIDEOCOLOR_GY
Definition: matroska.h:148
#define LEVEL_ENDED
Definition: matroskadec.c:74
This structure stores compressed data.
Definition: packet.h:332
static EbmlSyntax matroska_chapter_display[]
Definition: matroskadec.c:600
#define MATROSKA_ID_CODECSTATE
Definition: matroska.h:238
uint64_t default_duration
Definition: matroskadec.c:238
AVInputFormat ff_webm_dash_manifest_demuxer
Definition: matroskadec.c:4294
#define MATROSKA_ID_VIDEOCOLOR_RY
Definition: matroska.h:146
#define MATROSKA_ID_CODECINFOURL
Definition: matroska.h:91
static EbmlSyntax matroska_cluster_enter[]
Definition: matroskadec.c:746
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:114
static void matroska_add_index_entries(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:1899
static int matroska_parse_frame(MatroskaDemuxContext *matroska, MatroskaTrack *track, AVStream *st, AVBufferRef *buf, uint8_t *data, int pkt_size, uint64_t timecode, uint64_t lace_duration, int64_t pos, int is_keyframe, uint8_t *additional, uint64_t additional_id, int additional_size, int64_t discard_padding)
Definition: matroskadec.c:3436
AVPacket attached_pic
For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet will contain the attached pictu...
Definition: avformat.h:958
#define MATROSKA_ID_TRACKAUDIO
Definition: matroska.h:82
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define av_unused
Definition: attributes.h:131
#define MATROSKA_ID_ENCODINGSCOPE
Definition: matroska.h:172
const CodecTags ff_mkv_codec_tags[]
Definition: matroska.c:29
#define MATROSKA_ID_ENCODINGENCKEYID
Definition: matroska.h:181
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define MATROSKA_ID_DISCARDPADDING
Definition: matroska.h:239
static int is_ebml_id_valid(uint32_t id)
Definition: matroskadec.c:1127
uint32_t palette[AVPALETTE_COUNT]
Definition: matroskadec.c:255
#define NEEDS_CHECKING
Definition: matroskadec.c:72
static int64_t webm_dash_manifest_compute_bandwidth(AVFormatContext *s, int64_t cues_start)
Definition: matroskadec.c:4026
static const char *const matroska_doctypes[]
Definition: matroskadec.c:771
static uint8_t tmp[11]
Definition: aes_ctr.c:26
uint64_t attachuid
Definition: matroskadec.c:301