FFmpeg
matroskadec.c
Go to the documentation of this file.
1 /*
2  * Matroska file demuxer
3  * Copyright (c) 2003-2008 The FFmpeg Project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Matroska file demuxer
25  * @author Ronald Bultje <rbultje@ronald.bitfreak.net>
26  * @author with a little help from Moritz Bunkus <moritz@bunkus.org>
27  * @author totally reworked by Aurelien Jacobs <aurel@gnuage.org>
28  * @see specs available on the Matroska project page: http://www.matroska.org/
29  */
30 
31 #include "config.h"
32 #include "config_components.h"
33 
34 #include <inttypes.h>
35 #include <stdio.h>
36 
37 #include "libavutil/avstring.h"
38 #include "libavutil/base64.h"
39 #include "libavutil/bprint.h"
40 #include "libavutil/dict.h"
42 #include "libavutil/display.h"
44 #include "libavutil/intfloat.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/lzo.h"
48 #include "libavutil/mathematics.h"
49 #include "libavutil/opt.h"
50 #include "libavutil/pixdesc.h"
52 #include "libavutil/spherical.h"
53 
54 #include "libavcodec/bytestream.h"
55 #include "libavcodec/defs.h"
56 #include "libavcodec/flac.h"
57 #include "libavcodec/mpeg4audio.h"
59 
60 #include "avformat.h"
61 #include "avio_internal.h"
62 #include "demux.h"
63 #include "dovi_isom.h"
64 #include "internal.h"
65 #include "isom.h"
66 #include "matroska.h"
67 #include "oggdec.h"
68 /* For ff_codec_get_id(). */
69 #include "riff.h"
70 #include "rmsipr.h"
71 
72 #if CONFIG_BZLIB
73 #include <bzlib.h>
74 #endif
75 #if CONFIG_ZLIB
76 #include <zlib.h>
77 #endif
78 
79 #include "qtpalette.h"
80 
81 #define EBML_UNKNOWN_LENGTH UINT64_MAX /* EBML unknown length, in uint64_t */
82 #define NEEDS_CHECKING 2 /* Indicates that some error checks
83  * still need to be performed */
84 #define LEVEL_ENDED 3 /* return value of ebml_parse when the
85  * syntax level used for parsing ended. */
86 #define SKIP_THRESHOLD 1024 * 1024 /* In non-seekable mode, if more than SKIP_THRESHOLD
87  * of unkown, potentially damaged data is encountered,
88  * it is considered an error. */
89 #define UNKNOWN_EQUIV 50 * 1024 /* An unknown element is considered equivalent
90  * to this many bytes of unknown data for the
91  * SKIP_THRESHOLD check. */
92 
93 typedef enum {
99  EBML_UTF8,
100  EBML_BIN,
102  EBML_LEVEL1,
106 
107 typedef struct CountedElement {
108  union {
109  uint64_t u;
110  int64_t i;
111  double f;
112  char *s;
113  } el;
114  unsigned count;
116 
117 typedef const struct EbmlSyntax {
118  uint32_t id;
119  uint8_t type;
120  uint8_t is_counted;
122  size_t data_offset;
123  union {
124  int64_t i;
125  uint64_t u;
126  double f;
127  const char *s;
128  const struct EbmlSyntax *n;
129  } def;
130 } EbmlSyntax;
131 
132 typedef struct EbmlList {
133  int nb_elem;
134  unsigned int alloc_elem_size;
135  void *elem;
137 
138 typedef struct EbmlBin {
139  int size;
141  uint8_t *data;
142  int64_t pos;
144 
145 typedef struct Ebml {
146  uint64_t version;
147  uint64_t max_size;
148  uint64_t id_length;
149  char *doctype;
150  uint64_t doctype_version;
151 } Ebml;
152 
153 typedef struct MatroskaTrackCompression {
154  uint64_t algo;
157 
158 typedef struct MatroskaTrackEncryption {
159  uint64_t algo;
162 
163 typedef struct MatroskaTrackEncoding {
164  uint64_t scope;
165  uint64_t type;
169 
170 typedef struct MatroskaMasteringMeta {
171  double r_x;
172  double r_y;
173  double g_x;
174  double g_y;
175  double b_x;
176  double b_y;
177  double white_x;
178  double white_y;
182 
183 typedef struct MatroskaTrackVideoColor {
186  uint64_t chroma_sub_horz;
187  uint64_t chroma_sub_vert;
188  uint64_t cb_sub_horz;
189  uint64_t cb_sub_vert;
192  uint64_t range;
193  uint64_t transfer_characteristics;
194  uint64_t primaries;
195  uint64_t max_cll;
196  uint64_t max_fall;
199 
200 typedef struct MatroskaTrackVideoProjection {
201  uint64_t type;
202  EbmlBin private;
203  double yaw;
204  double pitch;
205  double roll;
207 
208 typedef struct MatroskaTrackVideo {
209  double frame_rate;
210  uint64_t display_width;
211  uint64_t display_height;
212  uint64_t pixel_width;
213  uint64_t pixel_height;
215  uint64_t display_unit;
216  uint64_t interlaced;
217  uint64_t field_order;
218  uint64_t stereo_mode;
219  uint64_t alpha_mode;
223 
224 typedef struct MatroskaTrackAudio {
225  double samplerate;
227  uint64_t bitdepth;
228  uint64_t channels;
229 
230  /* real audio header (extracted from extradata) */
233  int frame_size;
234  int sub_packet_size;
236  int pkt_cnt;
237  uint64_t buf_timecode;
238  uint8_t *buf;
240 
241 typedef struct MatroskaTrackPlane {
242  uint64_t uid;
243  uint64_t type;
245 
246 typedef struct MatroskaTrackOperation {
249 
250 typedef struct MatroskaBlockAdditionMapping {
251  uint64_t value;
252  char *name;
253  uint64_t type;
256 
257 typedef struct MatroskaTrack {
258  uint64_t num;
259  uint64_t uid;
260  uint64_t type;
261  char *name;
262  char *codec_id;
264  char *language;
265  double time_scale;
267  uint64_t flag_default;
268  uint64_t flag_forced;
269  uint64_t flag_comment;
274  uint64_t seek_preroll;
279  uint64_t codec_delay;
281 
282  AVStream *stream;
283  int64_t end_timecode;
285  int needs_decoding;
286  uint64_t max_block_additional_id;
288 
292 
293 typedef struct MatroskaAttachment {
294  uint64_t uid;
295  char *filename;
296  char *description;
297  char *mime;
299 
302 
303 typedef struct MatroskaChapter {
304  uint64_t start;
305  uint64_t end;
306  uint64_t uid;
307  char *title;
308 
311 
312 typedef struct MatroskaIndexPos {
313  uint64_t track;
314  uint64_t pos;
316 
317 typedef struct MatroskaIndex {
318  uint64_t time;
321 
322 typedef struct MatroskaTag {
323  char *name;
324  char *string;
325  char *lang;
326  uint64_t def;
329 
330 typedef struct MatroskaTagTarget {
331  char *type;
332  uint64_t typevalue;
333  uint64_t trackuid;
334  uint64_t chapteruid;
335  uint64_t attachuid;
337 
338 typedef struct MatroskaTags {
340  EbmlList tag;
341 } MatroskaTags;
342 
343 typedef struct MatroskaSeekhead {
344  uint64_t id;
345  uint64_t pos;
347 
348 typedef struct MatroskaLevel {
349  uint64_t start;
350  uint64_t length;
351 } MatroskaLevel;
352 
353 typedef struct MatroskaBlockMore {
354  uint64_t additional_id;
357 
358 typedef struct MatroskaBlock {
359  uint64_t duration;
361  uint64_t non_simple;
365 } MatroskaBlock;
366 
367 typedef struct MatroskaCluster {
369  uint64_t timecode;
370  int64_t pos;
372 
373 typedef struct MatroskaLevel1Element {
374  int64_t pos;
375  uint32_t id;
376  int parsed;
378 
379 typedef struct MatroskaDemuxContext {
380  const AVClass *class;
382 
383  /* EBML stuff */
386  uint32_t current_id;
387  int64_t resync_pos;
389 
390  uint64_t time_scale;
391  double duration;
392  char *title;
393  char *muxingapp;
398  EbmlList index;
399  EbmlList tags;
401 
402  /* byte position of the segment inside the stream */
403  int64_t segment_start;
404 
405  /* This packet coincides with FFFormatContext.parse_pkt
406  * and is not owned by us. */
407  AVPacket *pkt;
408 
409  /* the packet queue */
411 
412  int done;
413 
414  /* What to skip before effectively reading a packet. */
415  int skip_to_keyframe;
417 
418  /* File has a CUES element, but we defer parsing until it is needed. */
420 
421  /* Level1 elements and whether they were read yet */
423  int num_level1_elems;
424 
426 
427  int is_webm;
428 
429  /* WebM DASH Manifest live flag */
430  int is_live;
431 
432  /* Bandwidth value for WebM DASH Manifest */
433  int bandwidth;
435 
436 #define CHILD_OF(parent) { .def = { .n = parent } }
437 
438 // The following forward declarations need their size because
439 // a tentative definition with internal linkage must not be an
440 // incomplete type (6.7.2 in C90, 6.9.2 in C99).
441 // Removing the sizes breaks MSVC.
448 
449 static EbmlSyntax ebml_header[] = {
450  { EBML_ID_EBMLREADVERSION, EBML_UINT, 0, 0, offsetof(Ebml, version), { .u = EBML_VERSION } },
451  { EBML_ID_EBMLMAXSIZELENGTH, EBML_UINT, 0, 0, offsetof(Ebml, max_size), { .u = 8 } },
452  { EBML_ID_EBMLMAXIDLENGTH, EBML_UINT, 0, 0, offsetof(Ebml, id_length), { .u = 4 } },
453  { EBML_ID_DOCTYPE, EBML_STR, 0, 0, offsetof(Ebml, doctype), { .s = "(none)" } },
454  { EBML_ID_DOCTYPEREADVERSION, EBML_UINT, 0, 0, offsetof(Ebml, doctype_version), { .u = 1 } },
458 };
459 
461  { EBML_ID_HEADER, EBML_NEST, 0, 0, 0, { .n = ebml_header } },
463  { 0 }
464 };
465 
466 static EbmlSyntax matroska_info[] = {
467  { MATROSKA_ID_TIMECODESCALE, EBML_UINT, 0, 0, offsetof(MatroskaDemuxContext, time_scale), { .u = 1000000 } },
469  { MATROSKA_ID_TITLE, EBML_UTF8, 0, 0, offsetof(MatroskaDemuxContext, title) },
471  { MATROSKA_ID_MUXINGAPP, EBML_UTF8, 0, 0, offsetof(MatroskaDemuxContext, muxingapp) },
472  { MATROSKA_ID_DATEUTC, EBML_BIN, 0, 0, offsetof(MatroskaDemuxContext, date_utc) },
475 };
476 
484  { MATROSKA_ID_VIDEOCOLOR_WHITEX, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, white_x) },
485  { MATROSKA_ID_VIDEOCOLOR_WHITEY, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, white_y) },
486  { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN, EBML_FLOAT, 1, 0, offsetof(MatroskaMasteringMeta, min_luminance) },
487  { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, max_luminance) },
489 };
490 
492  { MATROSKA_ID_VIDEOCOLORMATRIXCOEFF, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, matrix_coefficients), { .u = AVCOL_SPC_UNSPECIFIED } },
493  { MATROSKA_ID_VIDEOCOLORBITSPERCHANNEL, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, bits_per_channel), { .u = 0 } },
494  { MATROSKA_ID_VIDEOCOLORCHROMASUBHORZ, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, chroma_sub_horz) },
495  { MATROSKA_ID_VIDEOCOLORCHROMASUBVERT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, chroma_sub_vert) },
496  { MATROSKA_ID_VIDEOCOLORCBSUBHORZ, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, cb_sub_horz) },
497  { MATROSKA_ID_VIDEOCOLORCBSUBVERT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, cb_sub_vert) },
504  { MATROSKA_ID_VIDEOCOLORMAXFALL, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideoColor, max_fall) },
507 };
508 
512  { MATROSKA_ID_VIDEOPROJECTIONPOSEYAW, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideoProjection, yaw), { .f = 0.0 } },
513  { MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideoProjection, pitch), { .f = 0.0 } },
514  { MATROSKA_ID_VIDEOPROJECTIONPOSEROLL, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideoProjection, roll), { .f = 0.0 } },
516 };
517 
518 static EbmlSyntax matroska_track_video[] = {
519  { MATROSKA_ID_VIDEOFRAMERATE, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackVideo, frame_rate) },
520  { MATROSKA_ID_VIDEODISPLAYWIDTH, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, display_width), { .u=-1 } },
521  { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, display_height), { .u=-1 } },
522  { MATROSKA_ID_VIDEOPIXELWIDTH, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, pixel_width) },
523  { MATROSKA_ID_VIDEOPIXELHEIGHT, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, pixel_height) },
524  { MATROSKA_ID_VIDEOCOLORSPACE, EBML_BIN, 0, 0, offsetof(MatroskaTrackVideo, color_space) },
525  { MATROSKA_ID_VIDEOALPHAMODE, EBML_UINT, 0, 0, offsetof(MatroskaTrackVideo, alpha_mode), { .u = 0 } },
538 };
539 
540 static EbmlSyntax matroska_track_audio[] = {
541  { MATROSKA_ID_AUDIOSAMPLINGFREQ, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackAudio, samplerate), { .f = 8000.0 } },
542  { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, EBML_FLOAT, 0, 0, offsetof(MatroskaTrackAudio, out_samplerate) },
543  { MATROSKA_ID_AUDIOBITDEPTH, EBML_UINT, 0, 0, offsetof(MatroskaTrackAudio, bitdepth) },
544  { MATROSKA_ID_AUDIOCHANNELS, EBML_UINT, 0, 0, offsetof(MatroskaTrackAudio, channels), { .u = 1 } },
546 };
547 
552 };
553 
555  { MATROSKA_ID_ENCODINGENCALGO, EBML_UINT, 0, 0, offsetof(MatroskaTrackEncryption,algo), {.u = 0} },
563 };
565  { MATROSKA_ID_ENCODINGSCOPE, EBML_UINT, 0, 0, offsetof(MatroskaTrackEncoding, scope), { .u = 1 } },
566  { MATROSKA_ID_ENCODINGTYPE, EBML_UINT, 0, 0, offsetof(MatroskaTrackEncoding, type), { .u = 0 } },
571 };
572 
576 };
577 
578 static EbmlSyntax matroska_track_plane[] = {
582 };
583 
585  { MATROSKA_ID_TRACKPLANE, EBML_NEST, 0, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n = matroska_track_plane} },
587 };
588 
592 };
593 
600 };
601 
602 static EbmlSyntax matroska_track[] = {
603  { MATROSKA_ID_TRACKNUMBER, EBML_UINT, 0, 0, offsetof(MatroskaTrack, num) },
604  { MATROSKA_ID_TRACKNAME, EBML_UTF8, 0, 0, offsetof(MatroskaTrack, name) },
605  { MATROSKA_ID_TRACKUID, EBML_UINT, 0, 0, offsetof(MatroskaTrack, uid) },
606  { MATROSKA_ID_TRACKTYPE, EBML_UINT, 0, 0, offsetof(MatroskaTrack, type) },
607  { MATROSKA_ID_CODECID, EBML_STR, 0, 0, offsetof(MatroskaTrack, codec_id) },
608  { MATROSKA_ID_CODECPRIVATE, EBML_BIN, 0, 0, offsetof(MatroskaTrack, codec_priv) },
609  { MATROSKA_ID_CODECDELAY, EBML_UINT, 0, 0, offsetof(MatroskaTrack, codec_delay), { .u = 0 } },
610  { MATROSKA_ID_TRACKLANGUAGE, EBML_STR, 0, 0, offsetof(MatroskaTrack, language), { .s = "eng" } },
611  { MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, 0, offsetof(MatroskaTrack, default_duration) },
612  { MATROSKA_ID_TRACKTIMECODESCALE, EBML_FLOAT, 0, 0, offsetof(MatroskaTrack, time_scale), { .f = 1.0 } },
613  { MATROSKA_ID_TRACKFLAGCOMMENTARY, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_comment), { .u = 0 } },
614  { MATROSKA_ID_TRACKFLAGDEFAULT, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_default), { .u = 1 } },
615  { MATROSKA_ID_TRACKFLAGFORCED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_forced), { .u = 0 } },
616  { MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_hearingimpaired), { .u = 0 } },
617  { MATROSKA_ID_TRACKFLAGVISUALIMPAIRED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_visualimpaired), { .u = 0 } },
618  { MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_textdescriptions), { .u = 0 } },
619  { MATROSKA_ID_TRACKFLAGORIGINAL, EBML_UINT, 1, 0, offsetof(MatroskaTrack, flag_original), {.u = 0 } },
621  { MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, 0, offsetof(MatroskaTrack, audio), { .n = matroska_track_audio } },
622  { MATROSKA_ID_TRACKOPERATION, EBML_NEST, 0, 0, offsetof(MatroskaTrack, operation), { .n = matroska_track_operation } },
624  { MATROSKA_ID_TRACKMAXBLKADDID, EBML_UINT, 0, 0, offsetof(MatroskaTrack, max_block_additional_id), { .u = 0 } },
625  { MATROSKA_ID_TRACKBLKADDMAPPING, EBML_NEST, 0, sizeof(MatroskaBlockAdditionMapping), offsetof(MatroskaTrack, block_addition_mappings), { .n = matroska_block_addition_mapping } },
626  { MATROSKA_ID_SEEKPREROLL, EBML_UINT, 0, 0, offsetof(MatroskaTrack, seek_preroll), { .u = 0 } },
636 };
637 
638 static EbmlSyntax matroska_tracks[] = {
639  { MATROSKA_ID_TRACKENTRY, EBML_NEST, 0, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext, tracks), { .n = matroska_track } },
641 };
642 
643 static EbmlSyntax matroska_attachment[] = {
644  { MATROSKA_ID_FILEUID, EBML_UINT, 0, 0, offsetof(MatroskaAttachment, uid) },
645  { MATROSKA_ID_FILENAME, EBML_UTF8, 0, 0, offsetof(MatroskaAttachment, filename) },
646  { MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, 0, offsetof(MatroskaAttachment, mime) },
647  { MATROSKA_ID_FILEDATA, EBML_BIN, 0, 0, offsetof(MatroskaAttachment, bin) },
650 };
651 
652 static EbmlSyntax matroska_attachments[] = {
653  { MATROSKA_ID_ATTACHEDFILE, EBML_NEST, 0, sizeof(MatroskaAttachment), offsetof(MatroskaDemuxContext, attachments), { .n = matroska_attachment } },
655 };
656 
658  { MATROSKA_ID_CHAPSTRING, EBML_UTF8, 0, 0, offsetof(MatroskaChapter, title) },
662 };
663 
665  { MATROSKA_ID_CHAPTERTIMESTART, EBML_UINT, 0, 0, offsetof(MatroskaChapter, start), { .u = AV_NOPTS_VALUE } },
666  { MATROSKA_ID_CHAPTERTIMEEND, EBML_UINT, 0, 0, offsetof(MatroskaChapter, end), { .u = AV_NOPTS_VALUE } },
667  { MATROSKA_ID_CHAPTERUID, EBML_UINT, 0, 0, offsetof(MatroskaChapter, uid) },
674 };
675 
676 static EbmlSyntax matroska_chapter[] = {
677  { MATROSKA_ID_CHAPTERATOM, EBML_NEST, 0, sizeof(MatroskaChapter), offsetof(MatroskaDemuxContext, chapters), { .n = matroska_chapter_entry } },
683 };
684 
685 static EbmlSyntax matroska_chapters[] = {
686  { MATROSKA_ID_EDITIONENTRY, EBML_NEST, 0, 0, 0, { .n = matroska_chapter } },
688 };
689 
690 static EbmlSyntax matroska_index_pos[] = {
691  { MATROSKA_ID_CUETRACK, EBML_UINT, 0, 0, offsetof(MatroskaIndexPos, track) },
697 };
698 
699 static EbmlSyntax matroska_index_entry[] = {
700  { MATROSKA_ID_CUETIME, EBML_UINT, 0, 0, offsetof(MatroskaIndex, time) },
703 };
704 
705 static EbmlSyntax matroska_index[] = {
708 };
709 
710 static EbmlSyntax matroska_simpletag[] = {
711  { MATROSKA_ID_TAGNAME, EBML_UTF8, 0, 0, offsetof(MatroskaTag, name) },
712  { MATROSKA_ID_TAGSTRING, EBML_UTF8, 0, 0, offsetof(MatroskaTag, string) },
713  { MATROSKA_ID_TAGLANG, EBML_STR, 0, 0, offsetof(MatroskaTag, lang), { .s = "und" } },
714  { MATROSKA_ID_TAGDEFAULT, EBML_UINT, 0, 0, offsetof(MatroskaTag, def) },
715  { MATROSKA_ID_TAGDEFAULT_BUG, EBML_UINT, 0, 0, offsetof(MatroskaTag, def) },
716  { MATROSKA_ID_SIMPLETAG, EBML_NEST, 0, sizeof(MatroskaTag), offsetof(MatroskaTag, sub), { .n = matroska_simpletag } },
718 };
719 
720 static EbmlSyntax matroska_tagtargets[] = {
722  { MATROSKA_ID_TAGTARGETS_TYPEVALUE, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, typevalue), { .u = 50 } },
723  { MATROSKA_ID_TAGTARGETS_TRACKUID, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, trackuid), { .u = 0 } },
724  { MATROSKA_ID_TAGTARGETS_CHAPTERUID, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, chapteruid), { .u = 0 } },
725  { MATROSKA_ID_TAGTARGETS_ATTACHUID, EBML_UINT, 0, 0, offsetof(MatroskaTagTarget, attachuid), { .u = 0 } },
727 };
728 
729 static EbmlSyntax matroska_tag[] = {
730  { MATROSKA_ID_SIMPLETAG, EBML_NEST, 0, sizeof(MatroskaTag), offsetof(MatroskaTags, tag), { .n = matroska_simpletag } },
731  { MATROSKA_ID_TAGTARGETS, EBML_NEST, 0, 0, offsetof(MatroskaTags, target), { .n = matroska_tagtargets } },
733 };
734 
735 static EbmlSyntax matroska_tags[] = {
736  { MATROSKA_ID_TAG, EBML_NEST, 0, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext, tags), { .n = matroska_tag } },
738 };
739 
741  { MATROSKA_ID_SEEKID, EBML_UINT, 0, 0, offsetof(MatroskaSeekhead, id) },
742  { MATROSKA_ID_SEEKPOSITION, EBML_UINT, 0, 0, offsetof(MatroskaSeekhead, pos), { .u = -1 } },
744 };
745 
746 static EbmlSyntax matroska_seekhead[] = {
747  { MATROSKA_ID_SEEKENTRY, EBML_NEST, 0, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext, seekhead), { .n = matroska_seekhead_entry } },
749 };
750 
751 static EbmlSyntax matroska_segment[] = {
753  { MATROSKA_ID_INFO, EBML_LEVEL1, 0, 0, 0, { .n = matroska_info } },
754  { MATROSKA_ID_TRACKS, EBML_LEVEL1, 0, 0, 0, { .n = matroska_tracks } },
756  { MATROSKA_ID_CHAPTERS, EBML_LEVEL1, 0, 0, 0, { .n = matroska_chapters } },
757  { MATROSKA_ID_CUES, EBML_LEVEL1, 0, 0, 0, { .n = matroska_index } },
758  { MATROSKA_ID_TAGS, EBML_LEVEL1, 0, 0, 0, { .n = matroska_tags } },
759  { MATROSKA_ID_SEEKHEAD, EBML_LEVEL1, 0, 0, 0, { .n = matroska_seekhead } },
760  { 0 } /* We don't want to go back to level 0, so don't add the parent. */
761 };
762 
763 static EbmlSyntax matroska_segments[] = {
764  { MATROSKA_ID_SEGMENT, EBML_NEST, 0, 0, 0, { .n = matroska_segment } },
765  { 0 }
766 };
767 
768 static EbmlSyntax matroska_blockmore[] = {
769  { MATROSKA_ID_BLOCKADDID, EBML_UINT, 0, 0, offsetof(MatroskaBlockMore,additional_id), { .u = MATROSKA_BLOCK_ADD_ID_OPAQUE } },
770  { MATROSKA_ID_BLOCKADDITIONAL, EBML_BIN, 0, 0, offsetof(MatroskaBlockMore,additional) },
772 };
773 
775  { MATROSKA_ID_BLOCKMORE, EBML_NEST, 0, sizeof(MatroskaBlockMore), offsetof(MatroskaBlock, blockmore), { .n = matroska_blockmore } },
777 };
778 
779 static EbmlSyntax matroska_blockgroup[] = {
780  { MATROSKA_ID_BLOCK, EBML_BIN, 0, 0, offsetof(MatroskaBlock, bin) },
783  { MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, 0, offsetof(MatroskaBlock, discard_padding) },
784  { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 1, 0, offsetof(MatroskaBlock, reference) },
786  { 1, EBML_UINT, 0, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
788 };
789 
790 // The following array contains SimpleBlock and BlockGroup twice
791 // in order to reuse the other values for matroska_cluster_enter.
793  { MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, 0, offsetof(MatroskaBlock, bin) },
794  { MATROSKA_ID_BLOCKGROUP, EBML_NEST, 0, 0, 0, { .n = matroska_blockgroup } },
795  { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, 0, offsetof(MatroskaCluster, timecode) },
801 };
802 
804  { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, 0, { .n = &matroska_cluster_parsing[2] } },
805  { 0 }
806 };
807 #undef CHILD_OF
808 
809 static const CodecMime mkv_image_mime_tags[] = {
810  {"image/gif" , AV_CODEC_ID_GIF},
811  {"image/jpeg" , AV_CODEC_ID_MJPEG},
812  {"image/png" , AV_CODEC_ID_PNG},
813  {"image/tiff" , AV_CODEC_ID_TIFF},
814 
815  {"" , AV_CODEC_ID_NONE}
816 };
817 
818 static const CodecMime mkv_mime_tags[] = {
819  {"application/x-truetype-font", AV_CODEC_ID_TTF},
820  {"application/x-font" , AV_CODEC_ID_TTF},
821  {"application/vnd.ms-opentype", AV_CODEC_ID_OTF},
822  {"binary" , AV_CODEC_ID_BIN_DATA},
823 
824  {"" , AV_CODEC_ID_NONE}
825 };
826 
828  "left",
829  "right",
830  "background",
831 };
832 
833 static const char *const matroska_doctypes[] = { "matroska", "webm" };
834 
835 /*
836  * This function prepares the status for parsing of level 1 elements.
837  */
838 static int matroska_reset_status(MatroskaDemuxContext *matroska,
839  uint32_t id, int64_t position)
840 {
841  int64_t err = 0;
842  if (position >= 0) {
843  err = avio_seek(matroska->ctx->pb, position, SEEK_SET);
844  if (err > 0)
845  err = 0;
846  } else
847  position = avio_tell(matroska->ctx->pb);
848 
849  matroska->current_id = id;
850  matroska->num_levels = 1;
851  matroska->unknown_count = 0;
852  matroska->resync_pos = position;
853  if (id)
854  matroska->resync_pos -= (av_log2(id) + 7) / 8;
855 
856  return err;
857 }
858 
859 static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
860 {
861  AVIOContext *pb = matroska->ctx->pb;
862  uint32_t id;
863 
864  /* Try to seek to the last position to resync from. If this doesn't work,
865  * we resync from the earliest position available: The start of the buffer. */
866  if (last_pos < avio_tell(pb) && avio_seek(pb, last_pos + 1, SEEK_SET) < 0) {
867  av_log(matroska->ctx, AV_LOG_WARNING,
868  "Seek to desired resync point failed. Seeking to "
869  "earliest point available instead.\n");
870  avio_seek(pb, FFMAX(avio_tell(pb) + (pb->buffer - pb->buf_ptr),
871  last_pos + 1), SEEK_SET);
872  }
873 
874  id = avio_rb32(pb);
875 
876  // try to find a toplevel element
877  while (!avio_feof(pb)) {
878  if (id == MATROSKA_ID_INFO || id == MATROSKA_ID_TRACKS ||
879  id == MATROSKA_ID_CUES || id == MATROSKA_ID_TAGS ||
881  id == MATROSKA_ID_CLUSTER || id == MATROSKA_ID_CHAPTERS) {
882  /* Prepare the context for parsing of a level 1 element. */
883  matroska_reset_status(matroska, id, -1);
884  /* Given that we are here means that an error has occurred,
885  * so treat the segment as unknown length in order not to
886  * discard valid data that happens to be beyond the designated
887  * end of the segment. */
888  matroska->levels[0].length = EBML_UNKNOWN_LENGTH;
889  return 0;
890  }
891  id = (id << 8) | avio_r8(pb);
892  }
893 
894  matroska->done = 1;
895  return pb->error ? pb->error : AVERROR_EOF;
896 }
897 
898 /*
899  * Read: an "EBML number", which is defined as a variable-length
900  * array of bytes. The first byte indicates the length by giving a
901  * number of 0-bits followed by a one. The position of the first
902  * "one" bit inside the first byte indicates the length of this
903  * number.
904  * Returns: number of bytes read, < 0 on error
905  */
906 static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb,
907  int max_size, uint64_t *number, int eof_forbidden)
908 {
909  int read, n = 1;
910  uint64_t total;
911  int64_t pos;
912 
913  /* The first byte tells us the length in bytes - except when it is zero. */
914  total = avio_r8(pb);
915  if (pb->eof_reached)
916  goto err;
917 
918  /* get the length of the EBML number */
919  read = 8 - ff_log2_tab[total];
920 
921  if (!total || read > max_size) {
922  pos = avio_tell(pb) - 1;
923  if (!total) {
924  av_log(matroska->ctx, AV_LOG_ERROR,
925  "0x00 at pos %"PRId64" (0x%"PRIx64") invalid as first byte "
926  "of an EBML number\n", pos, pos);
927  } else {
928  av_log(matroska->ctx, AV_LOG_ERROR,
929  "Length %d indicated by an EBML number's first byte 0x%02x "
930  "at pos %"PRId64" (0x%"PRIx64") exceeds max length %d.\n",
931  read, (uint8_t) total, pos, pos, max_size);
932  }
933  return AVERROR_INVALIDDATA;
934  }
935 
936  /* read out length */
937  total ^= 1 << ff_log2_tab[total];
938  while (n++ < read)
939  total = (total << 8) | avio_r8(pb);
940 
941  if (pb->eof_reached) {
942  eof_forbidden = 1;
943  goto err;
944  }
945 
946  *number = total;
947 
948  return read;
949 
950 err:
951  pos = avio_tell(pb);
952  if (pb->error) {
953  av_log(matroska->ctx, AV_LOG_ERROR,
954  "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
955  pos, pos);
956  return pb->error;
957  }
958  if (eof_forbidden) {
959  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely "
960  "at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
961  return AVERROR(EIO);
962  }
963  return AVERROR_EOF;
964 }
965 
966 /**
967  * Read a EBML length value.
968  * This needs special handling for the "unknown length" case which has multiple
969  * encodings.
970  */
971 static int ebml_read_length(MatroskaDemuxContext *matroska, AVIOContext *pb,
972  uint64_t *number)
973 {
974  int res = ebml_read_num(matroska, pb, 8, number, 1);
975  if (res > 0 && *number + 1 == 1ULL << (7 * res))
976  *number = EBML_UNKNOWN_LENGTH;
977  return res;
978 }
979 
980 /*
981  * Read the next element as an unsigned int.
982  * Returns NEEDS_CHECKING unless size == 0.
983  */
984 static int ebml_read_uint(AVIOContext *pb, int size,
985  uint64_t default_value, uint64_t *num)
986 {
987  int n = 0;
988 
989  if (size == 0) {
990  *num = default_value;
991  return 0;
992  }
993  /* big-endian ordering; build up number */
994  *num = 0;
995  while (n++ < size)
996  *num = (*num << 8) | avio_r8(pb);
997 
998  return NEEDS_CHECKING;
999 }
1000 
1001 /*
1002  * Read the next element as a signed int.
1003  * Returns NEEDS_CHECKING unless size == 0.
1004  */
1005 static int ebml_read_sint(AVIOContext *pb, int size,
1006  int64_t default_value, int64_t *num)
1007 {
1008  int n = 1;
1009 
1010  if (size == 0) {
1011  *num = default_value;
1012  return 0;
1013  } else {
1014  *num = sign_extend(avio_r8(pb), 8);
1015 
1016  /* big-endian ordering; build up number */
1017  while (n++ < size)
1018  *num = ((uint64_t)*num << 8) | avio_r8(pb);
1019  }
1020 
1021  return NEEDS_CHECKING;
1023 
1024 /*
1025  * Read the next element as a float.
1026  * Returns 0 if size == 0, NEEDS_CHECKING or < 0 on obvious failure.
1027  */
1028 static int ebml_read_float(AVIOContext *pb, int size,
1029  double default_value, double *num)
1030 {
1031  if (size == 0) {
1032  *num = default_value;
1033  return 0;
1034  } else if (size == 4) {
1035  *num = av_int2float(avio_rb32(pb));
1036  } else if (size == 8) {
1037  *num = av_int2double(avio_rb64(pb));
1038  } else
1039  return AVERROR_INVALIDDATA;
1040 
1041  return NEEDS_CHECKING;
1043 
1044 /*
1045  * Read the next element as an ASCII string.
1046  * 0 is success, < 0 or NEEDS_CHECKING is failure.
1047  */
1048 static int ebml_read_ascii(AVIOContext *pb, int size,
1049  const char *default_value, char **str)
1050 {
1051  char *res;
1052  int ret;
1053 
1054  if (size == 0 && default_value) {
1055  res = av_strdup(default_value);
1056  if (!res)
1057  return AVERROR(ENOMEM);
1058  } else {
1059  /* EBML strings are usually not 0-terminated, so we allocate one
1060  * byte more, read the string and NUL-terminate it ourselves. */
1061  if (!(res = av_malloc(size + 1)))
1062  return AVERROR(ENOMEM);
1063  if ((ret = avio_read(pb, (uint8_t *) res, size)) != size) {
1064  av_free(res);
1065  return ret < 0 ? ret : NEEDS_CHECKING;
1066  }
1067  (res)[size] = '\0';
1068  }
1069  av_free(*str);
1070  *str = res;
1071 
1072  return 0;
1074 
1075 /*
1076  * Read the next element as binary data.
1077  * 0 is success, < 0 or NEEDS_CHECKING is failure.
1078  */
1079 static int ebml_read_binary(AVIOContext *pb, int length,
1080  int64_t pos, EbmlBin *bin)
1081 {
1082  int ret;
1083 
1085  if (ret < 0)
1086  return ret;
1087  memset(bin->buf->data + length, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1088 
1089  bin->data = bin->buf->data;
1090  bin->size = length;
1091  bin->pos = pos;
1092  if ((ret = avio_read(pb, bin->data, length)) != length) {
1093  av_buffer_unref(&bin->buf);
1094  bin->data = NULL;
1095  bin->size = 0;
1096  return ret < 0 ? ret : NEEDS_CHECKING;
1097  }
1098 
1099  return 0;
1100 }
1102 /*
1103  * Read the next element, but only the header. The contents
1104  * are supposed to be sub-elements which can be read separately.
1105  * 0 is success, < 0 is failure.
1106  */
1107 static int ebml_read_master(MatroskaDemuxContext *matroska,
1108  uint64_t length, int64_t pos)
1109 {
1111 
1112  if (matroska->num_levels >= EBML_MAX_DEPTH) {
1113  av_log(matroska->ctx, AV_LOG_ERROR,
1114  "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
1115  return AVERROR(ENOSYS);
1116  }
1117 
1118  level = &matroska->levels[matroska->num_levels++];
1119  level->start = pos;
1120  level->length = length;
1121 
1122  return 0;
1124 
1125 /*
1126  * Read a signed "EBML number"
1127  * Return: number of bytes processed, < 0 on error
1128  */
1129 static int matroska_ebmlnum_sint(MatroskaDemuxContext *matroska,
1130  AVIOContext *pb, int64_t *num)
1131 {
1132  uint64_t unum;
1133  int res;
1134 
1135  /* read as unsigned number first */
1136  if ((res = ebml_read_num(matroska, pb, 8, &unum, 1)) < 0)
1137  return res;
1138 
1139  /* make signed (weird way) */
1140  *num = unum - ((1LL << (7 * res - 1)) - 1);
1141 
1142  return res;
1143 }
1144 
1145 static int ebml_parse(MatroskaDemuxContext *matroska,
1146  EbmlSyntax *syntax, void *data);
1147 
1148 static EbmlSyntax *ebml_parse_id(EbmlSyntax *syntax, uint32_t id)
1149 {
1150  int i;
1151 
1152  // Whoever touches this should be aware of the duplication
1153  // existing in matroska_cluster_parsing.
1154  for (i = 0; syntax[i].id; i++)
1155  if (id == syntax[i].id)
1156  break;
1157 
1158  return &syntax[i];
1159 }
1160 
1161 static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
1162  void *data)
1163 {
1164  int res;
1165 
1166  if (data) {
1167  for (int i = 0; syntax[i].id; i++) {
1168  void *dst = (char *)data + syntax[i].data_offset;
1169  switch (syntax[i].type) {
1170  case EBML_UINT:
1171  *(uint64_t *)dst = syntax[i].def.u;
1172  break;
1173  case EBML_SINT:
1174  *(int64_t *) dst = syntax[i].def.i;
1175  break;
1176  case EBML_FLOAT:
1177  *(double *) dst = syntax[i].def.f;
1178  break;
1179  case EBML_STR:
1180  case EBML_UTF8:
1181  // the default may be NULL
1182  if (syntax[i].def.s) {
1183  *(char**)dst = av_strdup(syntax[i].def.s);
1184  if (!*(char**)dst)
1185  return AVERROR(ENOMEM);
1186  }
1187  break;
1188  }
1189  }
1190 
1191  if (!matroska->levels[matroska->num_levels - 1].length) {
1192  matroska->num_levels--;
1193  return 0;
1194  }
1195  }
1196 
1197  do {
1198  res = ebml_parse(matroska, syntax, data);
1199  } while (!res);
1200 
1201  return res == LEVEL_ENDED ? 0 : res;
1202 }
1203 
1204 static int is_ebml_id_valid(uint32_t id)
1205 {
1206  // Due to endian nonsense in Matroska, the highest byte with any bits set
1207  // will contain the leading length bit. This bit in turn identifies the
1208  // total byte length of the element by its position within the byte.
1209  unsigned int bits = av_log2(id);
1210  return id && (bits + 7) / 8 == (8 - bits % 8);
1212 
1213 /*
1214  * Allocate and return the entry for the level1 element with the given ID. If
1215  * an entry already exists, return the existing entry.
1216  */
1218  uint32_t id, int64_t pos)
1219 {
1220  int i;
1221  MatroskaLevel1Element *elem;
1222 
1223  if (!is_ebml_id_valid(id))
1224  return NULL;
1225 
1226  // Some files link to all clusters; useless.
1227  if (id == MATROSKA_ID_CLUSTER)
1228  return NULL;
1229 
1230  // There can be multiple SeekHeads and Tags.
1231  for (i = 0; i < matroska->num_level1_elems; i++) {
1232  if (matroska->level1_elems[i].id == id) {
1233  if (matroska->level1_elems[i].pos == pos ||
1234  id != MATROSKA_ID_SEEKHEAD && id != MATROSKA_ID_TAGS)
1235  return &matroska->level1_elems[i];
1236  }
1237  }
1238 
1239  // Only a completely broken file would have more elements.
1240  if (matroska->num_level1_elems >= FF_ARRAY_ELEMS(matroska->level1_elems)) {
1241  av_log(matroska->ctx, AV_LOG_ERROR, "Too many level1 elements.\n");
1242  return NULL;
1243  }
1244 
1245  elem = &matroska->level1_elems[matroska->num_level1_elems++];
1246  *elem = (MatroskaLevel1Element){.id = id};
1247 
1248  return elem;
1249 }
1250 
1251 static int ebml_parse(MatroskaDemuxContext *matroska,
1252  EbmlSyntax *syntax, void *data)
1253 {
1254  static const uint64_t max_lengths[EBML_TYPE_COUNT] = {
1255  // Forbid unknown-length EBML_NONE elements.
1257  [EBML_UINT] = 8,
1258  [EBML_SINT] = 8,
1259  [EBML_FLOAT] = 8,
1260  // max. 16 MB for strings
1261  [EBML_STR] = 0x1000000,
1262  [EBML_UTF8] = 0x1000000,
1263  // max. 256 MB for binary data
1264  [EBML_BIN] = 0x10000000,
1265  // no limits for anything else
1266  };
1267  AVIOContext *pb = matroska->ctx->pb;
1268  uint32_t id;
1269  uint64_t length;
1270  int64_t pos = avio_tell(pb), pos_alt;
1271  int res, update_pos = 1, level_check;
1272  MatroskaLevel1Element *level1_elem;
1273  MatroskaLevel *level = matroska->num_levels ? &matroska->levels[matroska->num_levels - 1] : NULL;
1274 
1275  if (!matroska->current_id) {
1276  uint64_t id;
1277  res = ebml_read_num(matroska, pb, 4, &id, 0);
1278  if (res < 0) {
1279  if (pb->eof_reached && res == AVERROR_EOF) {
1280  if (matroska->is_live)
1281  // in live mode, finish parsing if EOF is reached.
1282  return 1;
1283  if (level && pos == avio_tell(pb)) {
1284  if (level->length == EBML_UNKNOWN_LENGTH) {
1285  // Unknown-length levels automatically end at EOF.
1286  matroska->num_levels--;
1287  return LEVEL_ENDED;
1288  } else {
1289  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely "
1290  "at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
1291  }
1292  }
1293  }
1294  return res;
1295  }
1296  matroska->current_id = id | 1 << 7 * res;
1297  pos_alt = pos + res;
1298  } else {
1299  pos_alt = pos;
1300  pos -= (av_log2(matroska->current_id) + 7) / 8;
1301  }
1302 
1303  id = matroska->current_id;
1304 
1305  syntax = ebml_parse_id(syntax, id);
1306  if (!syntax->id && id != EBML_ID_VOID && id != EBML_ID_CRC32) {
1307  if (level && level->length == EBML_UNKNOWN_LENGTH) {
1308  // Unknown-length levels end when an element from an upper level
1309  // in the hierarchy is encountered.
1310  while (syntax->def.n) {
1311  syntax = ebml_parse_id(syntax->def.n, id);
1312  if (syntax->id) {
1313  matroska->num_levels--;
1314  return LEVEL_ENDED;
1315  }
1316  };
1317  }
1318 
1319  av_log(matroska->ctx, AV_LOG_DEBUG, "Unknown entry 0x%"PRIX32" at pos. "
1320  "%"PRId64"\n", id, pos);
1321  update_pos = 0; /* Don't update resync_pos as an error might have happened. */
1322  }
1323 
1324  if (data) {
1325  data = (char *) data + syntax->data_offset;
1326  if (syntax->list_elem_size) {
1327  EbmlList *list = data;
1328  void *newelem;
1329 
1330  if ((unsigned)list->nb_elem + 1 >= UINT_MAX / syntax->list_elem_size)
1331  return AVERROR(ENOMEM);
1332  newelem = av_fast_realloc(list->elem,
1333  &list->alloc_elem_size,
1334  (list->nb_elem + 1) * syntax->list_elem_size);
1335  if (!newelem)
1336  return AVERROR(ENOMEM);
1337  list->elem = newelem;
1338  data = (char *) list->elem + list->nb_elem * syntax->list_elem_size;
1339  memset(data, 0, syntax->list_elem_size);
1340  list->nb_elem++;
1341  }
1342  }
1343 
1344  if (syntax->type != EBML_STOP) {
1345  matroska->current_id = 0;
1346  if ((res = ebml_read_length(matroska, pb, &length)) < 0)
1347  return res;
1348 
1349  pos_alt += res;
1350 
1351  if (matroska->num_levels > 0) {
1352  if (length != EBML_UNKNOWN_LENGTH &&
1353  level->length != EBML_UNKNOWN_LENGTH) {
1354  uint64_t elem_end = pos_alt + length,
1355  level_end = level->start + level->length;
1356 
1357  if (elem_end < level_end) {
1358  level_check = 0;
1359  } else if (elem_end == level_end) {
1360  level_check = LEVEL_ENDED;
1361  } else {
1362  av_log(matroska->ctx, AV_LOG_ERROR,
1363  "Element at 0x%"PRIx64" ending at 0x%"PRIx64" exceeds "
1364  "containing master element ending at 0x%"PRIx64"\n",
1365  pos, elem_end, level_end);
1366  return AVERROR_INVALIDDATA;
1367  }
1368  } else if (length != EBML_UNKNOWN_LENGTH) {
1369  level_check = 0;
1370  } else if (level->length != EBML_UNKNOWN_LENGTH) {
1371  av_log(matroska->ctx, AV_LOG_ERROR, "Unknown-sized element "
1372  "at 0x%"PRIx64" inside parent with finite size\n", pos);
1373  return AVERROR_INVALIDDATA;
1374  } else {
1375  level_check = 0;
1376  if (id != MATROSKA_ID_CLUSTER && (syntax->type == EBML_LEVEL1
1377  || syntax->type == EBML_NEST)) {
1378  // According to the current specifications only clusters and
1379  // segments are allowed to be unknown-length. We also accept
1380  // other unknown-length master elements.
1381  av_log(matroska->ctx, AV_LOG_WARNING,
1382  "Found unknown-length element 0x%"PRIX32" other than "
1383  "a cluster at 0x%"PRIx64". Spec-incompliant, but "
1384  "parsing will nevertheless be attempted.\n", id, pos);
1385  update_pos = -1;
1386  }
1387  }
1388  } else
1389  level_check = 0;
1390 
1391  if (max_lengths[syntax->type] && length > max_lengths[syntax->type]) {
1392  if (length != EBML_UNKNOWN_LENGTH) {
1393  av_log(matroska->ctx, AV_LOG_ERROR,
1394  "Invalid length 0x%"PRIx64" > 0x%"PRIx64" for element "
1395  "with ID 0x%"PRIX32" at 0x%"PRIx64"\n",
1396  length, max_lengths[syntax->type], id, pos);
1397  } else if (syntax->type != EBML_NONE) {
1398  av_log(matroska->ctx, AV_LOG_ERROR,
1399  "Element with ID 0x%"PRIX32" at pos. 0x%"PRIx64" has "
1400  "unknown length, yet the length of an element of its "
1401  "type must be known.\n", id, pos);
1402  } else {
1403  av_log(matroska->ctx, AV_LOG_ERROR,
1404  "Found unknown-length element with ID 0x%"PRIX32" at "
1405  "pos. 0x%"PRIx64" for which no syntax for parsing is "
1406  "available.\n", id, pos);
1407  }
1408  return AVERROR_INVALIDDATA;
1409  }
1410 
1411  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1412  // Loosing sync will likely manifest itself as encountering unknown
1413  // elements which are not reliably distinguishable from elements
1414  // belonging to future extensions of the format.
1415  // We use a heuristic to detect such situations: If the current
1416  // element is not expected at the current syntax level and there
1417  // were only a few unknown elements in a row, then the element is
1418  // skipped or considered defective based upon the length of the
1419  // current element (i.e. how much would be skipped); if there were
1420  // more than a few skipped elements in a row and skipping the current
1421  // element would lead us more than SKIP_THRESHOLD away from the last
1422  // known good position, then it is inferred that an error occurred.
1423  // The dependency on the number of unknown elements in a row exists
1424  // because the distance to the last known good position is
1425  // automatically big if the last parsed element was big.
1426  // In both cases, each unknown element is considered equivalent to
1427  // UNKNOWN_EQUIV of skipped bytes for the check.
1428  // The whole check is only done for non-seekable output, because
1429  // in this situation skipped data can't simply be rechecked later.
1430  // This is especially important when using unkown length elements
1431  // as the check for whether a child exceeds its containing master
1432  // element is not effective in this situation.
1433  if (update_pos) {
1434  matroska->unknown_count = 0;
1435  } else {
1436  int64_t dist = length + UNKNOWN_EQUIV * matroska->unknown_count++;
1437 
1438  if (matroska->unknown_count > 3)
1439  dist += pos_alt - matroska->resync_pos;
1440 
1441  if (dist > SKIP_THRESHOLD) {
1442  av_log(matroska->ctx, AV_LOG_ERROR,
1443  "Unknown element %"PRIX32" at pos. 0x%"PRIx64" with "
1444  "length 0x%"PRIx64" considered as invalid data. Last "
1445  "known good position 0x%"PRIx64", %d unknown elements"
1446  " in a row\n", id, pos, length, matroska->resync_pos,
1447  matroska->unknown_count);
1448  return AVERROR_INVALIDDATA;
1449  }
1450  }
1451  }
1452 
1453  if (update_pos > 0) {
1454  // We have found an element that is allowed at this place
1455  // in the hierarchy and it passed all checks, so treat the beginning
1456  // of the element as the "last known good" position.
1457  matroska->resync_pos = pos;
1458  }
1459 
1460  if (!data && length != EBML_UNKNOWN_LENGTH)
1461  goto skip;
1462  }
1463 
1464  switch (syntax->type) {
1465  case EBML_UINT:
1466  res = ebml_read_uint(pb, length, syntax->def.u, data);
1467  break;
1468  case EBML_SINT:
1469  res = ebml_read_sint(pb, length, syntax->def.i, data);
1470  break;
1471  case EBML_FLOAT:
1472  res = ebml_read_float(pb, length, syntax->def.f, data);
1473  break;
1474  case EBML_STR:
1475  case EBML_UTF8:
1476  res = ebml_read_ascii(pb, length, syntax->def.s, data);
1477  break;
1478  case EBML_BIN:
1479  res = ebml_read_binary(pb, length, pos_alt, data);
1480  break;
1481  case EBML_LEVEL1:
1482  case EBML_NEST:
1483  if ((res = ebml_read_master(matroska, length, pos_alt)) < 0)
1484  return res;
1485  if (id == MATROSKA_ID_SEGMENT)
1486  matroska->segment_start = pos_alt;
1487  if (id == MATROSKA_ID_CUES)
1488  matroska->cues_parsing_deferred = 0;
1489  if (syntax->type == EBML_LEVEL1 &&
1490  (level1_elem = matroska_find_level1_elem(matroska, syntax->id, pos))) {
1491  if (!level1_elem->pos) {
1492  // Zero is not a valid position for a level 1 element.
1493  level1_elem->pos = pos;
1494  } else if (level1_elem->pos != pos)
1495  av_log(matroska->ctx, AV_LOG_ERROR, "Duplicate element\n");
1496  level1_elem->parsed = 1;
1497  }
1498  if (res = ebml_parse_nest(matroska, syntax->def.n, data))
1499  return res;
1500  break;
1501  case EBML_STOP:
1502  return 1;
1503  skip:
1504  default:
1505  if (length) {
1506  int64_t res2;
1507  if (ffio_limit(pb, length) != length) {
1508  // ffio_limit emits its own error message,
1509  // so we don't have to.
1510  return AVERROR(EIO);
1511  }
1512  if ((res2 = avio_skip(pb, length - 1)) >= 0) {
1513  // avio_skip might take us past EOF. We check for this
1514  // by skipping only length - 1 bytes, reading a byte and
1515  // checking the error flags. This is done in order to check
1516  // that the element has been properly skipped even when
1517  // no filesize (that ffio_limit relies on) is available.
1518  avio_r8(pb);
1519  res = NEEDS_CHECKING;
1520  } else
1521  res = res2;
1522  } else
1523  res = 0;
1524  }
1525  if (res) {
1526  if (res == NEEDS_CHECKING) {
1527  if (pb->eof_reached) {
1528  if (pb->error)
1529  res = pb->error;
1530  else
1531  res = AVERROR_EOF;
1532  } else
1533  goto level_check;
1534  }
1535 
1536  if (res == AVERROR_INVALIDDATA)
1537  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
1538  else if (res == AVERROR(EIO))
1539  av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
1540  else if (res == AVERROR_EOF) {
1541  av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely\n");
1542  res = AVERROR(EIO);
1543  }
1544 
1545  return res;
1546  }
1547 
1548 level_check:
1549  if (syntax->is_counted && data) {
1550  CountedElement *elem = data;
1551  if (elem->count != UINT_MAX)
1552  elem->count++;
1553  }
1554 
1555  if (level_check == LEVEL_ENDED && matroska->num_levels) {
1556  level = &matroska->levels[matroska->num_levels - 1];
1557  pos = avio_tell(pb);
1558 
1559  // Given that pos >= level->start no check for
1560  // level->length != EBML_UNKNOWN_LENGTH is necessary.
1561  while (matroska->num_levels && pos == level->start + level->length) {
1562  matroska->num_levels--;
1563  level--;
1564  }
1565  }
1566 
1567  return level_check;
1568 }
1569 
1570 static void ebml_free(EbmlSyntax *syntax, void *data)
1571 {
1572  int i, j;
1573  for (i = 0; syntax[i].id; i++) {
1574  void *data_off = (char *) data + syntax[i].data_offset;
1575  switch (syntax[i].type) {
1576  case EBML_STR:
1577  case EBML_UTF8:
1578  av_freep(data_off);
1579  break;
1580  case EBML_BIN:
1581  av_buffer_unref(&((EbmlBin *) data_off)->buf);
1582  break;
1583  case EBML_LEVEL1:
1584  case EBML_NEST:
1585  if (syntax[i].list_elem_size) {
1586  EbmlList *list = data_off;
1587  char *ptr = list->elem;
1588  for (j = 0; j < list->nb_elem;
1589  j++, ptr += syntax[i].list_elem_size)
1590  ebml_free(syntax[i].def.n, ptr);
1591  av_freep(&list->elem);
1592  list->nb_elem = 0;
1593  list->alloc_elem_size = 0;
1594  } else
1595  ebml_free(syntax[i].def.n, data_off);
1596  default:
1597  break;
1598  }
1599  }
1600 }
1601 
1602 /*
1603  * Autodetecting...
1604  */
1605 static int matroska_probe(const AVProbeData *p)
1606 {
1607  uint64_t total = 0;
1608  int len_mask = 0x80, size = 1, n = 1, i;
1609 
1610  /* EBML header? */
1611  if (AV_RB32(p->buf) != EBML_ID_HEADER)
1612  return 0;
1613 
1614  /* length of header */
1615  total = p->buf[4];
1616  while (size <= 8 && !(total & len_mask)) {
1617  size++;
1618  len_mask >>= 1;
1619  }
1620  if (size > 8)
1621  return 0;
1622  total &= (len_mask - 1);
1623  while (n < size)
1624  total = (total << 8) | p->buf[4 + n++];
1625 
1626  if (total + 1 == 1ULL << (7 * size)){
1627  /* Unknown-length header - simply parse the whole buffer. */
1628  total = p->buf_size - 4 - size;
1629  } else {
1630  /* Does the probe data contain the whole header? */
1631  if (p->buf_size < 4 + size + total)
1632  return 0;
1633  }
1634 
1635  /* The header should contain a known document type. For now,
1636  * we don't parse the whole header but simply check for the
1637  * availability of that array of characters inside the header.
1638  * Not fully fool-proof, but good enough. */
1639  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++) {
1640  size_t probelen = strlen(matroska_doctypes[i]);
1641  if (total < probelen)
1642  continue;
1643  for (n = 4 + size; n <= 4 + size + total - probelen; n++)
1644  if (!memcmp(p->buf + n, matroska_doctypes[i], probelen))
1645  return AVPROBE_SCORE_MAX;
1646  }
1647 
1648  // probably valid EBML header but no recognized doctype
1649  return AVPROBE_SCORE_EXTENSION;
1650 }
1651 
1653  uint64_t num)
1654 {
1655  MatroskaTrack *tracks = matroska->tracks.elem;
1656  int i;
1657 
1658  for (i = 0; i < matroska->tracks.nb_elem; i++)
1659  if (tracks[i].num == num)
1660  return &tracks[i];
1661 
1662  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %"PRIu64"\n", num);
1663  return NULL;
1664 }
1665 
1666 static int matroska_decode_buffer(uint8_t **buf, int *buf_size,
1667  MatroskaTrack *track)
1668 {
1669  MatroskaTrackEncoding *encodings = track->encodings.elem;
1670  uint8_t *data = *buf;
1671  int isize = *buf_size;
1672  uint8_t *pkt_data = NULL;
1673  uint8_t av_unused *newpktdata;
1674  int pkt_size = isize;
1675  int result = 0;
1676  int olen;
1677 
1678  if (pkt_size >= 10000000U)
1679  return AVERROR_INVALIDDATA;
1680 
1681  switch (encodings[0].compression.algo) {
1683  {
1684  int header_size = encodings[0].compression.settings.size;
1685  uint8_t *header = encodings[0].compression.settings.data;
1686 
1687  if (header_size && !header) {
1688  av_log(NULL, AV_LOG_ERROR, "Compression size but no data in headerstrip\n");
1689  return -1;
1690  }
1691 
1692  if (!header_size)
1693  return 0;
1694 
1695  pkt_size = isize + header_size;
1696  pkt_data = av_malloc(pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1697  if (!pkt_data)
1698  return AVERROR(ENOMEM);
1699 
1700  memcpy(pkt_data, header, header_size);
1701  memcpy(pkt_data + header_size, data, isize);
1702  break;
1703  }
1705  do {
1706  int insize = isize;
1707  olen = pkt_size *= 3;
1708  newpktdata = av_realloc(pkt_data, pkt_size + AV_LZO_OUTPUT_PADDING
1710  if (!newpktdata) {
1711  result = AVERROR(ENOMEM);
1712  goto failed;
1713  }
1714  pkt_data = newpktdata;
1715  result = av_lzo1x_decode(pkt_data, &olen, data, &insize);
1716  } while (result == AV_LZO_OUTPUT_FULL && pkt_size < 10000000);
1717  if (result) {
1719  goto failed;
1720  }
1721  pkt_size -= olen;
1722  break;
1723 #if CONFIG_ZLIB
1725  {
1726  z_stream zstream = { 0 };
1727  if (!pkt_size || inflateInit(&zstream) != Z_OK)
1728  return -1;
1729  zstream.next_in = data;
1730  zstream.avail_in = isize;
1731  do {
1732  pkt_size *= 3;
1733  newpktdata = av_realloc(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1734  if (!newpktdata) {
1735  inflateEnd(&zstream);
1736  result = AVERROR(ENOMEM);
1737  goto failed;
1738  }
1739  pkt_data = newpktdata;
1740  zstream.avail_out = pkt_size - zstream.total_out;
1741  zstream.next_out = pkt_data + zstream.total_out;
1742  result = inflate(&zstream, Z_NO_FLUSH);
1743  } while (result == Z_OK && pkt_size < 10000000);
1744  pkt_size = zstream.total_out;
1745  inflateEnd(&zstream);
1746  if (result != Z_STREAM_END) {
1747  if (result == Z_MEM_ERROR)
1748  result = AVERROR(ENOMEM);
1749  else
1751  goto failed;
1752  }
1753  break;
1754  }
1755 #endif
1756 #if CONFIG_BZLIB
1758  {
1759  bz_stream bzstream = { 0 };
1760  if (!pkt_size || BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
1761  return -1;
1762  bzstream.next_in = data;
1763  bzstream.avail_in = isize;
1764  do {
1765  pkt_size *= 3;
1766  newpktdata = av_realloc(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE);
1767  if (!newpktdata) {
1768  BZ2_bzDecompressEnd(&bzstream);
1769  result = AVERROR(ENOMEM);
1770  goto failed;
1771  }
1772  pkt_data = newpktdata;
1773  bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
1774  bzstream.next_out = pkt_data + bzstream.total_out_lo32;
1775  result = BZ2_bzDecompress(&bzstream);
1776  } while (result == BZ_OK && pkt_size < 10000000);
1777  pkt_size = bzstream.total_out_lo32;
1778  BZ2_bzDecompressEnd(&bzstream);
1779  if (result != BZ_STREAM_END) {
1780  if (result == BZ_MEM_ERROR)
1781  result = AVERROR(ENOMEM);
1782  else
1784  goto failed;
1785  }
1786  break;
1787  }
1788 #endif
1789  default:
1790  return AVERROR_INVALIDDATA;
1791  }
1792 
1793  memset(pkt_data + pkt_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1794 
1795  *buf = pkt_data;
1796  *buf_size = pkt_size;
1797  return 0;
1799 failed:
1800  av_free(pkt_data);
1801  return result;
1802 }
1803 
1805  AVDictionary **metadata, char *prefix)
1806 {
1807  MatroskaTag *tags = list->elem;
1808  char key[1024];
1809  int i;
1810 
1811  for (i = 0; i < list->nb_elem; i++) {
1812  const char *lang = tags[i].lang &&
1813  strcmp(tags[i].lang, "und") ? tags[i].lang : NULL;
1814 
1815  if (!tags[i].name) {
1816  av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no TagName.\n");
1817  continue;
1818  }
1819  if (prefix)
1820  snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
1821  else
1822  av_strlcpy(key, tags[i].name, sizeof(key));
1823  if (tags[i].def || !lang) {
1824  av_dict_set(metadata, key, tags[i].string, 0);
1825  if (tags[i].sub.nb_elem)
1826  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1827  }
1828  if (lang) {
1829  av_strlcat(key, "-", sizeof(key));
1830  av_strlcat(key, lang, sizeof(key));
1831  av_dict_set(metadata, key, tags[i].string, 0);
1832  if (tags[i].sub.nb_elem)
1833  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1834  }
1835  }
1837 }
1838 
1840 {
1841  MatroskaDemuxContext *matroska = s->priv_data;
1842  MatroskaTags *tags = matroska->tags.elem;
1843  int i, j;
1844 
1845  for (i = 0; i < matroska->tags.nb_elem; i++) {
1846  if (tags[i].target.attachuid) {
1847  MatroskaAttachment *attachment = matroska->attachments.elem;
1848  int found = 0;
1849  for (j = 0; j < matroska->attachments.nb_elem; j++) {
1850  if (attachment[j].uid == tags[i].target.attachuid &&
1851  attachment[j].stream) {
1852  matroska_convert_tag(s, &tags[i].tag,
1853  &attachment[j].stream->metadata, NULL);
1854  found = 1;
1855  }
1856  }
1857  if (!found) {
1859  "The tags at index %d refer to a "
1860  "non-existent attachment %"PRId64".\n",
1861  i, tags[i].target.attachuid);
1862  }
1863  } else if (tags[i].target.chapteruid) {
1864  MatroskaChapter *chapter = matroska->chapters.elem;
1865  int found = 0;
1866  for (j = 0; j < matroska->chapters.nb_elem; j++) {
1867  if (chapter[j].uid == tags[i].target.chapteruid &&
1868  chapter[j].chapter) {
1869  matroska_convert_tag(s, &tags[i].tag,
1870  &chapter[j].chapter->metadata, NULL);
1871  found = 1;
1872  }
1873  }
1874  if (!found) {
1876  "The tags at index %d refer to a non-existent chapter "
1877  "%"PRId64".\n",
1878  i, tags[i].target.chapteruid);
1879  }
1880  } else if (tags[i].target.trackuid) {
1881  MatroskaTrack *track = matroska->tracks.elem;
1882  int found = 0;
1883  for (j = 0; j < matroska->tracks.nb_elem; j++) {
1884  if (track[j].uid == tags[i].target.trackuid &&
1885  track[j].stream) {
1886  matroska_convert_tag(s, &tags[i].tag,
1887  &track[j].stream->metadata, NULL);
1888  found = 1;
1889  }
1890  }
1891  if (!found) {
1893  "The tags at index %d refer to a non-existent track "
1894  "%"PRId64".\n",
1895  i, tags[i].target.trackuid);
1896  }
1897  } else {
1898  matroska_convert_tag(s, &tags[i].tag, &s->metadata,
1899  tags[i].target.type);
1900  }
1901  }
1902 }
1903 
1905  int64_t pos)
1906 {
1907  uint32_t saved_id = matroska->current_id;
1908  int64_t before_pos = avio_tell(matroska->ctx->pb);
1909  int ret = 0;
1910  int ret2;
1911 
1912  /* seek */
1913  if (avio_seek(matroska->ctx->pb, pos, SEEK_SET) == pos) {
1914  /* We don't want to lose our seekhead level, so we add
1915  * a dummy. This is a crude hack. */
1916  if (matroska->num_levels == EBML_MAX_DEPTH) {
1917  av_log(matroska->ctx, AV_LOG_INFO,
1918  "Max EBML element depth (%d) reached, "
1919  "cannot parse further.\n", EBML_MAX_DEPTH);
1921  } else {
1922  matroska->levels[matroska->num_levels] = (MatroskaLevel) { 0, EBML_UNKNOWN_LENGTH };
1923  matroska->num_levels++;
1924  matroska->current_id = 0;
1925 
1926  ret = ebml_parse(matroska, matroska_segment, matroska);
1927  if (ret == LEVEL_ENDED) {
1928  /* This can only happen if the seek brought us beyond EOF. */
1929  ret = AVERROR_EOF;
1930  }
1931  }
1932  }
1933  /* Seek back - notice that in all instances where this is used
1934  * it is safe to set the level to 1. */
1935  ret2 = matroska_reset_status(matroska, saved_id, before_pos);
1936  if (ret >= 0)
1937  ret = ret2;
1938 
1939  return ret;
1940 }
1941 
1942 static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
1943 {
1944  EbmlList *seekhead_list = &matroska->seekhead;
1945  int i;
1946 
1947  // we should not do any seeking in the streaming case
1948  if (!(matroska->ctx->pb->seekable & AVIO_SEEKABLE_NORMAL))
1949  return;
1950 
1951  for (i = 0; i < seekhead_list->nb_elem; i++) {
1952  MatroskaSeekhead *seekheads = seekhead_list->elem;
1953  uint32_t id = seekheads[i].id;
1954  int64_t pos = seekheads[i].pos + matroska->segment_start;
1955  MatroskaLevel1Element *elem;
1956 
1957  if (id != seekheads[i].id || pos < matroska->segment_start)
1958  continue;
1959 
1960  elem = matroska_find_level1_elem(matroska, id, pos);
1961  if (!elem || elem->parsed)
1962  continue;
1963 
1964  elem->pos = pos;
1965 
1966  // defer cues parsing until we actually need cue data.
1967  if (id == MATROSKA_ID_CUES)
1968  continue;
1969 
1970  if (matroska_parse_seekhead_entry(matroska, pos) < 0) {
1971  // mark index as broken
1972  matroska->cues_parsing_deferred = -1;
1973  break;
1974  }
1975 
1976  elem->parsed = 1;
1977  }
1978 }
1979 
1980 static void matroska_add_index_entries(MatroskaDemuxContext *matroska)
1981 {
1982  EbmlList *index_list;
1984  uint64_t index_scale = 1;
1985  int i, j;
1986 
1987  if (matroska->ctx->flags & AVFMT_FLAG_IGNIDX)
1988  return;
1989 
1990  index_list = &matroska->index;
1991  index = index_list->elem;
1992  if (index_list->nb_elem < 2)
1993  return;
1994  if (index[1].time > 1E14 / matroska->time_scale) {
1995  av_log(matroska->ctx, AV_LOG_WARNING, "Dropping apparently-broken index.\n");
1996  return;
1997  }
1998  for (i = 0; i < index_list->nb_elem; i++) {
1999  EbmlList *pos_list = &index[i].pos;
2000  MatroskaIndexPos *pos = pos_list->elem;
2001  for (j = 0; j < pos_list->nb_elem; j++) {
2002  MatroskaTrack *track = matroska_find_track_by_num(matroska,
2003  pos[j].track);
2004  if (track && track->stream)
2005  av_add_index_entry(track->stream,
2006  pos[j].pos + matroska->segment_start,
2007  index[i].time / index_scale, 0, 0,
2009  }
2010  }
2011 }
2012 
2013 static void matroska_parse_cues(MatroskaDemuxContext *matroska) {
2014  int i;
2015 
2016  if (matroska->ctx->flags & AVFMT_FLAG_IGNIDX)
2017  return;
2018 
2019  for (i = 0; i < matroska->num_level1_elems; i++) {
2020  MatroskaLevel1Element *elem = &matroska->level1_elems[i];
2021  if (elem->id == MATROSKA_ID_CUES && !elem->parsed) {
2022  if (matroska_parse_seekhead_entry(matroska, elem->pos) < 0)
2023  matroska->cues_parsing_deferred = -1;
2024  elem->parsed = 1;
2025  break;
2026  }
2027  }
2028 
2029  matroska_add_index_entries(matroska);
2030 }
2031 
2033  unsigned nb_encodings,
2034  MatroskaTrack *track,
2035  char **key_id_base64, void *logctx)
2036 {
2037  if (nb_encodings > 1) {
2038  av_log(logctx, AV_LOG_ERROR,
2039  "Multiple combined encodings not supported\n");
2040  return 0;
2041  }
2042  if (!nb_encodings)
2043  return 0;
2044  if (encodings->type) {
2045  if (encodings->encryption.key_id.size > 0) {
2046  /* Save the encryption key id to be stored later
2047  * as a metadata tag. */
2048  const int b64_size = AV_BASE64_SIZE(encodings->encryption.key_id.size);
2049  *key_id_base64 = av_malloc(b64_size);
2050  if (!*key_id_base64)
2051  return AVERROR(ENOMEM);
2052 
2053  av_base64_encode(*key_id_base64, b64_size,
2054  encodings->encryption.key_id.data,
2055  encodings->encryption.key_id.size);
2056  } else {
2057  encodings->scope = 0;
2058  av_log(logctx, AV_LOG_ERROR, "Unsupported encoding type\n");
2059  }
2060  } else if (
2061 #if CONFIG_ZLIB
2063 #endif
2064 #if CONFIG_BZLIB
2066 #endif
2069  encodings->scope = 0;
2070  av_log(logctx, AV_LOG_ERROR, "Unsupported encoding type\n");
2071  } else if (track->codec_priv.size && encodings[0].scope & 2) {
2072  uint8_t *codec_priv = track->codec_priv.data;
2073  int ret = matroska_decode_buffer(&track->codec_priv.data,
2074  &track->codec_priv.size,
2075  track);
2076  if (ret < 0) {
2077  track->codec_priv.data = NULL;
2078  track->codec_priv.size = 0;
2079  av_log(logctx, AV_LOG_ERROR,
2080  "Failed to decode codec private data\n");
2081  }
2082 
2083  if (codec_priv != track->codec_priv.data) {
2084  av_buffer_unref(&track->codec_priv.buf);
2085  if (track->codec_priv.data) {
2086  track->codec_priv.buf = av_buffer_create(track->codec_priv.data,
2088  NULL, NULL, 0);
2089  if (!track->codec_priv.buf) {
2090  av_freep(&track->codec_priv.data);
2091  track->codec_priv.size = 0;
2092  return AVERROR(ENOMEM);
2093  }
2094  }
2095  }
2096  }
2097  track->needs_decoding = !encodings->type &&
2098  encodings->scope & 1 &&
2099  (encodings->compression.algo !=
2101  encodings->compression.settings.size);
2102 
2103  return 0;
2104 }
2105 
2106 static int matroska_aac_profile(char *codec_id)
2107 {
2108  static const char *const aac_profiles[] = { "MAIN", "LC", "SSR" };
2109  int profile;
2110 
2112  if (strstr(codec_id, aac_profiles[profile]))
2113  break;
2114  return profile + 1;
2115 }
2116 
2117 static int matroska_aac_sri(int samplerate)
2118 {
2119  int sri;
2120 
2121  for (sri = 0; sri < FF_ARRAY_ELEMS(ff_mpeg4audio_sample_rates); sri++)
2122  if (ff_mpeg4audio_sample_rates[sri] == samplerate)
2123  break;
2124  return sri;
2125 }
2126 
2127 static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
2128 {
2129  /* Convert to seconds and adjust by number of seconds between 2001-01-01 and Epoch */
2130  avpriv_dict_set_timestamp(metadata, "creation_time", date_utc / 1000 + 978307200000000LL);
2131 }
2132 
2134  MatroskaTrack *track,
2135  int *offset)
2136 {
2137  AVStream *st = track->stream;
2138  uint8_t *p = track->codec_priv.data;
2139  int size = track->codec_priv.size;
2140 
2141  if (size < 8 + FLAC_STREAMINFO_SIZE || p[4] & 0x7f) {
2142  av_log(s, AV_LOG_WARNING, "Invalid FLAC private data\n");
2143  track->codec_priv.size = 0;
2144  return 0;
2145  }
2146  *offset = 8;
2147  track->codec_priv.size = 8 + FLAC_STREAMINFO_SIZE;
2148 
2149  p += track->codec_priv.size;
2150  size -= track->codec_priv.size;
2151 
2152  /* parse the remaining metadata blocks if present */
2153  while (size >= 4) {
2154  int block_last, block_type, block_size;
2155 
2156  flac_parse_block_header(p, &block_last, &block_type, &block_size);
2157 
2158  p += 4;
2159  size -= 4;
2160  if (block_size > size)
2161  return 0;
2162 
2163  /* check for the channel mask */
2164  if (block_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
2165  AVDictionary *dict = NULL;
2166  AVDictionaryEntry *chmask;
2167 
2168  ff_vorbis_comment(s, &dict, p, block_size, 0);
2169  chmask = av_dict_get(dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);
2170  if (chmask) {
2171  uint64_t mask = strtol(chmask->value, NULL, 0);
2172  if (!mask || mask & ~0x3ffffULL) {
2174  "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
2175  } else
2177  }
2178  av_dict_free(&dict);
2179  }
2180 
2181  p += block_size;
2182  size -= block_size;
2183  }
2184 
2185  return 0;
2186 }
2187 
2188 static int mkv_field_order(const MatroskaDemuxContext *matroska, uint64_t field_order)
2189 {
2190  int minor, micro, bttb = 0;
2191 
2192  /* workaround a bug in our Matroska muxer, introduced in version 57.36 alongside
2193  * this function, and fixed in 57.52 */
2194  if (matroska->muxingapp && sscanf(matroska->muxingapp, "Lavf57.%d.%d", &minor, &micro) == 2)
2195  bttb = (minor >= 36 && minor <= 51 && micro >= 100);
2196 
2197  switch (field_order) {
2199  return AV_FIELD_PROGRESSIVE;
2201  return AV_FIELD_UNKNOWN;
2203  return AV_FIELD_TT;
2205  return AV_FIELD_BB;
2207  return bttb ? AV_FIELD_TB : AV_FIELD_BT;
2209  return bttb ? AV_FIELD_BT : AV_FIELD_TB;
2210  default:
2211  return AV_FIELD_UNKNOWN;
2212  }
2213 }
2214 
2215 static void mkv_stereo_mode_display_mul(int stereo_mode,
2216  int *h_width, int *h_height)
2217 {
2218  switch (stereo_mode) {
2224  break;
2229  *h_width = 2;
2230  break;
2235  *h_height = 2;
2236  break;
2237  }
2238 }
2239 
2240 static int mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
2241 {
2242  static const struct {
2243  char type;
2244  char flags;
2245  } stereo_mode_conv [] = {
2246 #define STEREO_MODE_CONV(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM) \
2247  [(STEREOMODETYPE)] = { .type = (STEREO3DTYPE), .flags = (FLAGS) },
2248 #define NOTHING(STEREOMODETYPE, WDIV, HDIV, WEBM)
2250  };
2251  AVStereo3D *stereo;
2252 
2253  stereo = av_stereo3d_alloc();
2254  if (!stereo)
2255  return AVERROR(ENOMEM);
2256 
2257  stereo->type = stereo_mode_conv[stereo_mode].type;
2258  stereo->flags = stereo_mode_conv[stereo_mode].flags;
2259 
2261  AV_PKT_DATA_STEREO3D, stereo, sizeof(*stereo), 0)) {
2262  av_freep(&stereo);
2263  return AVERROR(ENOMEM);
2264  }
2265 
2266  return 0;
2267 }
2268 
2269 static int mkv_parse_video_color(AVStream *st, const MatroskaTrack *track) {
2270  const MatroskaTrackVideoColor *color = track->video.color.elem;
2271  const MatroskaMasteringMeta *mastering_meta;
2272  int has_mastering_primaries, has_mastering_luminance;
2273 
2274  if (!track->video.color.nb_elem)
2275  return 0;
2276 
2277  mastering_meta = &color->mastering_meta;
2278  // Mastering primaries are CIE 1931 coords, and must be > 0.
2279  has_mastering_primaries =
2280  mastering_meta->r_x > 0 && mastering_meta->r_y > 0 &&
2281  mastering_meta->g_x > 0 && mastering_meta->g_y > 0 &&
2282  mastering_meta->b_x > 0 && mastering_meta->b_y > 0 &&
2283  mastering_meta->white_x > 0 && mastering_meta->white_y > 0;
2284  has_mastering_luminance = mastering_meta->max_luminance >
2285  mastering_meta->min_luminance.el.f &&
2286  mastering_meta->min_luminance.el.f >= 0 &&
2287  mastering_meta->min_luminance.count;
2288 
2289  if (color->matrix_coefficients != AVCOL_SPC_RESERVED)
2290  st->codecpar->color_space = color->matrix_coefficients;
2291  if (color->primaries != AVCOL_PRI_RESERVED &&
2292  color->primaries != AVCOL_PRI_RESERVED0)
2293  st->codecpar->color_primaries = color->primaries;
2294  if (color->transfer_characteristics != AVCOL_TRC_RESERVED &&
2295  color->transfer_characteristics != AVCOL_TRC_RESERVED0)
2296  st->codecpar->color_trc = color->transfer_characteristics;
2297  if (color->range != AVCOL_RANGE_UNSPECIFIED &&
2298  color->range <= AVCOL_RANGE_JPEG)
2299  st->codecpar->color_range = color->range;
2300  if (color->chroma_siting_horz != MATROSKA_COLOUR_CHROMASITINGHORZ_UNDETERMINED &&
2301  color->chroma_siting_vert != MATROSKA_COLOUR_CHROMASITINGVERT_UNDETERMINED &&
2302  color->chroma_siting_horz < MATROSKA_COLOUR_CHROMASITINGHORZ_NB &&
2303  color->chroma_siting_vert < MATROSKA_COLOUR_CHROMASITINGVERT_NB) {
2304  st->codecpar->chroma_location =
2305  av_chroma_location_pos_to_enum((color->chroma_siting_horz - 1) << 7,
2306  (color->chroma_siting_vert - 1) << 7);
2307  }
2308  if (color->max_cll && color->max_fall) {
2309  size_t size = 0;
2311  if (!metadata)
2312  return AVERROR(ENOMEM);
2314  AV_PKT_DATA_CONTENT_LIGHT_LEVEL, metadata, size, 0)) {
2315  av_freep(&metadata);
2316  return AVERROR(ENOMEM);
2317  }
2318  metadata->MaxCLL = color->max_cll;
2319  metadata->MaxFALL = color->max_fall;
2320  }
2321 
2322  if (has_mastering_primaries || has_mastering_luminance) {
2323  AVMasteringDisplayMetadata *metadata;
2327  sizeof(AVMasteringDisplayMetadata), 0);
2328  if (!sd)
2329  return AVERROR(ENOMEM);
2330  metadata = (AVMasteringDisplayMetadata*)sd->data;
2331  memset(metadata, 0, sizeof(AVMasteringDisplayMetadata));
2332  if (has_mastering_primaries) {
2333  metadata->display_primaries[0][0] = av_d2q(mastering_meta->r_x, INT_MAX);
2334  metadata->display_primaries[0][1] = av_d2q(mastering_meta->r_y, INT_MAX);
2335  metadata->display_primaries[1][0] = av_d2q(mastering_meta->g_x, INT_MAX);
2336  metadata->display_primaries[1][1] = av_d2q(mastering_meta->g_y, INT_MAX);
2337  metadata->display_primaries[2][0] = av_d2q(mastering_meta->b_x, INT_MAX);
2338  metadata->display_primaries[2][1] = av_d2q(mastering_meta->b_y, INT_MAX);
2339  metadata->white_point[0] = av_d2q(mastering_meta->white_x, INT_MAX);
2340  metadata->white_point[1] = av_d2q(mastering_meta->white_y, INT_MAX);
2341  metadata->has_primaries = 1;
2342  }
2343  if (has_mastering_luminance) {
2344  metadata->max_luminance = av_d2q(mastering_meta->max_luminance, INT_MAX);
2345  metadata->min_luminance = av_d2q(mastering_meta->min_luminance.el.f, INT_MAX);
2346  metadata->has_luminance = 1;
2347  }
2348  }
2349  return 0;
2350 }
2351 
2352 static int mkv_create_display_matrix(AVStream *st,
2353  const MatroskaTrackVideoProjection *proj,
2354  void *logctx)
2355 {
2356  AVPacketSideData *sd;
2357  double pitch = proj->pitch, yaw = proj->yaw, roll = proj->roll;
2358  int32_t *matrix;
2359  int hflip;
2360 
2361  if (pitch == 0.0 && yaw == 0.0 && roll == 0.0)
2362  return 0;
2363 
2364  /* Note: The following constants are exactly representable
2365  * as floating-point numbers. */
2366  if (pitch != 0.0 || (yaw != 0.0 && yaw != 180.0 && yaw != -180.0) ||
2367  isnan(roll)) {
2368  av_log(logctx, AV_LOG_WARNING, "Ignoring non-2D rectangular "
2369  "projection in stream %u (yaw %f, pitch %f, roll %f)\n",
2370  st->index, yaw, pitch, roll);
2371  return 0;
2372  }
2376  9 * sizeof(*matrix), 0);
2377  if (!sd)
2378  return AVERROR(ENOMEM);
2379  matrix = (int32_t*)sd->data;
2380 
2381  hflip = yaw != 0.0;
2382  /* ProjectionPoseRoll is in the counter-clockwise direction
2383  * whereas av_display_rotation_set() expects its argument
2384  * to be oriented clockwise, so we need to negate roll.
2385  * Furthermore, if hflip is set, we need to negate it again
2386  * to account for the fact that the Matroska specifications
2387  * require the yaw rotation to be applied first. */
2388  av_display_rotation_set(matrix, roll * (2 * hflip - 1));
2389  av_display_matrix_flip(matrix, hflip, 0);
2390 
2391  return 0;
2392 }
2393 
2394 static int mkv_parse_video_projection(AVStream *st, const MatroskaTrack *track,
2395  void *logctx)
2396 {
2397  AVSphericalMapping *spherical;
2398  const MatroskaTrackVideoProjection *mkv_projection = &track->video.projection;
2399  const uint8_t *priv_data = mkv_projection->private.data;
2400  enum AVSphericalProjection projection;
2401  size_t spherical_size;
2402  uint32_t l = 0, t = 0, r = 0, b = 0;
2403  uint32_t padding = 0;
2404 
2405  if (mkv_projection->private.size && priv_data[0] != 0) {
2406  av_log(logctx, AV_LOG_WARNING, "Unknown spherical metadata\n");
2407  return 0;
2408  }
2409 
2410  switch (track->video.projection.type) {
2412  return mkv_create_display_matrix(st, mkv_projection, logctx);
2414  if (track->video.projection.private.size == 20) {
2415  t = AV_RB32(priv_data + 4);
2416  b = AV_RB32(priv_data + 8);
2417  l = AV_RB32(priv_data + 12);
2418  r = AV_RB32(priv_data + 16);
2419 
2420  if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
2421  av_log(logctx, AV_LOG_ERROR,
2422  "Invalid bounding rectangle coordinates "
2423  "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n",
2424  l, t, r, b);
2425  return AVERROR_INVALIDDATA;
2426  }
2427  } else if (track->video.projection.private.size != 0) {
2428  av_log(logctx, AV_LOG_ERROR, "Unknown spherical metadata\n");
2429  return AVERROR_INVALIDDATA;
2430  }
2431 
2432  if (l || t || r || b)
2433  projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
2434  else
2435  projection = AV_SPHERICAL_EQUIRECTANGULAR;
2436  break;
2438  if (track->video.projection.private.size < 4) {
2439  av_log(logctx, AV_LOG_ERROR, "Missing projection private properties\n");
2440  return AVERROR_INVALIDDATA;
2441  } else if (track->video.projection.private.size == 12) {
2442  uint32_t layout = AV_RB32(priv_data + 4);
2443  if (layout) {
2444  av_log(logctx, AV_LOG_WARNING,
2445  "Unknown spherical cubemap layout %"PRIu32"\n", layout);
2446  return 0;
2447  }
2448  projection = AV_SPHERICAL_CUBEMAP;
2449  padding = AV_RB32(priv_data + 8);
2450  } else {
2451  av_log(logctx, AV_LOG_ERROR, "Unknown spherical metadata\n");
2452  return AVERROR_INVALIDDATA;
2453  }
2454  break;
2455  default:
2456  av_log(logctx, AV_LOG_WARNING,
2457  "Unknown spherical metadata type %"PRIu64"\n",
2458  track->video.projection.type);
2459  return 0;
2460  }
2461 
2462  spherical = av_spherical_alloc(&spherical_size);
2463  if (!spherical)
2464  return AVERROR(ENOMEM);
2465 
2466  spherical->projection = projection;
2467 
2468  spherical->yaw = (int32_t) (track->video.projection.yaw * (1 << 16));
2469  spherical->pitch = (int32_t) (track->video.projection.pitch * (1 << 16));
2470  spherical->roll = (int32_t) (track->video.projection.roll * (1 << 16));
2471 
2472  spherical->padding = padding;
2473 
2474  spherical->bound_left = l;
2475  spherical->bound_top = t;
2476  spherical->bound_right = r;
2477  spherical->bound_bottom = b;
2478 
2480  AV_PKT_DATA_SPHERICAL, spherical, spherical_size, 0)) {
2481  av_freep(&spherical);
2482  return AVERROR(ENOMEM);
2483  }
2484 
2485  return 0;
2486 }
2487 
2489  EbmlBin *bin)
2490 {
2491  return ff_isom_parse_dvcc_dvvc(s, st, bin->data, bin->size);
2492 }
2493 
2495 {
2496  const EbmlList *mappings_list = &track->block_addition_mappings;
2497  MatroskaBlockAdditionMapping *mappings = mappings_list->elem;
2498  int ret;
2499 
2500  for (int i = 0; i < mappings_list->nb_elem; i++) {
2501  MatroskaBlockAdditionMapping *mapping = &mappings[i];
2502  uint64_t type = mapping->type;
2503 
2504  switch (mapping->type) {
2507  "Explicit block Addition Mapping type \"Use BlockAddIDValue\", value %"PRIu64","
2508  " name \"%s\" found.\n", mapping->value, mapping->name ? mapping->name : "");
2510  // fall-through
2513  if (mapping->value != type) {
2514  int strict = s->strict_std_compliance >= FF_COMPLIANCE_STRICT;
2515  av_log(s, strict ? AV_LOG_ERROR : AV_LOG_WARNING,
2516  "Invalid Block Addition Value 0x%"PRIx64" for Block Addition Mapping Type "
2517  "0x%"PRIx64", name \"%s\"\n", mapping->value, mapping->type,
2518  mapping->name ? mapping->name : "");
2519  if (strict)
2520  return AVERROR_INVALIDDATA;
2521  }
2522  break;
2525  if ((ret = mkv_parse_dvcc_dvvc(s, st, track, &mapping->extradata)) < 0)
2526  return ret;
2527 
2528  break;
2529  default:
2531  "Unknown Block Addition Mapping type 0x%"PRIx64", value %"PRIu64", name \"%s\"\n",
2532  mapping->type, mapping->value, mapping->name ? mapping->name : "");
2533  if (mapping->value < 2) {
2534  int strict = s->strict_std_compliance >= FF_COMPLIANCE_STRICT;
2535  av_log(s, strict ? AV_LOG_ERROR : AV_LOG_WARNING,
2536  "Invalid Block Addition value 0x%"PRIu64" for unknown Block Addition Mapping "
2537  "type %"PRIx64", name \"%s\"\n", mapping->value, mapping->type,
2538  mapping->name ? mapping->name : "");
2539  if (strict)
2540  return AVERROR_INVALIDDATA;
2541  }
2542  break;
2543  }
2544  }
2545 
2546  return 0;
2547 }
2548 
2549 static int get_qt_codec(MatroskaTrack *track, uint32_t *fourcc, enum AVCodecID *codec_id)
2550 {
2551  const AVCodecTag *codec_tags;
2552 
2553  codec_tags = track->type == MATROSKA_TRACK_TYPE_VIDEO ?
2555 
2556  /* Normalize noncompliant private data that starts with the fourcc
2557  * by expanding/shifting the data by 4 bytes and storing the data
2558  * size at the start. */
2559  if (ff_codec_get_id(codec_tags, AV_RL32(track->codec_priv.data))) {
2560  int ret = av_buffer_realloc(&track->codec_priv.buf,
2562  if (ret < 0)
2563  return ret;
2564 
2565  track->codec_priv.data = track->codec_priv.buf->data;
2566  memmove(track->codec_priv.data + 4, track->codec_priv.data, track->codec_priv.size);
2567  track->codec_priv.size += 4;
2568  AV_WB32(track->codec_priv.data, track->codec_priv.size);
2569  }
2570 
2571  *fourcc = AV_RL32(track->codec_priv.data + 4);
2572  *codec_id = ff_codec_get_id(codec_tags, *fourcc);
2573 
2574  return 0;
2576 
2577 /* An enum with potential return values of the functions for parsing a track.
2578  * Apart from that all these functions can also indicate ordinary errors via
2579  * negative return values. */
2580 enum {
2581  SKIP_TRACK = 1,
2582 };
2583 
2584 #define AAC_MAX_EXTRADATA_SIZE 5
2585 #define TTA_EXTRADATA_SIZE 22
2586 #define WAVPACK_EXTRADATA_SIZE 2
2587 /* Performs the codec-specific part of parsing an audio track. */
2588 static int mka_parse_audio_codec(MatroskaTrack *track, AVCodecParameters *par,
2589  const MatroskaDemuxContext *matroska,
2590  AVFormatContext *s, int *extradata_offset)
2591 {
2592  uint8_t extradata[FFMAX3(AAC_MAX_EXTRADATA_SIZE,
2595  int extradata_size = 0; // > 0 means that the extradata buffer is used
2596  int ret;
2597 
2598  if (!strcmp(track->codec_id, "A_MS/ACM") &&
2599  track->codec_priv.size >= 14) {
2600  FFIOContext b;
2602  track->codec_priv.size);
2603  ret = ff_get_wav_header(s, &b.pub, par,
2604  track->codec_priv.size, 0);
2605  if (ret < 0)
2606  return ret;
2607  *extradata_offset = FFMIN(track->codec_priv.size, 18);
2608  return 0;
2609  } else if (!strcmp(track->codec_id, "A_QUICKTIME") &&
2610  /* Normally 36, but allow noncompliant private data */
2611  track->codec_priv.size >= 32) {
2612  enum AVCodecID codec_id;
2613  uint32_t fourcc;
2614  uint16_t sample_size;
2615 
2616  ret = get_qt_codec(track, &fourcc, &codec_id);
2617  if (ret < 0)
2618  return ret;
2619  sample_size = AV_RB16(track->codec_priv.data + 26);
2620  if (fourcc == 0) {
2621  if (sample_size == 8) {
2622  fourcc = MKTAG('r','a','w',' ');
2624  } else if (sample_size == 16) {
2625  fourcc = MKTAG('t','w','o','s');
2627  }
2628  }
2629  if ((fourcc == MKTAG('t','w','o','s') ||
2630  fourcc == MKTAG('s','o','w','t')) && sample_size == 8)
2632  par->codec_id = codec_id;
2633  par->codec_tag = fourcc;
2634  return 0;
2635  }
2636 
2637  switch (par->codec_id) {
2638  case AV_CODEC_ID_PCM_S16BE:
2639  switch (track->audio.bitdepth) {
2640  case 8:
2642  break;
2643  case 24:
2645  break;
2646  case 32:
2648  break;
2649  }
2650  break;
2651  case AV_CODEC_ID_PCM_S16LE:
2652  switch (track->audio.bitdepth) {
2653  case 8:
2655  break;
2656  case 24:
2658  break;
2659  case 32:
2661  break;
2662  }
2663  break;
2664  case AV_CODEC_ID_PCM_F32LE:
2665  if (track->audio.bitdepth == 64)
2667  break;
2668  case AV_CODEC_ID_AAC:
2669  if (!track->codec_priv.size) {
2670  int profile = matroska_aac_profile(track->codec_id);
2671  int sri = matroska_aac_sri(track->audio.samplerate);
2672 
2673  extradata[0] = (profile << 3) | ((sri & 0x0E) >> 1);
2674  extradata[1] = ((sri & 0x01) << 7) | (track->audio.channels << 3);
2675  if (strstr(track->codec_id, "SBR")) {
2676  sri = matroska_aac_sri(track->audio.out_samplerate);
2677  extradata[2] = 0x56;
2678  extradata[3] = 0xE5;
2679  extradata[4] = 0x80 | (sri << 3);
2680  extradata_size = 5;
2681  } else
2682  extradata_size = 2;
2683  }
2684  break;
2685  case AV_CODEC_ID_ALAC:
2686  if (track->codec_priv.size && track->codec_priv.size < INT_MAX - 12 - AV_INPUT_BUFFER_PADDING_SIZE) {
2687  /* Only ALAC's magic cookie is stored in Matroska's track headers.
2688  * Create the "atom size", "tag", and "tag version" fields the
2689  * decoder expects manually. */
2690  ret = ff_alloc_extradata(par, 12 + track->codec_priv.size);
2691  if (ret < 0)
2692  return ret;
2693  AV_WB32(par->extradata, par->extradata_size);
2694  AV_WB32(&par->extradata[4], MKBETAG('a', 'l', 'a', 'c'));
2695  AV_WB32(&par->extradata[8], 0);
2696  memcpy(&par->extradata[12], track->codec_priv.data,
2697  track->codec_priv.size);
2698  }
2699  break;
2700  case AV_CODEC_ID_TTA:
2701  {
2702  uint8_t *ptr;
2703  if (track->audio.channels > UINT16_MAX ||
2704  track->audio.bitdepth > UINT16_MAX) {
2705  av_log(matroska->ctx, AV_LOG_WARNING,
2706  "Too large audio channel number %"PRIu64
2707  " or bitdepth %"PRIu64". Skipping track.\n",
2708  track->audio.channels, track->audio.bitdepth);
2709  if (matroska->ctx->error_recognition & AV_EF_EXPLODE)
2710  return AVERROR_INVALIDDATA;
2711  else
2712  return SKIP_TRACK;
2713  }
2714  if (track->audio.out_samplerate < 0 || track->audio.out_samplerate > INT_MAX)
2715  return AVERROR_INVALIDDATA;
2716  extradata_size = TTA_EXTRADATA_SIZE;
2717  ptr = extradata;
2718  bytestream_put_be32(&ptr, AV_RB32("TTA1"));
2719  bytestream_put_le16(&ptr, 1);
2720  bytestream_put_le16(&ptr, track->audio.channels);
2721  bytestream_put_le16(&ptr, track->audio.bitdepth);
2722  bytestream_put_le32(&ptr, track->audio.out_samplerate);
2723  bytestream_put_le32(&ptr, av_rescale(matroska->duration * matroska->time_scale,
2724  track->audio.out_samplerate,
2725  AV_TIME_BASE * 1000));
2726  break;
2727  }
2728  case AV_CODEC_ID_RA_144:
2729  track->audio.out_samplerate = 8000;
2730  track->audio.channels = 1;
2731  break;
2732  case AV_CODEC_ID_RA_288:
2733  case AV_CODEC_ID_COOK:
2734  case AV_CODEC_ID_ATRAC3:
2735  case AV_CODEC_ID_SIPR:
2736  {
2737  const uint8_t *ptr = track->codec_priv.data;
2738  int flavor;
2739 
2740  if (!track->codec_priv.size)
2741  break;
2742 
2743  if (track->codec_priv.size < 46)
2744  return AVERROR_INVALIDDATA;
2745  ptr += 22;
2746  flavor = bytestream_get_be16(&ptr);
2747  track->audio.coded_framesize = bytestream_get_be32(&ptr);
2748  ptr += 12;
2749  track->audio.sub_packet_h = bytestream_get_be16(&ptr);
2750  track->audio.frame_size = bytestream_get_be16(&ptr);
2751  track->audio.sub_packet_size = bytestream_get_be16(&ptr);
2752  if (track->audio.coded_framesize <= 0 ||
2753  track->audio.sub_packet_h <= 0 ||
2754  track->audio.frame_size <= 0)
2755  return AVERROR_INVALIDDATA;
2756 
2757  if (par->codec_id == AV_CODEC_ID_RA_288) {
2758  if (track->audio.sub_packet_h & 1 || 2 * track->audio.frame_size
2759  != (int64_t)track->audio.sub_packet_h * track->audio.coded_framesize)
2760  return AVERROR_INVALIDDATA;
2761  par->block_align = track->audio.coded_framesize;
2762  track->codec_priv.size = 0;
2763  } else {
2764  if (par->codec_id == AV_CODEC_ID_SIPR) {
2765  static const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
2766  if (flavor > 3)
2767  return AVERROR_INVALIDDATA;
2768  track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
2769  par->bit_rate = sipr_bit_rate[flavor];
2770  } else if (track->audio.sub_packet_size <= 0 ||
2771  track->audio.frame_size % track->audio.sub_packet_size)
2772  return AVERROR_INVALIDDATA;
2773  par->block_align = track->audio.sub_packet_size;
2774  *extradata_offset = 78;
2775  }
2776  track->audio.buf = av_malloc_array(track->audio.sub_packet_h,
2777  track->audio.frame_size);
2778  if (!track->audio.buf)
2779  return AVERROR(ENOMEM);
2780  break;
2781  }
2782  case AV_CODEC_ID_ATRAC1:
2783  /* ATRAC1 uses a constant frame size.
2784  * Typical ATRAC1 streams are either mono or stereo.
2785  * At most, ATRAC1 was used to store 8 channels of audio. */
2786  if (track->audio.channels > 8)
2787  return AVERROR_INVALIDDATA;
2788  par->block_align = track->audio.channels * 212;
2789  break;
2790  case AV_CODEC_ID_FLAC:
2791  if (track->codec_priv.size) {
2792  ret = matroska_parse_flac(s, track, extradata_offset);
2793  if (ret < 0)
2794  return ret;
2795  }
2796  break;
2797  case AV_CODEC_ID_WAVPACK:
2798  if (track->codec_priv.size < 2) {
2799  av_log(matroska->ctx, AV_LOG_INFO, "Assuming WavPack version 4.10 "
2800  "in absence of valid CodecPrivate.\n");
2801  extradata_size = WAVPACK_EXTRADATA_SIZE;
2802  AV_WL16(extradata, 0x410);
2803  }
2804  break;
2805  }
2806 
2807  if (extradata_size > 0) {
2808  ret = ff_alloc_extradata(par, extradata_size);
2809  if (ret < 0)
2810  return ret;
2811  memcpy(par->extradata, extradata, extradata_size);
2812  }
2813 
2814  return 0;
2815 }
2816 
2817 /* Performs the generic part of parsing an audio track. */
2818 static int mka_parse_audio(MatroskaTrack *track, AVStream *st,
2819  AVCodecParameters *par,
2820  const MatroskaDemuxContext *matroska,
2821  AVFormatContext *s, int *extradata_offset)
2822 {
2823  FFStream *const sti = ffstream(st);
2824  int ret;
2825 
2826  ret = mka_parse_audio_codec(track, par, matroska,
2827  s, extradata_offset);
2828  if (ret)
2829  return ret;
2830 
2832  par->sample_rate = track->audio.out_samplerate;
2833  // channel layout may be already set by codec private checks above
2834  if (!av_channel_layout_check(&par->ch_layout)) {
2836  par->ch_layout.nb_channels = track->audio.channels;
2837  }
2838  if (!par->bits_per_coded_sample)
2839  par->bits_per_coded_sample = track->audio.bitdepth;
2840  if (par->codec_id == AV_CODEC_ID_MP3 ||
2841  par->codec_id == AV_CODEC_ID_MLP ||
2842  par->codec_id == AV_CODEC_ID_TRUEHD)
2844  else if (par->codec_id != AV_CODEC_ID_AAC)
2846  if (track->codec_delay > 0) {
2848  (AVRational){1, 1000000000},
2849  (AVRational){1, par->codec_id == AV_CODEC_ID_OPUS ?
2850  48000 : par->sample_rate});
2851  }
2852  if (track->seek_preroll > 0) {
2853  par->seek_preroll = av_rescale_q(track->seek_preroll,
2854  (AVRational){1, 1000000000},
2855  (AVRational){1, par->sample_rate});
2856  }
2857 
2858  return 0;
2859 }
2860 
2861 /* Performs the codec-specific part of parsing a video track. */
2862 static int mkv_parse_video_codec(MatroskaTrack *track, AVCodecParameters *par,
2863  const MatroskaDemuxContext *matroska,
2864  int *extradata_offset)
2865 {
2866  if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC") &&
2867  track->codec_priv.size >= 40) {
2868  track->ms_compat = 1;
2869  par->bits_per_coded_sample = AV_RL16(track->codec_priv.data + 14);
2870  par->codec_tag = AV_RL32(track->codec_priv.data + 16);
2872  par->codec_tag);
2873  if (!par->codec_id)
2875  par->codec_tag);
2876  *extradata_offset = 40;
2877  return 0;
2878  } else if (!strcmp(track->codec_id, "V_QUICKTIME") &&
2879  track->codec_priv.size >= 21) {
2880  enum AVCodecID codec_id;
2881  uint32_t fourcc;
2882  int ret = get_qt_codec(track, &fourcc, &codec_id);
2883  if (ret < 0)
2884  return ret;
2885  if (codec_id == AV_CODEC_ID_NONE && AV_RL32(track->codec_priv.data+4) == AV_RL32("SMI ")) {
2886  fourcc = MKTAG('S','V','Q','3');
2888  }
2889  par->codec_id = codec_id;
2890  if (codec_id == AV_CODEC_ID_NONE)
2891  av_log(matroska->ctx, AV_LOG_ERROR,
2892  "mov FourCC not found %s.\n", av_fourcc2str(fourcc));
2893  if (track->codec_priv.size >= 86) {
2894  FFIOContext b;
2895  unsigned bit_depth = AV_RB16(track->codec_priv.data + 82);
2897  track->codec_priv.size);
2898  if (ff_get_qtpalette(codec_id, &b.pub, track->palette)) {
2899  bit_depth &= 0x1F;
2900  track->has_palette = 1;
2901  }
2903  }
2904  par->codec_tag = fourcc;
2905  return 0;
2906  }
2907 
2908  switch (par->codec_id) {
2909  case AV_CODEC_ID_RV10:
2910  case AV_CODEC_ID_RV20:
2911  case AV_CODEC_ID_RV30:
2912  case AV_CODEC_ID_RV40:
2913  *extradata_offset = 26;
2914  break;
2915  case AV_CODEC_ID_PRORES:
2916  if (track->codec_priv.size == 4)
2917  par->codec_tag = AV_RL32(track->codec_priv.data);
2918  break;
2919  case AV_CODEC_ID_VP9:
2920  /* we don't need any value stored in CodecPrivate.
2921  * make sure that it's not exported as extradata. */
2922  track->codec_priv.size = 0;
2923  break;
2924  }
2925 
2926  return 0;
2927 }
2928 
2929 /* Performs the generic part of parsing a video track. */
2930 static int mkv_parse_video(MatroskaTrack *track, AVStream *st,
2931  AVCodecParameters *par,
2932  const MatroskaDemuxContext *matroska,
2933  int *extradata_offset)
2934 {
2935  FFStream *const sti = ffstream(st);
2937  int display_width_mul = 1;
2938  int display_height_mul = 1;
2939  int ret;
2940 
2941  if (track->video.color_space.size == 4)
2942  par->codec_tag = AV_RL32(track->video.color_space.data);
2943 
2944  ret = mkv_parse_video_codec(track, par, matroska,
2945  extradata_offset);
2946  if (ret < 0)
2947  return ret;
2948 
2950  par->width = track->video.pixel_width;
2951  par->height = track->video.pixel_height;
2952 
2954  par->field_order = mkv_field_order(matroska, track->video.field_order);
2957 
2960  &display_width_mul, &display_height_mul);
2961 
2963  if (track->video.display_width && track->video.display_height &&
2964  par->height < INT64_MAX / track->video.display_width / display_width_mul &&
2965  par->width < INT64_MAX / track->video.display_height / display_height_mul)
2967  &st->sample_aspect_ratio.den,
2968  par->height * track->video.display_width * display_width_mul,
2969  par->width * track->video.display_height * display_height_mul,
2970  INT_MAX);
2971  }
2972  if (par->codec_id != AV_CODEC_ID_HEVC)
2974 
2975  if (track->default_duration) {
2976  int div = track->default_duration <= INT64_MAX ? 1 : 2;
2978  1000000000 / div, track->default_duration / div, 30000);
2979 #if FF_API_R_FRAME_RATE
2980  if ( st->avg_frame_rate.num < st->avg_frame_rate.den * 1000LL
2981  && st->avg_frame_rate.num > st->avg_frame_rate.den * 5LL)
2982  st->r_frame_rate = st->avg_frame_rate;
2983 #endif
2984  }
2985 
2986  /* export stereo mode flag as metadata tag */
2988  av_dict_set(&st->metadata, "stereo_mode", ff_matroska_video_stereo_mode[track->video.stereo_mode], 0);
2989 
2990  /* export alpha mode flag as metadata tag */
2991  if (track->video.alpha_mode)
2992  av_dict_set_int(&st->metadata, "alpha_mode", 1, 0);
2993 
2994  /* if we have virtual track, mark the real tracks */
2996  for (int j = 0; j < track->operation.combine_planes.nb_elem; j++) {
2997  MatroskaTrack *tracks = matroska->tracks.elem;
2998  char buf[32];
3000  continue;
3001  snprintf(buf, sizeof(buf), "%s_%d",
3003  for (int k = 0; k < matroska->tracks.nb_elem; k++)
3004  if (planes[j].uid == tracks[k].uid && tracks[k].stream) {
3005  av_dict_set(&tracks[k].stream->metadata,
3006  "stereo_mode", buf, 0);
3007  break;
3008  }
3009  }
3010  // add stream level stereo3d side data if it is a supported format
3014  int ret = mkv_stereo3d_conv(st, track->video.stereo_mode);
3015  if (ret < 0)
3016  return ret;
3017  }
3018 
3019  ret = mkv_parse_video_color(st, track);
3020  if (ret < 0)
3021  return ret;
3022  ret = mkv_parse_video_projection(st, track, matroska->ctx);
3023  if (ret < 0)
3024  return ret;
3025 
3026  return 0;
3027 }
3028 
3029 /* Performs the codec-specific part of parsing a subtitle track. */
3030 static int mkv_parse_subtitle_codec(MatroskaTrack *track, AVStream *st,
3031  AVCodecParameters *par,
3032  const MatroskaDemuxContext *matroska)
3033 {
3034  switch (par->codec_id) {
3036  if (track->codec_priv.size == 3) {
3037  int component_tag = track->codec_priv.data[0];
3038  int data_component_id = AV_RB16(track->codec_priv.data + 1);
3039 
3040  switch (data_component_id) {
3041  case 0x0008:
3042  // [0x30..0x37] are component tags utilized for
3043  // non-mobile captioning service ("profile A").
3044  if (component_tag >= 0x30 && component_tag <= 0x37) {
3046  }
3047  break;
3048  case 0x0012:
3049  // component tag 0x87 signifies a mobile/partial reception
3050  // (1seg) captioning service ("profile C").
3051  if (component_tag == 0x87) {
3053  }
3054  break;
3055  default:
3056  break;
3057  }
3058 
3059  if (par->profile == AV_PROFILE_UNKNOWN)
3060  av_log(matroska->ctx, AV_LOG_WARNING,
3061  "Unknown ARIB caption profile utilized: %02x / %04x\n",
3062  component_tag, data_component_id);
3063 
3064  track->codec_priv.size = 0;
3065  }
3066  break;
3067  case AV_CODEC_ID_WEBVTT:
3068  if (!strcmp(track->codec_id, "D_WEBVTT/CAPTIONS")) {
3070  } else if (!strcmp(track->codec_id, "D_WEBVTT/DESCRIPTIONS")) {
3072  } else if (!strcmp(track->codec_id, "D_WEBVTT/METADATA")) {
3074  }
3075  break;
3076  }
3077 
3078  return 0;
3079 }
3080 
3082 {
3083  MatroskaDemuxContext *matroska = s->priv_data;
3084  MatroskaTrack *tracks = matroska->tracks.elem;
3085  int i, j, ret;
3086 
3087  for (i = 0; i < matroska->tracks.nb_elem; i++) {
3088  MatroskaTrack *track = &tracks[i];
3090  AVCodecParameters *par;
3092  int extradata_offset = 0;
3093  AVStream *st;
3094  char* key_id_base64 = NULL;
3095 
3096  /* Apply some sanity checks. */
3097  if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
3098  track->type != MATROSKA_TRACK_TYPE_AUDIO &&
3099  track->type != MATROSKA_TRACK_TYPE_SUBTITLE &&
3100  track->type != MATROSKA_TRACK_TYPE_METADATA) {
3101  av_log(matroska->ctx, AV_LOG_INFO,
3102  "Unknown or unsupported track type %"PRIu64"\n",
3103  track->type);
3104  continue;
3105  }
3106  if (!track->codec_id)
3107  continue;
3108 
3109  if ( track->type == MATROSKA_TRACK_TYPE_AUDIO && track->codec_id[0] != 'A'
3110  || track->type == MATROSKA_TRACK_TYPE_VIDEO && track->codec_id[0] != 'V'
3111  || track->type == MATROSKA_TRACK_TYPE_SUBTITLE && track->codec_id[0] != 'D' && track->codec_id[0] != 'S'
3112  || track->type == MATROSKA_TRACK_TYPE_METADATA && track->codec_id[0] != 'D' && track->codec_id[0] != 'S'
3113  ) {
3114  av_log(matroska->ctx, AV_LOG_INFO, "Inconsistent track type\n");
3115  continue;
3116  }
3117 
3118  if (track->audio.samplerate < 0 || track->audio.samplerate > INT_MAX ||
3119  isnan(track->audio.samplerate)) {
3120  av_log(matroska->ctx, AV_LOG_WARNING,
3121  "Invalid sample rate %f, defaulting to 8000 instead.\n",
3122  track->audio.samplerate);
3123  track->audio.samplerate = 8000;
3124  }
3125 
3126  if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
3127  if (!track->default_duration && track->video.frame_rate > 0) {
3128  double default_duration = 1000000000 / track->video.frame_rate;
3129  if (default_duration > UINT64_MAX || default_duration < 0) {
3130  av_log(matroska->ctx, AV_LOG_WARNING,
3131  "Invalid frame rate %e. Cannot calculate default duration.\n",
3132  track->video.frame_rate);
3133  } else {
3134  track->default_duration = default_duration;
3135  }
3136  }
3137  if (track->video.display_width == -1)
3138  track->video.display_width = track->video.pixel_width;
3139  if (track->video.display_height == -1)
3140  track->video.display_height = track->video.pixel_height;
3141  } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
3142  if (!track->audio.out_samplerate)
3143  track->audio.out_samplerate = track->audio.samplerate;
3144  }
3146  track->encodings.nb_elem,
3147  track, &key_id_base64, matroska->ctx);
3148  if (ret < 0)
3149  return ret;
3150 
3151  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
3152  if (av_strstart(track->codec_id, ff_mkv_codec_tags[j].str, NULL)) {
3154  break;
3155  }
3156  }
3157 
3158  st = track->stream = avformat_new_stream(s, NULL);
3159  if (!st) {
3160  av_free(key_id_base64);
3161  return AVERROR(ENOMEM);
3162  }
3163  par = st->codecpar;
3164 
3165  par->codec_id = codec_id;
3166 
3167  if (track->flag_default)
3169  if (track->flag_forced)
3171  if (track->flag_comment)
3173  if (track->flag_hearingimpaired)
3175  if (track->flag_visualimpaired)
3177  if (track->flag_original.count > 0)
3180 
3181  if (key_id_base64) {
3182  /* export encryption key id as base64 metadata tag */
3183  av_dict_set(&st->metadata, "enc_key_id", key_id_base64,
3185  }
3186 
3187  if (strcmp(track->language, "und"))
3188  av_dict_set(&st->metadata, "language", track->language, 0);
3189  av_dict_set(&st->metadata, "title", track->name, 0);
3190 
3191  if (track->time_scale < 0.01) {
3192  av_log(matroska->ctx, AV_LOG_WARNING,
3193  "Track TimestampScale too small %f, assuming 1.0.\n",
3194  track->time_scale);
3195  track->time_scale = 1.0;
3196  }
3197  avpriv_set_pts_info(st, 64, matroska->time_scale * track->time_scale,
3198  1000 * 1000 * 1000); /* 64 bit pts in ns */
3199 
3200  /* convert the delay from ns to the track timebase */
3202  (AVRational){ 1, 1000000000 },
3203  st->time_base);
3204 
3205  type = track->type;
3206  if (par->codec_id == AV_CODEC_ID_WEBVTT)
3208  switch (type) {
3210  ret = mka_parse_audio(track, st, par, matroska,
3211  s, &extradata_offset);
3212  if (ret < 0)
3213  return ret;
3214  if (ret == SKIP_TRACK)
3215  continue;
3216  break;
3218  ret = mkv_parse_video(track, st, par, matroska, &extradata_offset);
3219  if (ret < 0)
3220  return ret;
3221  break;
3223  ret = mkv_parse_subtitle_codec(track, st, par, matroska);
3224  if (ret < 0)
3225  return ret;
3227 
3228  if (track->flag_textdescriptions)
3230  break;
3231  }
3232 
3233  if (par->codec_id == AV_CODEC_ID_NONE)
3234  av_log(matroska->ctx, AV_LOG_INFO,
3235  "Unknown/unsupported AVCodecID %s.\n", track->codec_id);
3236 
3237  if (!par->extradata && track->codec_priv.size > extradata_offset) {
3238  const uint8_t *src = track->codec_priv.data + extradata_offset;
3239  unsigned extra_size = track->codec_priv.size - extradata_offset;
3240  ret = ff_alloc_extradata(par, extra_size);
3241  if (ret < 0)
3242  return ret;
3243  memcpy(par->extradata, src, extra_size);
3244  }
3245 
3246  ret = mkv_parse_block_addition_mappings(s, st, track);
3247  if (ret < 0)
3248  return ret;
3249  }
3250 
3251  return 0;
3252 }
3253 
3255 {
3256  FFFormatContext *const si = ffformatcontext(s);
3257  MatroskaDemuxContext *matroska = s->priv_data;
3258  EbmlList *attachments_list = &matroska->attachments;
3259  EbmlList *chapters_list = &matroska->chapters;
3260  MatroskaAttachment *attachments;
3261  MatroskaChapter *chapters;
3262  uint64_t max_start = 0;
3263  int64_t pos;
3264  Ebml ebml = { 0 };
3265  int i, j, res;
3266 
3267  matroska->ctx = s;
3268  matroska->cues_parsing_deferred = 1;
3269 
3270  /* First read the EBML header. */
3271  if (ebml_parse(matroska, ebml_syntax, &ebml) || !ebml.doctype) {
3272  av_log(matroska->ctx, AV_LOG_ERROR, "EBML header parsing failed\n");
3273  ebml_free(ebml_syntax, &ebml);
3274  return AVERROR_INVALIDDATA;
3275  }
3276  if (ebml.version > EBML_VERSION ||
3277  ebml.max_size > sizeof(uint64_t) ||
3278  ebml.id_length > sizeof(uint32_t) ||
3279  ebml.doctype_version > 3) {
3281  "EBML version %"PRIu64", doctype %s, doc version %"PRIu64,
3282  ebml.version, ebml.doctype, ebml.doctype_version);
3283  ebml_free(ebml_syntax, &ebml);
3284  return AVERROR_PATCHWELCOME;
3285  } else if (ebml.doctype_version == 3) {
3286  av_log(matroska->ctx, AV_LOG_WARNING,
3287  "EBML header using unsupported features\n"
3288  "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
3289  ebml.version, ebml.doctype, ebml.doctype_version);
3290  }
3291  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++)
3292  if (!strcmp(ebml.doctype, matroska_doctypes[i]))
3293  break;
3295  av_log(s, AV_LOG_WARNING, "Unknown EBML doctype '%s'\n", ebml.doctype);
3296  if (matroska->ctx->error_recognition & AV_EF_EXPLODE) {
3297  ebml_free(ebml_syntax, &ebml);
3298  return AVERROR_INVALIDDATA;
3299  }
3300  }
3301  matroska->is_webm = !strcmp(ebml.doctype, "webm");
3302 
3303  ebml_free(ebml_syntax, &ebml);
3304 
3305  matroska->pkt = si->parse_pkt;
3306 
3307  /* The next thing is a segment. */
3308  pos = avio_tell(matroska->ctx->pb);
3309  res = ebml_parse(matroska, matroska_segments, matroska);
3310  // Try resyncing until we find an EBML_STOP type element.
3311  while (res != 1) {
3312  res = matroska_resync(matroska, pos);
3313  if (res < 0)
3314  return res;
3315  pos = avio_tell(matroska->ctx->pb);
3316  res = ebml_parse(matroska, matroska_segment, matroska);
3317  if (res == AVERROR(EIO)) // EOF is translated to EIO, this exists the loop on EOF
3318  return res;
3319  }
3320  /* Set data_offset as it might be needed later by seek_frame_generic. */
3321  if (matroska->current_id == MATROSKA_ID_CLUSTER)
3322  si->data_offset = avio_tell(matroska->ctx->pb) - 4;
3323  matroska_execute_seekhead(matroska);
3324 
3325  if (!matroska->time_scale)
3326  matroska->time_scale = 1000000;
3327  if (isnan(matroska->duration))
3328  matroska->duration = 0;
3329  if (matroska->duration)
3330  matroska->ctx->duration = matroska->duration * matroska->time_scale *
3331  1000 / AV_TIME_BASE;
3332  av_dict_set(&s->metadata, "title", matroska->title, 0);
3333  av_dict_set(&s->metadata, "encoder", matroska->muxingapp, 0);
3334 
3335  if (matroska->date_utc.size == 8)
3336  matroska_metadata_creation_time(&s->metadata, AV_RB64(matroska->date_utc.data));
3337 
3338  res = matroska_parse_tracks(s);
3339  if (res < 0)
3340  return res;
3341 
3342  attachments = attachments_list->elem;
3343  for (j = 0; j < attachments_list->nb_elem; j++) {
3344  if (!(attachments[j].filename && attachments[j].mime &&
3345  attachments[j].bin.data && attachments[j].bin.size > 0)) {
3346  av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
3347  } else {
3349  if (!st)
3350  break;
3351  av_dict_set(&st->metadata, "filename", attachments[j].filename, 0);
3352  av_dict_set(&st->metadata, "mimetype", attachments[j].mime, 0);
3353  if (attachments[j].description)
3354  av_dict_set(&st->metadata, "title", attachments[j].description, 0);
3356 
3357  for (i = 0; mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
3358  if (av_strstart(attachments[j].mime, mkv_image_mime_tags[i].str, NULL)) {
3360  break;
3361  }
3362  }
3363 
3364  attachments[j].stream = st;
3365 
3366  if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
3367  res = ff_add_attached_pic(s, st, NULL, &attachments[j].bin.buf, 0);
3368  if (res < 0)
3369  return res;
3370  } else {
3372  if (ff_alloc_extradata(st->codecpar, attachments[j].bin.size))
3373  break;
3374  memcpy(st->codecpar->extradata, attachments[j].bin.data,
3375  attachments[j].bin.size);
3376 
3377  for (i = 0; mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
3378  if (av_strstart(attachments[j].mime, mkv_mime_tags[i].str, NULL)) {
3380  break;
3381  }
3382  }
3383  }
3384  }
3385  }
3386 
3387  chapters = chapters_list->elem;
3388  for (i = 0; i < chapters_list->nb_elem; i++)
3389  if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid &&
3390  (max_start == 0 || chapters[i].start > max_start)) {
3391  chapters[i].chapter =
3392  avpriv_new_chapter(s, chapters[i].uid,
3393  (AVRational) { 1, 1000000000 },
3394  chapters[i].start, chapters[i].end,
3395  chapters[i].title);
3396  max_start = chapters[i].start;
3397  }
3398 
3399  matroska_add_index_entries(matroska);
3400 
3402 
3403  return 0;
3405 
3406 /*
3407  * Put one packet in an application-supplied AVPacket struct.
3408  * Returns 0 on success or -1 on failure.
3409  */
3410 static int matroska_deliver_packet(MatroskaDemuxContext *matroska,
3411  AVPacket *pkt)
3412 {
3413  if (matroska->queue.head) {
3414  MatroskaTrack *tracks = matroska->tracks.elem;
3415  MatroskaTrack *track;
3416 
3417  avpriv_packet_list_get(&matroska->queue, pkt);
3418  track = &tracks[pkt->stream_index];
3419  if (track->has_palette) {
3421  if (!pal) {
3422  av_log(matroska->ctx, AV_LOG_ERROR, "Cannot append palette to packet\n");
3423  } else {
3424  memcpy(pal, track->palette, AVPALETTE_SIZE);
3425  }
3426  track->has_palette = 0;
3427  }
3428  return 0;
3429  }
3430 
3431  return -1;
3432 }
3433 
3434 /*
3435  * Free all packets in our internal queue.
3436  */
3437 static void matroska_clear_queue(MatroskaDemuxContext *matroska)
3438 {
3439  avpriv_packet_list_free(&matroska->queue);
3440 }
3441 
3442 static int matroska_parse_laces(MatroskaDemuxContext *matroska, uint8_t **buf,
3443  int size, int type, AVIOContext *pb,
3444  uint32_t lace_size[256], int *laces)
3445 {
3446  int n;
3447  uint8_t *data = *buf;
3448 
3449  if (!type) {
3450  *laces = 1;
3451  lace_size[0] = size;
3452  return 0;
3453  }
3454 
3455  if (size <= 0)
3456  return AVERROR_INVALIDDATA;
3457 
3458  *laces = *data + 1;
3459  data += 1;
3460  size -= 1;
3461 
3462  switch (type) {
3463  case 0x1: /* Xiph lacing */
3464  {
3465  uint8_t temp;
3466  uint32_t total = 0;
3467  for (n = 0; n < *laces - 1; n++) {
3468  lace_size[n] = 0;
3469 
3470  do {
3471  if (size <= total)
3472  return AVERROR_INVALIDDATA;
3473  temp = *data;
3474  total += temp;
3475  lace_size[n] += temp;
3476  data += 1;
3477  size -= 1;
3478  } while (temp == 0xff);
3479  }
3480  if (size < total)
3481  return AVERROR_INVALIDDATA;
3482 
3483  lace_size[n] = size - total;
3484  break;
3485  }
3486 
3487  case 0x2: /* fixed-size lacing */
3488  if (size % (*laces))
3489  return AVERROR_INVALIDDATA;
3490  for (n = 0; n < *laces; n++)
3491  lace_size[n] = size / *laces;
3492  break;
3493 
3494  case 0x3: /* EBML lacing */
3495  {
3496  uint64_t num;
3497  uint64_t total;
3498  int offset;
3499 
3500  avio_skip(pb, 4);
3501 
3502  n = ebml_read_num(matroska, pb, 8, &num, 1);
3503  if (n < 0)
3504  return n;
3505  if (num > INT_MAX)
3506  return AVERROR_INVALIDDATA;
3507 
3508  total = lace_size[0] = num;
3509  offset = n;
3510  for (n = 1; n < *laces - 1; n++) {
3511  int64_t snum;
3512  int r;
3513  r = matroska_ebmlnum_sint(matroska, pb, &snum);
3514  if (r < 0)
3515  return r;
3516  if (lace_size[n - 1] + snum > (uint64_t)INT_MAX)
3517  return AVERROR_INVALIDDATA;
3518 
3519  lace_size[n] = lace_size[n - 1] + snum;
3520  total += lace_size[n];
3521  offset += r;
3522  }
3523  data += offset;
3524  size -= offset;
3525  if (size < total)
3526  return AVERROR_INVALIDDATA;
3527 
3528  lace_size[*laces - 1] = size - total;
3529  break;
3530  }
3531  }
3533  *buf = data;
3534 
3535  return 0;
3536 }
3537 
3538 static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
3539  MatroskaTrack *track, AVStream *st,
3540  uint8_t *data, int size, uint64_t timecode,
3541  int64_t pos)
3542 {
3543  const int a = st->codecpar->block_align;
3544  const int sps = track->audio.sub_packet_size;
3545  const int cfs = track->audio.coded_framesize;
3546  const int h = track->audio.sub_packet_h;
3547  const int w = track->audio.frame_size;
3548  int y = track->audio.sub_packet_cnt;
3549  int x;
3550 
3551  if (!track->audio.pkt_cnt) {
3552  if (track->audio.sub_packet_cnt == 0)
3553  track->audio.buf_timecode = timecode;
3554  if (st->codecpar->codec_id == AV_CODEC_ID_RA_288) {
3555  if (size < cfs * h / 2) {
3556  av_log(matroska->ctx, AV_LOG_ERROR,
3557  "Corrupt int4 RM-style audio packet size\n");
3558  return AVERROR_INVALIDDATA;
3559  }
3560  for (x = 0; x < h / 2; x++)
3561  memcpy(track->audio.buf + x * 2 * w + y * cfs,
3562  data + x * cfs, cfs);
3563  } else if (st->codecpar->codec_id == AV_CODEC_ID_SIPR) {
3564  if (size < w) {
3565  av_log(matroska->ctx, AV_LOG_ERROR,
3566  "Corrupt sipr RM-style audio packet size\n");
3567  return AVERROR_INVALIDDATA;
3568  }
3569  memcpy(track->audio.buf + y * w, data, w);
3570  } else {
3571  if (size < w) {
3572  av_log(matroska->ctx, AV_LOG_ERROR,
3573  "Corrupt generic RM-style audio packet size\n");
3574  return AVERROR_INVALIDDATA;
3575  }
3576  for (x = 0; x < w / sps; x++)
3577  memcpy(track->audio.buf +
3578  sps * (h * x + ((h + 1) / 2) * (y & 1) + (y >> 1)),
3579  data + x * sps, sps);
3580  }
3581 
3582  if (++track->audio.sub_packet_cnt >= h) {
3583  if (st->codecpar->codec_id == AV_CODEC_ID_SIPR)
3584  ff_rm_reorder_sipr_data(track->audio.buf, h, w);
3585  track->audio.sub_packet_cnt = 0;
3586  track->audio.pkt_cnt = h * w / a;
3587  }
3588  }
3589 
3590  while (track->audio.pkt_cnt) {
3591  int ret;
3592  AVPacket *pkt = matroska->pkt;
3593 
3594  ret = av_new_packet(pkt, a);
3595  if (ret < 0) {
3596  return ret;
3597  }
3598  memcpy(pkt->data,
3599  track->audio.buf + a * (h * w / a - track->audio.pkt_cnt--),
3600  a);
3601  pkt->pts = track->audio.buf_timecode;
3603  pkt->pos = pos;
3604  pkt->stream_index = st->index;
3605  ret = avpriv_packet_list_put(&matroska->queue, pkt, NULL, 0);
3606  if (ret < 0) {
3608  return AVERROR(ENOMEM);
3609  }
3610  }
3611 
3612  return 0;
3613 }
3614 
3615 /* reconstruct full wavpack blocks from mangled matroska ones */
3616 static int matroska_parse_wavpack(MatroskaTrack *track,
3617  uint8_t **data, int *size)
3618 {
3619  uint8_t *dst = NULL;
3620  uint8_t *src = *data;
3621  int dstlen = 0;
3622  int srclen = *size;
3623  uint32_t samples;
3624  uint16_t ver;
3625  int ret, offset = 0;
3626 
3627  if (srclen < 12)
3628  return AVERROR_INVALIDDATA;
3629 
3630  av_assert1(track->stream->codecpar->extradata_size >= 2);
3631  ver = AV_RL16(track->stream->codecpar->extradata);
3632 
3633  samples = AV_RL32(src);
3634  src += 4;
3635  srclen -= 4;
3636 
3637  while (srclen >= 8) {
3638  int multiblock;
3639  uint32_t blocksize;
3640  uint8_t *tmp;
3641 
3642  uint32_t flags = AV_RL32(src);
3643  uint32_t crc = AV_RL32(src + 4);
3644  src += 8;
3645  srclen -= 8;
3646 
3647  multiblock = (flags & 0x1800) != 0x1800;
3648  if (multiblock) {
3649  if (srclen < 4) {
3651  goto fail;
3652  }
3653  blocksize = AV_RL32(src);
3654  src += 4;
3655  srclen -= 4;
3656  } else
3657  blocksize = srclen;
3658 
3659  if (blocksize > srclen) {
3661  goto fail;
3662  }
3663 
3664  tmp = av_realloc(dst, dstlen + blocksize + 32 + AV_INPUT_BUFFER_PADDING_SIZE);
3665  if (!tmp) {
3666  ret = AVERROR(ENOMEM);
3667  goto fail;
3668  }
3669  dst = tmp;
3670  dstlen += blocksize + 32;
3671 
3672  AV_WL32(dst + offset, MKTAG('w', 'v', 'p', 'k')); // tag
3673  AV_WL32(dst + offset + 4, blocksize + 24); // blocksize - 8
3674  AV_WL16(dst + offset + 8, ver); // version
3675  AV_WL16(dst + offset + 10, 0); // track/index_no
3676  AV_WL32(dst + offset + 12, 0); // total samples
3677  AV_WL32(dst + offset + 16, 0); // block index
3678  AV_WL32(dst + offset + 20, samples); // number of samples
3679  AV_WL32(dst + offset + 24, flags); // flags
3680  AV_WL32(dst + offset + 28, crc); // crc
3681  memcpy(dst + offset + 32, src, blocksize); // block data
3682 
3683  src += blocksize;
3684  srclen -= blocksize;
3685  offset += blocksize + 32;
3686  }
3687 
3688  memset(dst + dstlen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3689 
3690  *data = dst;
3691  *size = dstlen;
3692 
3693  return 0;
3695 fail:
3696  av_freep(&dst);
3697  return ret;
3698 }
3699 
3700 static int matroska_parse_prores(MatroskaTrack *track,
3701  uint8_t **data, int *size)
3702 {
3703  uint8_t *dst;
3704  int dstlen = *size + 8;
3705 
3706  dst = av_malloc(dstlen + AV_INPUT_BUFFER_PADDING_SIZE);
3707  if (!dst)
3708  return AVERROR(ENOMEM);
3709 
3710  AV_WB32(dst, dstlen);
3711  AV_WB32(dst + 4, MKBETAG('i', 'c', 'p', 'f'));
3712  memcpy(dst + 8, *data, dstlen - 8);
3713  memset(dst + dstlen, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3714 
3715  *data = dst;
3716  *size = dstlen;
3717 
3718  return 0;
3719 }
3720 
3721 static int matroska_parse_webvtt(MatroskaDemuxContext *matroska,
3722  MatroskaTrack *track,
3723  AVStream *st,
3724  uint8_t *data, int data_len,
3725  uint64_t timecode,
3726  uint64_t duration,
3727  int64_t pos)
3728 {
3729  AVPacket *pkt = matroska->pkt;
3730  uint8_t *id, *settings, *text, *buf;
3731  int id_len, settings_len, text_len;
3732  uint8_t *p, *q;
3733  int err;
3734 
3735  if (data_len <= 0)
3736  return AVERROR_INVALIDDATA;
3737 
3738  p = data;
3739  q = data + data_len;
3740 
3741  id = p;
3742  id_len = -1;
3743  while (p < q) {
3744  if (*p == '\r' || *p == '\n') {
3745  id_len = p - id;
3746  if (*p == '\r')
3747  p++;
3748  break;
3749  }
3750  p++;
3751  }
3752 
3753  if (p >= q || *p != '\n')
3754  return AVERROR_INVALIDDATA;
3755  p++;
3756 
3757  settings = p;
3758  settings_len = -1;
3759  while (p < q) {
3760  if (*p == '\r' || *p == '\n') {
3761  settings_len = p - settings;
3762  if (*p == '\r')
3763  p++;
3764  break;
3765  }
3766  p++;
3767  }
3768 
3769  if (p >= q || *p != '\n')
3770  return AVERROR_INVALIDDATA;
3771  p++;
3772 
3773  text = p;
3774  text_len = q - p;
3775  while (text_len > 0) {
3776  const int len = text_len - 1;
3777  const uint8_t c = p[len];
3778  if (c != '\r' && c != '\n')
3779  break;
3780  text_len = len;
3781  }
3782 
3783  if (text_len <= 0)
3784  return AVERROR_INVALIDDATA;
3785 
3786  err = av_new_packet(pkt, text_len);
3787  if (err < 0) {
3788  return err;
3789  }
3790 
3791  memcpy(pkt->data, text, text_len);
3792 
3793  if (id_len > 0) {
3796  id_len);
3797  if (!buf) {
3799  return AVERROR(ENOMEM);
3800  }
3801  memcpy(buf, id, id_len);
3802  }
3803 
3804  if (settings_len > 0) {
3807  settings_len);
3808  if (!buf) {
3810  return AVERROR(ENOMEM);
3811  }
3812  memcpy(buf, settings, settings_len);
3813  }
3814 
3815  // Do we need this for subtitles?
3816  // pkt->flags = AV_PKT_FLAG_KEY;
3817 
3818  pkt->stream_index = st->index;
3819  pkt->pts = timecode;
3820 
3821  // Do we need this for subtitles?
3822  // pkt->dts = timecode;
3823 
3824  pkt->duration = duration;
3825  pkt->pos = pos;
3826 
3827  err = avpriv_packet_list_put(&matroska->queue, pkt, NULL, 0);
3828  if (err < 0) {
3830  return AVERROR(ENOMEM);
3831  }
3832 
3833  return 0;
3834 }
3835 
3837  MatroskaTrack *track, AVPacket *pkt,
3838  const uint8_t *data, int size, uint64_t id)
3839 {
3840  const EbmlList *mappings_list = &track->block_addition_mappings;
3841  MatroskaBlockAdditionMapping *mappings = mappings_list->elem, *mapping = NULL;
3842  uint8_t *side_data;
3843  int res;
3844 
3845  if (!matroska->is_webm && track->max_block_additional_id && id > track->max_block_additional_id) {
3846  int strict = matroska->ctx->strict_std_compliance >= FF_COMPLIANCE_STRICT;
3847  av_log(matroska->ctx, strict ? AV_LOG_ERROR : AV_LOG_WARNING,
3848  "BlockAddID %"PRIu64" is higher than the reported MaxBlockAdditionID %"PRIu64" "
3849  "for Track with TrackNumber %"PRIu64"\n", id, track->max_block_additional_id,
3850  track->num);
3851  if (strict)
3852  return AVERROR_INVALIDDATA;
3853  }
3854 
3855  for (int i = 0; i < mappings_list->nb_elem; i++) {
3856  if (id != mappings[i].value)
3857  continue;
3858  mapping = &mappings[i];
3859  break;
3860  }
3861 
3862  if (id != 1 && !matroska->is_webm && !mapping) {
3863  av_log(matroska->ctx, AV_LOG_WARNING, "BlockAddID %"PRIu64" has no mapping. Skipping\n", id);
3864  return 0;
3865  }
3866 
3867  if (mapping && mapping->type)
3868  id = mapping->type;
3869 
3870  switch (id) {
3872  GetByteContext bc;
3873  int country_code, provider_code;
3874  int provider_oriented_code, application_identifier;
3875  size_t hdrplus_size;
3876  AVDynamicHDRPlus *hdrplus;
3877 
3878  if (size < 6)
3879  break; //ignore
3880 
3881  bytestream2_init(&bc, data, size);
3882 
3883  /* ITU-T T.35 metadata */
3884  country_code = bytestream2_get_byteu(&bc);
3885  provider_code = bytestream2_get_be16u(&bc);
3886 
3887  if (country_code != 0xB5 || provider_code != 0x3C)
3888  break; // ignore
3889 
3890  provider_oriented_code = bytestream2_get_be16u(&bc);
3891  application_identifier = bytestream2_get_byteu(&bc);
3892 
3893  if (provider_oriented_code != 1 || application_identifier != 4)
3894  break; // ignore
3895 
3896  hdrplus = av_dynamic_hdr_plus_alloc(&hdrplus_size);
3897  if (!hdrplus)
3898  return AVERROR(ENOMEM);
3899 
3900  if ((res = av_dynamic_hdr_plus_from_t35(hdrplus, bc.buffer,
3901  bytestream2_get_bytes_left(&bc))) < 0 ||
3903  (uint8_t *)hdrplus, hdrplus_size)) < 0) {
3904  av_free(hdrplus);
3905  return res;
3906  }
3907 
3908  return 0;
3909  }
3910  default:
3911  break;
3912  }
3913 
3915  size + (size_t)8);
3916  if (!side_data)
3917  return AVERROR(ENOMEM);
3918 
3919  AV_WB64(side_data, id);
3920  memcpy(side_data + 8, data, size);
3921 
3922  return 0;
3923 }
3924 
3925 static int matroska_parse_frame(MatroskaDemuxContext *matroska,
3926  MatroskaTrack *track, AVStream *st,
3927  AVBufferRef *buf, uint8_t *data, int pkt_size,
3928  uint64_t timecode, uint64_t lace_duration,
3929  int64_t pos, int is_keyframe,
3930  MatroskaBlockMore *blockmore, int nb_blockmore,
3931  int64_t discard_padding)
3932 {
3933  uint8_t *pkt_data = data;
3934  int res = 0;
3935  AVPacket *pkt = matroska->pkt;
3936 
3937  if (st->codecpar->codec_id == AV_CODEC_ID_WAVPACK) {
3938  res = matroska_parse_wavpack(track, &pkt_data, &pkt_size);
3939  if (res < 0) {
3940  av_log(matroska->ctx, AV_LOG_ERROR,
3941  "Error parsing a wavpack block.\n");
3942  goto fail;
3943  }
3944  if (!buf)
3945  av_freep(&data);
3946  buf = NULL;
3947  }
3948 
3949  if (st->codecpar->codec_id == AV_CODEC_ID_PRORES &&
3950  AV_RB32(pkt_data + 4) != MKBETAG('i', 'c', 'p', 'f')) {
3951  res = matroska_parse_prores(track, &pkt_data, &pkt_size);
3952  if (res < 0) {
3953  av_log(matroska->ctx, AV_LOG_ERROR,
3954  "Error parsing a prores block.\n");
3955  goto fail;
3956  }
3957  if (!buf)
3958  av_freep(&data);
3959  buf = NULL;
3960  }
3961 
3962  if (!pkt_size && !nb_blockmore)
3963  goto no_output;
3964 
3965  if (!matroska->is_webm && nb_blockmore && !track->max_block_additional_id) {
3966  int strict = matroska->ctx->strict_std_compliance >= FF_COMPLIANCE_STRICT;
3967  av_log(matroska->ctx, strict ? AV_LOG_ERROR : AV_LOG_WARNING,
3968  "Unexpected BlockAdditions found in a Block from Track with TrackNumber %"PRIu64" "
3969  "where MaxBlockAdditionID is 0\n", track->num);
3970  if (strict) {
3971  res = AVERROR_INVALIDDATA;
3972  goto fail;
3973  }
3974  }
3975 
3976  if (!buf)
3977  pkt->buf = av_buffer_create(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE,
3978  NULL, NULL, 0);
3979  else
3980  pkt->buf = av_buffer_ref(buf);
3981 
3982  if (!pkt->buf) {
3983  res = AVERROR(ENOMEM);
3984  goto fail;
3985  }
3986 
3987  pkt->data = pkt_data;
3988  pkt->size = pkt_size;
3989  pkt->flags = is_keyframe;
3990  pkt->stream_index = st->index;
3991 
3992  for (int i = 0; i < nb_blockmore; i++) {
3993  MatroskaBlockMore *more = &blockmore[i];
3994 
3995  if (!more->additional.size)
3996  continue;
3997 
3998  res = matroska_parse_block_additional(matroska, track, pkt, more->additional.data,
3999  more->additional.size, more->additional_id);
4000  if (res < 0) {
4002  return res;
4003  }
4004  }
4005 
4006  if (discard_padding) {
4007  uint8_t *side_data = av_packet_new_side_data(pkt,
4009  10);
4010  if (!side_data) {
4012  return AVERROR(ENOMEM);
4013  }
4014  discard_padding = av_rescale_q(discard_padding,
4015  (AVRational){1, 1000000000},
4016  (AVRational){1, st->codecpar->sample_rate});
4017  if (discard_padding > 0) {
4018  AV_WL32(side_data + 4, discard_padding);
4019  } else {
4020  AV_WL32(side_data, -discard_padding);
4021  }
4022  }
4023 
4024  if (track->ms_compat)
4025  pkt->dts = timecode;
4026  else
4027  pkt->pts = timecode;
4028  pkt->pos = pos;
4029  pkt->duration = lace_duration;
4030 
4031  res = avpriv_packet_list_put(&matroska->queue, pkt, NULL, 0);
4032  if (res < 0) {
4034  return AVERROR(ENOMEM);
4035  }
4036 
4037  return 0;
4038 
4039 no_output:
4041  if (!buf)
4042  av_free(pkt_data);
4043  return res;
4044 }
4045 
4046 static int matroska_parse_block(MatroskaDemuxContext *matroska, AVBufferRef *buf, uint8_t *data,
4047  int size, int64_t pos, uint64_t cluster_time,
4048  uint64_t block_duration, int is_keyframe,
4049  MatroskaBlockMore *blockmore, int nb_blockmore,
4050  int64_t cluster_pos, int64_t discard_padding)
4051 {
4052  uint64_t timecode = AV_NOPTS_VALUE;
4053  MatroskaTrack *track;
4054  FFIOContext pb;
4055  int res = 0;
4056  AVStream *st;
4057  int16_t block_time;
4058  uint32_t lace_size[256];
4059  int n, flags, laces = 0;
4060  uint64_t num;
4061  int trust_default_duration;
4062 
4063  av_assert1(buf);
4064 
4066 
4067  if ((n = ebml_read_num(matroska, &pb.pub, 8, &num, 1)) < 0)
4068  return n;
4069  data += n;
4070  size -= n;
4071 
4072  track = matroska_find_track_by_num(matroska, num);
4073  if (!track || size < 3)
4074  return AVERROR_INVALIDDATA;
4075 
4076  if (!(st = track->stream)) {
4077  av_log(matroska->ctx, AV_LOG_VERBOSE,
4078  "No stream associated to TrackNumber %"PRIu64". "
4079  "Ignoring Block with this TrackNumber.\n", num);
4080  return 0;
4081  }
4082 
4083  if (st->discard >= AVDISCARD_ALL)
4084  return res;
4085  if (block_duration > INT64_MAX)
4086  block_duration = INT64_MAX;
4087 
4088  block_time = sign_extend(AV_RB16(data), 16);
4089  data += 2;
4090  flags = *data++;
4091  size -= 3;
4092  if (is_keyframe == -1)
4093  is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
4094 
4095  if (cluster_time != (uint64_t) -1 &&
4096  (block_time >= 0 || cluster_time >= -block_time)) {
4097  uint64_t timecode_cluster_in_track_tb = (double) cluster_time / track->time_scale;
4098  timecode = timecode_cluster_in_track_tb + block_time - track->codec_delay_in_track_tb;
4099  if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
4100  timecode < track->end_timecode)
4101  is_keyframe = 0; /* overlapping subtitles are not key frame */
4102  if (is_keyframe) {
4103  ff_reduce_index(matroska->ctx, st->index);
4104  av_add_index_entry(st, cluster_pos, timecode, 0, 0,
4106  }
4107  }
4108 
4109  if (matroska->skip_to_keyframe &&
4110  track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
4111  // Compare signed timecodes. Timecode may be negative due to codec delay
4112  // offset. We don't support timestamps greater than int64_t anyway - see
4113  // AVPacket's pts.
4114  if ((int64_t)timecode < (int64_t)matroska->skip_to_timecode)
4115  return res;
4116  if (is_keyframe)
4117  matroska->skip_to_keyframe = 0;
4118  else if (!ffstream(st)->skip_to_keyframe) {
4119  av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
4120  matroska->skip_to_keyframe = 0;
4121  }
4122  }
4123 
4124  res = matroska_parse_laces(matroska, &data, size, (flags & 0x06) >> 1,
4125  &pb.pub, lace_size, &laces);
4126  if (res < 0) {
4127  av_log(matroska->ctx, AV_LOG_ERROR, "Error parsing frame sizes.\n");
4128  return res;
4129  }
4130 
4131  trust_default_duration = track->default_duration != 0;
4132  if (track->audio.samplerate == 8000 && trust_default_duration) {
4133  // If this is needed for more codecs, then add them here
4134  if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
4135  if (track->audio.samplerate != st->codecpar->sample_rate || !st->codecpar->frame_size)
4136  trust_default_duration = 0;
4137  }
4138  }
4139 
4140  if (!block_duration && trust_default_duration)
4141  block_duration = track->default_duration * laces / matroska->time_scale;
4142 
4143  if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
4144  track->end_timecode =
4145  FFMAX(track->end_timecode, timecode + block_duration);
4146 
4147  for (n = 0; n < laces; n++) {
4148  int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
4149  uint8_t *out_data = data;
4150  int out_size = lace_size[n];
4151 
4152  if (track->needs_decoding) {
4153  res = matroska_decode_buffer(&out_data, &out_size, track);
4154  if (res < 0)
4155  return res;
4156  /* Given that we are here means that out_data is no longer
4157  * owned by buf, so set it to NULL. This depends upon
4158  * zero-length header removal compression being ignored. */
4159  av_assert1(out_data != data);
4160  buf = NULL;
4161  }
4162 
4163  if (track->audio.buf) {
4164  res = matroska_parse_rm_audio(matroska, track, st,
4165  out_data, out_size,
4166  timecode, pos);
4167  if (!buf)
4168  av_free(out_data);
4169  if (res)
4170  return res;
4171  } else if (st->codecpar->codec_id == AV_CODEC_ID_WEBVTT) {
4172  res = matroska_parse_webvtt(matroska, track, st,
4173  out_data, out_size,
4174  timecode, lace_duration,
4175  pos);
4176  if (!buf)
4177  av_free(out_data);
4178  if (res)
4179  return res;
4180  } else {
4181  res = matroska_parse_frame(matroska, track, st, buf, out_data,
4182  out_size, timecode, lace_duration,
4183  pos, !n ? is_keyframe : 0,
4184  blockmore, nb_blockmore,
4185  discard_padding);
4186  if (res)
4187  return res;
4188  }
4189 
4190  if (timecode != AV_NOPTS_VALUE)
4191  timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
4192  data += lace_size[n];
4193  }
4194 
4195  return 0;
4196 }
4197 
4198 static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
4199 {
4200  MatroskaCluster *cluster = &matroska->current_cluster;
4201  MatroskaBlock *block = &cluster->block;
4202  int res;
4203 
4204  av_assert0(matroska->num_levels <= 2);
4205 
4206  if (matroska->num_levels == 1) {
4207  res = ebml_parse(matroska, matroska_segment, NULL);
4208 
4209  if (res == 1) {
4210  /* Found a cluster: subtract the size of the ID already read. */
4211  cluster->pos = avio_tell(matroska->ctx->pb) - 4;
4212 
4213  res = ebml_parse(matroska, matroska_cluster_enter, cluster);
4214  if (res < 0)
4215  return res;
4216  }
4217  }
4218 
4219  if (matroska->num_levels == 2) {
4220  /* We are inside a cluster. */
4221  res = ebml_parse(matroska, matroska_cluster_parsing, cluster);
4222 
4223  if (res >= 0 && block->bin.size > 0) {
4224  int is_keyframe = block->non_simple ? block->reference.count == 0 : -1;
4225 
4226  res = matroska_parse_block(matroska, block->bin.buf, block->bin.data,
4227  block->bin.size, block->bin.pos,
4228  cluster->timecode, block->duration,
4229  is_keyframe, block->blockmore.elem,
4230  block->blockmore.nb_elem, cluster->pos,
4231  block->discard_padding);
4232  }
4233 
4235  memset(block, 0, sizeof(*block));
4236  } else if (!matroska->num_levels) {
4237  if (!avio_feof(matroska->ctx->pb)) {
4238  avio_r8(matroska->ctx->pb);
4239  if (!avio_feof(matroska->ctx->pb)) {
4240  av_log(matroska->ctx, AV_LOG_WARNING, "File extends beyond "
4241  "end of segment.\n");
4242  return AVERROR_INVALIDDATA;
4243  }
4244  }
4245  matroska->done = 1;
4246  return AVERROR_EOF;
4247  }
4248 
4249  return res;
4250 }
4251 
4253 {
4254  MatroskaDemuxContext *matroska = s->priv_data;
4255  int ret = 0;
4256 
4257  if (matroska->resync_pos == -1) {
4258  // This can only happen if generic seeking has been used.
4259  matroska->resync_pos = avio_tell(s->pb);
4260  }
4261 
4262  while (matroska_deliver_packet(matroska, pkt)) {
4263  if (matroska->done)
4264  return (ret < 0) ? ret : AVERROR_EOF;
4265  if (matroska_parse_cluster(matroska) < 0 && !matroska->done)
4266  ret = matroska_resync(matroska, matroska->resync_pos);
4267  }
4268 
4269  return 0;
4270 }
4271 
4272 static int matroska_read_seek(AVFormatContext *s, int stream_index,
4273  int64_t timestamp, int flags)
4274 {
4275  MatroskaDemuxContext *matroska = s->priv_data;
4276  MatroskaTrack *tracks = NULL;
4277  AVStream *st = s->streams[stream_index];
4278  FFStream *const sti = ffstream(st);
4279  int i, index;
4280 
4281  /* Parse the CUES now since we need the index data to seek. */
4282  if (matroska->cues_parsing_deferred > 0) {
4283  matroska->cues_parsing_deferred = 0;
4284  matroska_parse_cues(matroska);
4285  }
4286 
4287  if (!sti->nb_index_entries)
4288  goto err;
4289  timestamp = FFMAX(timestamp, sti->index_entries[0].timestamp);
4290 
4291  if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 ||
4292  index == sti->nb_index_entries - 1) {
4293  matroska_reset_status(matroska, 0, sti->index_entries[sti->nb_index_entries - 1].pos);
4294  while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 ||
4295  index == sti->nb_index_entries - 1) {
4296  matroska_clear_queue(matroska);
4297  if (matroska_parse_cluster(matroska) < 0)
4298  break;
4299  }
4300  }
4301 
4302  matroska_clear_queue(matroska);
4303  if (index < 0 || (matroska->cues_parsing_deferred < 0 &&
4304  index == sti->nb_index_entries - 1))
4305  goto err;
4306 
4307  tracks = matroska->tracks.elem;
4308  for (i = 0; i < matroska->tracks.nb_elem; i++) {
4309  tracks[i].audio.pkt_cnt = 0;
4310  tracks[i].audio.sub_packet_cnt = 0;
4311  tracks[i].audio.buf_timecode = AV_NOPTS_VALUE;
4312  tracks[i].end_timecode = 0;
4313  }
4314 
4315  /* We seek to a level 1 element, so set the appropriate status. */
4316  matroska_reset_status(matroska, 0, sti->index_entries[index].pos);
4317  if (flags & AVSEEK_FLAG_ANY) {
4318  sti->skip_to_keyframe = 0;
4319  matroska->skip_to_timecode = timestamp;
4320  } else {
4321  sti->skip_to_keyframe = 1;
4322  matroska->skip_to_timecode = sti->index_entries[index].timestamp;
4323  }
4324  matroska->skip_to_keyframe = 1;
4325  matroska->done = 0;
4327  return 0;
4328 err:
4329  // slightly hackish but allows proper fallback to
4330  // the generic seeking code.
4331  matroska_reset_status(matroska, 0, -1);
4332  matroska->resync_pos = -1;
4333  matroska_clear_queue(matroska);
4335  matroska->skip_to_keyframe = 0;
4336  matroska->done = 0;
4337  return -1;
4338 }
4339 
4341 {
4342  MatroskaDemuxContext *matroska = s->priv_data;
4343  MatroskaTrack *tracks = matroska->tracks.elem;
4344  int n;
4345 
4346  matroska_clear_queue(matroska);
4347 
4348  for (n = 0; n < matroska->tracks.nb_elem; n++)
4349  if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
4350  av_freep(&tracks[n].audio.buf);
4351  ebml_free(matroska_segment, matroska);
4352 
4353  return 0;
4354 }
4355 
4356 #if CONFIG_WEBM_DASH_MANIFEST_DEMUXER
4357 typedef struct {
4358  int64_t start_time_ns;
4359  int64_t end_time_ns;
4360  int64_t start_offset;
4361  int64_t end_offset;
4362 } CueDesc;
4363 
4364 /* This function searches all the Cues and returns the CueDesc corresponding to
4365  * the timestamp ts. Returned CueDesc will be such that start_time_ns <= ts <
4366  * end_time_ns. All 4 fields will be set to -1 if ts >= file's duration or
4367  * if an error occurred.
4368  */
4369 static CueDesc get_cue_desc(AVFormatContext *s, int64_t ts, int64_t cues_start) {
4370  MatroskaDemuxContext *matroska = s->priv_data;
4371  FFStream *const sti = ffstream(s->streams[0]);
4372  AVIndexEntry *const index_entries = sti->index_entries;
4373  int nb_index_entries = sti->nb_index_entries;
4374  CueDesc cue_desc;
4375  int i;
4376 
4377  if (ts >= (int64_t)(matroska->duration * matroska->time_scale))
4378  return (CueDesc) {-1, -1, -1, -1};
4379  for (i = 1; i < nb_index_entries; i++) {
4380  if (index_entries[i - 1].timestamp * matroska->time_scale <= ts &&
4381  index_entries[i].timestamp * matroska->time_scale > ts) {
4382  break;
4383  }
4384  }
4385  --i;
4386  if (index_entries[i].timestamp > matroska->duration)
4387  return (CueDesc) {-1, -1, -1, -1};
4388  cue_desc.start_time_ns = index_entries[i].timestamp * matroska->time_scale;
4389  cue_desc.start_offset = index_entries[i].pos - matroska->segment_start;
4390  if (i != nb_index_entries - 1) {
4391  cue_desc.end_time_ns = index_entries[i + 1].timestamp * matroska->time_scale;
4392  cue_desc.end_offset = index_entries[i + 1].pos - matroska->segment_start;
4393  } else {
4394  cue_desc.end_time_ns = matroska->duration * matroska->time_scale;
4395  // FIXME: this needs special handling for files where Cues appear
4396  // before Clusters. the current logic assumes Cues appear after
4397  // Clusters.
4398  cue_desc.end_offset = cues_start - matroska->segment_start;
4399  }
4400  return cue_desc;
4401 }
4402 
4403 static int webm_clusters_start_with_keyframe(AVFormatContext *s)
4404 {
4405  MatroskaDemuxContext *matroska = s->priv_data;
4406  AVStream *const st = s->streams[0];
4407  FFStream *const sti = ffstream(st);
4408  uint32_t id = matroska->current_id;
4409  int64_t cluster_pos, before_pos;
4410  int index, rv = 1;
4411 
4412  if (sti->nb_index_entries <= 0)
4413  return 0;
4414 
4415  // seek to the first cluster using cues.
4416  index = av_index_search_timestamp(st, 0, 0);
4417  if (index < 0)
4418  return 0;
4419  cluster_pos = sti->index_entries[index].pos;
4420  before_pos = avio_tell(s->pb);
4421  while (1) {
4422  uint64_t cluster_id, cluster_length;
4423  int read;
4424  AVPacket *pkt;
4425  avio_seek(s->pb, cluster_pos, SEEK_SET);
4426  // read cluster id and length
4427  read = ebml_read_num(matroska, matroska->ctx->pb, 4, &cluster_id, 1);
4428  if (read < 0 || cluster_id != 0xF43B675) // done with all clusters
4429  break;
4430  read = ebml_read_length(matroska, matroska->ctx->pb, &cluster_length);
4431  if (read < 0)
4432  break;
4433 
4434  matroska_reset_status(matroska, 0, cluster_pos);
4435  matroska_clear_queue(matroska);
4436  if (matroska_parse_cluster(matroska) < 0 ||
4437  !matroska->queue.head) {
4438  break;
4439  }
4440  pkt = &matroska->queue.head->pkt;
4441  // 4 + read is the length of the cluster id and the cluster length field.
4442  cluster_pos += 4 + read + cluster_length;
4443  if (!(pkt->flags & AV_PKT_FLAG_KEY)) {
4444  rv = 0;
4445  break;
4446  }
4447  }
4448 
4449  /* Restore the status after matroska_read_header: */
4450  matroska_reset_status(matroska, id, before_pos);
4451 
4452  return rv;
4453 }
4454 
4455 static int buffer_size_after_time_downloaded(int64_t time_ns, double search_sec, int64_t bps,
4456  double min_buffer, double* buffer,
4457  double* sec_to_download, AVFormatContext *s,
4458  int64_t cues_start)
4459 {
4460  double nano_seconds_per_second = 1000000000.0;
4461  double time_sec = time_ns / nano_seconds_per_second;
4462  int rv = 0;
4463  int64_t time_to_search_ns = (int64_t)(search_sec * nano_seconds_per_second);
4464  int64_t end_time_ns = time_ns + time_to_search_ns;
4465  double sec_downloaded = 0.0;
4466  CueDesc desc_curr = get_cue_desc(s, time_ns, cues_start);
4467  if (desc_curr.start_time_ns == -1)
4468  return -1;
4469  *sec_to_download = 0.0;
4470 
4471  // Check for non cue start time.
4472  if (time_ns > desc_curr.start_time_ns) {
4473  int64_t cue_nano = desc_curr.end_time_ns - time_ns;
4474  double percent = (double)(cue_nano) / (desc_curr.end_time_ns - desc_curr.start_time_ns);
4475  double cueBytes = (desc_curr.end_offset - desc_curr.start_offset) * percent;
4476  double timeToDownload = (cueBytes * 8.0) / bps;
4477 
4478  sec_downloaded += (cue_nano / nano_seconds_per_second) - timeToDownload;
4479  *sec_to_download += timeToDownload;
4480 
4481  // Check if the search ends within the first cue.
4482  if (desc_curr.end_time_ns >= end_time_ns) {
4483  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
4484  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
4485  sec_downloaded = percent_to_sub * sec_downloaded;
4486  *sec_to_download = percent_to_sub * *sec_to_download;
4487  }
4488 
4489  if ((sec_downloaded + *buffer) <= min_buffer) {
4490  return 1;
4491  }
4492 
4493  // Get the next Cue.
4494  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
4495  }
4496 
4497  while (desc_curr.start_time_ns != -1) {
4498  int64_t desc_bytes = desc_curr.end_offset - desc_curr.start_offset;
4499  int64_t desc_ns = desc_curr.end_time_ns - desc_curr.start_time_ns;
4500  double desc_sec = desc_ns / nano_seconds_per_second;
4501  double bits = (desc_bytes * 8.0);
4502  double time_to_download = bits / bps;
4503 
4504  sec_downloaded += desc_sec - time_to_download;
4505  *sec_to_download += time_to_download;
4506 
4507  if (desc_curr.end_time_ns >= end_time_ns) {
4508  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
4509  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
4510  sec_downloaded = percent_to_sub * sec_downloaded;
4511  *sec_to_download = percent_to_sub * *sec_to_download;
4512 
4513  if ((sec_downloaded + *buffer) <= min_buffer)
4514  rv = 1;
4515  break;
4516  }
4517 
4518  if ((sec_downloaded + *buffer) <= min_buffer) {
4519  rv = 1;
4520  break;
4521  }
4522 
4523  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
4524  }
4525  *buffer = *buffer + sec_downloaded;
4526  return rv;
4527 }
4528 
4529 /* This function computes the bandwidth of the WebM file with the help of
4530  * buffer_size_after_time_downloaded() function. Both of these functions are
4531  * adapted from WebM Tools project and are adapted to work with FFmpeg's
4532  * Matroska parsing mechanism.
4533  *
4534  * Returns the bandwidth of the file on success; -1 on error.
4535  * */
4536 static int64_t webm_dash_manifest_compute_bandwidth(AVFormatContext *s, int64_t cues_start)
4537 {
4538  MatroskaDemuxContext *matroska = s->priv_data;
4539  AVStream *st = s->streams[0];
4540  FFStream *const sti = ffstream(st);
4541  double bandwidth = 0.0;
4542 
4543  for (int i = 0; i < sti->nb_index_entries; i++) {
4544  int64_t prebuffer_ns = 1000000000;
4545  int64_t time_ns = sti->index_entries[i].timestamp * matroska->time_scale;
4546  double nano_seconds_per_second = 1000000000.0;
4547  int64_t prebuffered_ns;
4548  double prebuffer_bytes = 0.0;
4549  int64_t temp_prebuffer_ns = prebuffer_ns;
4550  int64_t pre_bytes, pre_ns;
4551  double pre_sec, prebuffer, bits_per_second;
4552  CueDesc desc_beg = get_cue_desc(s, time_ns, cues_start);
4553  // Start with the first Cue.
4554  CueDesc desc_end = desc_beg;
4555 
4556  if (time_ns > INT64_MAX - prebuffer_ns)
4557  return -1;
4558  prebuffered_ns = time_ns + prebuffer_ns;
4559 
4560  // Figure out how much data we have downloaded for the prebuffer. This will
4561  // be used later to adjust the bits per sample to try.
4562  while (desc_end.start_time_ns != -1 && desc_end.end_time_ns < prebuffered_ns) {
4563  // Prebuffered the entire Cue.
4564  prebuffer_bytes += desc_end.end_offset - desc_end.start_offset;
4565  temp_prebuffer_ns -= desc_end.end_time_ns - desc_end.start_time_ns;
4566  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
4567  }
4568  if (desc_end.start_time_ns == -1) {
4569  // The prebuffer is larger than the duration.
4570  if (matroska->duration * matroska->time_scale >= prebuffered_ns)
4571  return -1;
4572  bits_per_second = 0.0;
4573  } else {
4574  // The prebuffer ends in the last Cue. Estimate how much data was
4575  // prebuffered.
4576  pre_bytes = desc_end.end_offset - desc_end.start_offset;
4577  pre_ns = desc_end.end_time_ns - desc_end.start_time_ns;
4578  if (pre_ns <= 0)
4579  return -1;
4580  pre_sec = pre_ns / nano_seconds_per_second;
4581  prebuffer_bytes +=
4582  pre_bytes * ((temp_prebuffer_ns / nano_seconds_per_second) / pre_sec);
4583 
4584  prebuffer = prebuffer_ns / nano_seconds_per_second;
4585 
4586  // Set this to 0.0 in case our prebuffer buffers the entire video.
4587  bits_per_second = 0.0;
4588  do {
4589  int64_t desc_bytes = desc_end.end_offset - desc_beg.start_offset;
4590  int64_t desc_ns = desc_end.end_time_ns - desc_beg.start_time_ns;
4591  double desc_sec, calc_bits_per_second, percent, mod_bits_per_second;
4592  if (desc_bytes <= 0)
4593  return -1;
4594 
4595  desc_sec = desc_ns / nano_seconds_per_second;
4596  calc_bits_per_second = (desc_bytes * 8) / desc_sec;
4597 
4598  // Drop the bps by the percentage of bytes buffered.
4599  percent = (desc_bytes - prebuffer_bytes) / desc_bytes;
4600  mod_bits_per_second = calc_bits_per_second * percent;
4601 
4602  if (prebuffer < desc_sec) {
4603  double search_sec =
4604  (double)(matroska->duration * matroska->time_scale) / nano_seconds_per_second;
4605 
4606  // Add 1 so the bits per second should be a little bit greater than file
4607  // datarate.
4608  int64_t bps = (int64_t)(mod_bits_per_second) + 1;
4609  const double min_buffer = 0.0;
4610  double buffer = prebuffer;
4611  double sec_to_download = 0.0;
4612 
4613  int rv = buffer_size_after_time_downloaded(prebuffered_ns, search_sec, bps,
4614  min_buffer, &buffer, &sec_to_download,
4615  s, cues_start);
4616  if (rv < 0) {
4617  return -1;
4618  } else if (rv == 0) {
4619  bits_per_second = (double)(bps);
4620  break;
4621  }
4622  }
4623 
4624  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
4625  } while (desc_end.start_time_ns != -1);
4626  }
4627  if (bandwidth < bits_per_second) bandwidth = bits_per_second;
4628  }
4629  return (int64_t)bandwidth;
4630 }
4631 
4632 static int webm_dash_manifest_cues(AVFormatContext *s, int64_t init_range)
4633 {
4634  MatroskaDemuxContext *matroska = s->priv_data;
4635  EbmlList *seekhead_list = &matroska->seekhead;
4636  MatroskaSeekhead *seekhead = seekhead_list->elem;
4637  AVStream *const st = s->streams[0];
4638  FFStream *const sti = ffstream(st);
4639  AVBPrint bprint;
4640  char *buf;
4641  int64_t cues_start = -1, cues_end = -1, before_pos, bandwidth;
4642  int i;
4643  int ret;
4644 
4645  // determine cues start and end positions
4646  for (i = 0; i < seekhead_list->nb_elem; i++)
4647  if (seekhead[i].id == MATROSKA_ID_CUES)
4648  break;
4649 
4650  if (i >= seekhead_list->nb_elem) return -1;
4651 
4652  before_pos = avio_tell(matroska->ctx->pb);
4653  cues_start = seekhead[i].pos + matroska->segment_start;
4654  if (avio_seek(matroska->ctx->pb, cues_start, SEEK_SET) == cues_start) {
4655  // cues_end is computed as cues_start + cues_length + length of the
4656  // Cues element ID (i.e. 4) + EBML length of the Cues element.
4657  // cues_end is inclusive and the above sum is reduced by 1.
4658  uint64_t cues_length, cues_id;
4659  int bytes_read;
4660  bytes_read = ebml_read_num (matroska, matroska->ctx->pb, 4, &cues_id, 1);
4661  if (bytes_read < 0 || cues_id != (MATROSKA_ID_CUES & 0xfffffff))
4662  return bytes_read < 0 ? bytes_read : AVERROR_INVALIDDATA;
4663  bytes_read = ebml_read_length(matroska, matroska->ctx->pb, &cues_length);
4664  if (bytes_read < 0)
4665  return bytes_read;
4666  cues_end = cues_start + 4 + bytes_read + cues_length - 1;
4667  }
4668  avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
4669  if (cues_start == -1 || cues_end == -1) return -1;
4670 
4671  // parse the cues
4672  matroska_parse_cues(matroska);
4673 
4674  if (!sti->nb_index_entries)
4675  return AVERROR_INVALIDDATA;
4676 
4677  // cues start
4678  av_dict_set_int(&s->streams[0]->metadata, CUES_START, cues_start, 0);
4679 
4680  // cues end
4681  av_dict_set_int(&s->streams[0]->metadata, CUES_END, cues_end, 0);
4682 
4683  // if the file has cues at the start, fix up the init range so that
4684  // it does not include it
4685  if (cues_start <= init_range)
4686  av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, cues_start - 1, 0);
4687 
4688  // bandwidth
4689  bandwidth = webm_dash_manifest_compute_bandwidth(s, cues_start);
4690  if (bandwidth < 0) return -1;
4691  av_dict_set_int(&s->streams[0]->metadata, BANDWIDTH, bandwidth, 0);
4692 
4693  // check if all clusters start with key frames
4694  av_dict_set_int(&s->streams[0]->metadata, CLUSTER_KEYFRAME, webm_clusters_start_with_keyframe(s), 0);
4695 
4696  // Store cue point timestamps as a comma separated list
4697  // for checking subsegment alignment in the muxer.
4699  for (int i = 0; i < sti->nb_index_entries; i++)
4700  av_bprintf(&bprint, "%" PRId64",", sti->index_entries[i].timestamp);
4701  if (!av_bprint_is_complete(&bprint)) {
4702  av_bprint_finalize(&bprint, NULL);
4703  return AVERROR(ENOMEM);
4704  }
4705  // Remove the trailing ','
4706  bprint.str[--bprint.len] = '\0';
4707  if ((ret = av_bprint_finalize(&bprint, &buf)) < 0)
4708  return ret;
4709  av_dict_set(&s->streams[0]->metadata, CUE_TIMESTAMPS,
4711 
4712  return 0;
4713 }
4714 
4715 static int webm_dash_manifest_read_header(AVFormatContext *s)
4716 {
4717  char *buf;
4718  int ret = matroska_read_header(s);
4719  int64_t init_range;
4720  MatroskaTrack *tracks;
4721  MatroskaDemuxContext *matroska = s->priv_data;
4722  if (ret) {
4723  av_log(s, AV_LOG_ERROR, "Failed to read file headers\n");
4724  return -1;
4725  }
4726  if (!matroska->tracks.nb_elem || !s->nb_streams) {
4727  av_log(s, AV_LOG_ERROR, "No track found\n");
4728  return AVERROR_INVALIDDATA;
4729  }
4730 
4731  if (!matroska->is_live) {
4732  buf = av_asprintf("%g", matroska->duration);
4733  if (!buf)
4734  return AVERROR(ENOMEM);
4735  av_dict_set(&s->streams[0]->metadata, DURATION,
4737 
4738  // initialization range
4739  // 5 is the offset of Cluster ID.
4740  init_range = avio_tell(s->pb) - 5;
4741  av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, init_range, 0);
4742  }
4743 
4744  // basename of the file
4745  buf = strrchr(s->url, '/');
4746  av_dict_set(&s->streams[0]->metadata, FILENAME, buf ? ++buf : s->url, 0);
4747 
4748  // track number
4749  tracks = matroska->tracks.elem;
4750  av_dict_set_int(&s->streams[0]->metadata, TRACK_NUMBER, tracks[0].num, 0);
4751 
4752  // parse the cues and populate Cue related fields
4753  if (!matroska->is_live) {
4754  ret = webm_dash_manifest_cues(s, init_range);
4755  if (ret < 0) {
4756  av_log(s, AV_LOG_ERROR, "Error parsing Cues\n");
4757  return ret;
4758  }
4759  }
4760 
4761  // use the bandwidth from the command line if it was provided
4762  if (matroska->bandwidth > 0) {
4763  av_dict_set_int(&s->streams[0]->metadata, BANDWIDTH,
4764  matroska->bandwidth, 0);
4765  }
4766  return 0;
4767 }
4768 
4769 static int webm_dash_manifest_read_packet(AVFormatContext *s, AVPacket *pkt)
4770 {
4771  return AVERROR_EOF;
4772 }
4773 
4774 #define OFFSET(x) offsetof(MatroskaDemuxContext, x)
4775 static const AVOption options[] = {
4776  { "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 },
4777  { "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 },
4778  { NULL },
4779 };
4780 
4781 static const AVClass webm_dash_class = {
4782  .class_name = "WebM DASH Manifest demuxer",
4783  .item_name = av_default_item_name,
4784  .option = options,
4785  .version = LIBAVUTIL_VERSION_INT,
4786 };
4787 
4789  .p.name = "webm_dash_manifest",
4790  .p.long_name = NULL_IF_CONFIG_SMALL("WebM DASH Manifest"),
4791  .p.priv_class = &webm_dash_class,
4792  .priv_data_size = sizeof(MatroskaDemuxContext),
4793  .flags_internal = FF_FMT_INIT_CLEANUP,
4794  .read_header = webm_dash_manifest_read_header,
4795  .read_packet = webm_dash_manifest_read_packet,
4797 };
4798 #endif
4799 
4801  .p.name = "matroska,webm",
4802  .p.long_name = NULL_IF_CONFIG_SMALL("Matroska / WebM"),
4803  .p.extensions = "mkv,mk3d,mka,mks,webm",
4804  .p.mime_type = "audio/webm,audio/x-matroska,video/webm,video/x-matroska",
4805  .priv_data_size = sizeof(MatroskaDemuxContext),
4806  .flags_internal = FF_FMT_INIT_CLEANUP,
4812 };
AVCOL_PRI_RESERVED
@ AVCOL_PRI_RESERVED
Definition: pixfmt.h:559
MatroskaCluster::timecode
uint64_t timecode
Definition: matroskadec.c:363
MATROSKA_ID_ENCODINGENCRYPTION
#define MATROSKA_ID_ENCODINGENCRYPTION
Definition: matroska.h:183
MatroskaBlockAdditionMapping::type
uint64_t type
Definition: matroskadec.c:247
avpriv_new_chapter
AVChapter * avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base, int64_t start, int64_t end, const char *title)
Add a new chapter.
Definition: demux_utils.c:42
MatroskaDemuxContext::segment_start
int64_t segment_start
Definition: matroskadec.c:397
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
MATROSKA_ID_TAGTARGETS_ATTACHUID
#define MATROSKA_ID_TAGTARGETS_ATTACHUID
Definition: matroska.h:225
MatroskaDemuxContext::pkt
AVPacket * pkt
Definition: matroskadec.c:401
MATROSKA_ID_CHAPCOUNTRY
#define MATROSKA_ID_CHAPCOUNTRY
Definition: matroska.h:268
matroska_block_addition_mapping
static EbmlSyntax matroska_block_addition_mapping[5]
Definition: matroskadec.c:438
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
ebml_read_master
static int ebml_read_master(MatroskaDemuxContext *matroska, uint64_t length, int64_t pos)
Definition: matroskadec.c:1101
ebml_read_binary
static int ebml_read_binary(AVIOContext *pb, int length, int64_t pos, EbmlBin *bin)
Definition: matroskadec.c:1073
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:109
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
MATROSKA_ID_VIDEODISPLAYUNIT
#define MATROSKA_ID_VIDEODISPLAYUNIT
Definition: matroska.h:125
mkv_image_mime_tags
static const CodecMime mkv_image_mime_tags[]
Definition: matroskadec.c:803
matroska_parse_laces
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:3436
MATROSKA_ID_CODECPRIVATE
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:88
MATROSKA_ID_TRACKNUMBER
#define MATROSKA_ID_TRACKNUMBER
Definition: matroska.h:77
MatroskaTag
Definition: matroskadec.c:316
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
MATROSKA_ID_TRACKFLAGVISUALIMPAIRED
#define MATROSKA_ID_TRACKFLAGVISUALIMPAIRED
Definition: matroska.h:101
MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_RL
@ MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_RL
Definition: matroska.h:319
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
MATROSKA_ID_CHAPSTRING
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:266
MATROSKA_BLOCK_ADD_ID_OPAQUE
#define MATROSKA_BLOCK_ADD_ID_OPAQUE
Definition: matroska.h:368
MATROSKA_ID_ENCODINGSIGHASHALGO
#define MATROSKA_ID_ENCODINGSIGHASHALGO
Definition: matroska.h:188
MatroskaTrack::codec_priv
EbmlBin codec_priv
Definition: matroskadec.c:257
avpriv_packet_list_put
int avpriv_packet_list_put(PacketList *packet_buffer, AVPacket *pkt, int(*copy)(AVPacket *dst, const AVPacket *src), int flags)
Append an AVPacket to the list.
Definition: avpacket.c:541
MATROSKA_ID_TAGTARGETS
#define MATROSKA_ID_TAGTARGETS
Definition: matroska.h:220
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVSphericalProjection
AVSphericalProjection
Projection of the video surface(s) on a sphere.
Definition: spherical.h:47
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
EbmlSyntax::id
uint32_t id
Definition: matroskadec.c:112
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
MATROSKA_ID_CLUSTERTIMECODE
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:235
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:34
avpriv_packet_list_get
int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: avpacket.c:580
level
uint8_t level
Definition: svq3.c:204
matroska_attachment
static EbmlSyntax matroska_attachment[]
Definition: matroskadec.c:637
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:443
ebml_header
static EbmlSyntax ebml_header[]
Definition: matroskadec.c:443
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:46
MatroskaDemuxContext::current_id
uint32_t current_id
Definition: matroskadec.c:380
MatroskaDemuxContext::bandwidth
int bandwidth
Definition: matroskadec.c:427
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:218
MATROSKA_ID_TITLE
#define MATROSKA_ID_TITLE
Definition: matroska.h:67
r
const char * r
Definition: vf_curves.c:126
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
uid
UID uid
Definition: mxfenc.c:2421
opt.h
matroska_parse_block_additional
static int matroska_parse_block_additional(MatroskaDemuxContext *matroska, MatroskaTrack *track, AVPacket *pkt, const uint8_t *data, int size, uint64_t id)
Definition: matroskadec.c:3830
matroska_parse_tracks
static int matroska_parse_tracks(AVFormatContext *s)
Definition: matroskadec.c:3075
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVSphericalMapping::projection
enum AVSphericalProjection projection
Projection type.
Definition: spherical.h:82
MatroskaTrack::operation
MatroskaTrackOperation operation
Definition: matroskadec.c:271
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
AVSphericalMapping::bound_bottom
uint32_t bound_bottom
Distance from the bottom edge.
Definition: spherical.h:166
MATROSKA_ID_CODECDECODEALL
#define MATROSKA_ID_CODECDECODEALL
Definition: matroska.h:92
ff_rm_reorder_sipr_data
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
MATROSKA_ID_VIDEOCOLORMASTERINGMETA
#define MATROSKA_ID_VIDEOCOLORMASTERINGMETA
Definition: matroska.h:149
ebml_read_ascii
static int ebml_read_ascii(AVIOContext *pb, int size, const char *default_value, char **str)
Definition: matroskadec.c:1042
matroska_parse_block
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, MatroskaBlockMore *blockmore, int nb_blockmore, int64_t cluster_pos, int64_t discard_padding)
Definition: matroskadec.c:4040
Ebml
Definition: matroskadec.c:139
EBML_BIN
@ EBML_BIN
Definition: matroskadec.c:94
MATROSKA_ID_CHAPTERFLAGENABLED
#define MATROSKA_ID_CHAPTERFLAGENABLED
Definition: matroska.h:275
MatroskaTrackPlane
Definition: matroskadec.c:235
color
Definition: vf_paletteuse.c:511
EBML_MAX_DEPTH
#define EBML_MAX_DEPTH
Definition: matroska.h:381
matroska_parse_prores
static int matroska_parse_prores(MatroskaTrack *track, uint8_t **data, int *size)
Definition: matroskadec.c:3694
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
GetByteContext
Definition: bytestream.h:33
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVFMT_FLAG_IGNIDX
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1408
segment_start
static int segment_start(AVFormatContext *s, int write_header)
Definition: segment.c:231
EBML_ID_EBMLMAXSIZELENGTH
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:38
MatroskaTrack::audio
MatroskaTrackAudio audio
Definition: matroskadec.c:270
MatroskaAttachment::description
char * description
Definition: matroskadec.c:290
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:194
MatroskaTags
Definition: matroskadec.c:332
MatroskaAttachment::bin
EbmlBin bin
Definition: matroskadec.c:292
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
MATROSKA_ID_TRACKOPERATION
#define MATROSKA_ID_TRACKOPERATION
Definition: matroska.h:82
ebml_read_num
static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb, int max_size, uint64_t *number, int eof_forbidden)
Definition: matroskadec.c:900
matroska_parse_frame
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, MatroskaBlockMore *blockmore, int nb_blockmore, int64_t discard_padding)
Definition: matroskadec.c:3919
MATROSKA_VIDEO_FIELDORDER_PROGRESSIVE
@ MATROSKA_VIDEO_FIELDORDER_PROGRESSIVE
Definition: matroska.h:304
MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS
#define MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS
Definition: matroska.h:102
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
EBML_STOP
@ EBML_STOP
Definition: matroskadec.c:97
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:814
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:200
MATROSKA_ID_VIDEOPIXELWIDTH
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:119
TTA_EXTRADATA_SIZE
#define TTA_EXTRADATA_SIZE
Definition: matroskadec.c:2579
MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_LR
@ MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_LR
Definition: matroska.h:318
MATROSKA_ID_AUDIOSAMPLINGFREQ
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:169
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
EbmlList
Definition: matroskadec.c:126
av_int2double
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
matrix
Definition: vc1dsp.c:42
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
matroska_resync
static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
Definition: matroskadec.c:853
MatroskaSeekhead::pos
uint64_t pos
Definition: matroskadec.c:339
MATROSKA_VIDEO_PROJECTION_TYPE_RECTANGULAR
@ MATROSKA_VIDEO_PROJECTION_TYPE_RECTANGULAR
Definition: matroska.h:354
MatroskaTrack::name
char * name
Definition: matroskadec.c:255
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
Ebml::version
uint64_t version
Definition: matroskadec.c:140
matroska_track_combine_planes
static EbmlSyntax matroska_track_combine_planes[2]
Definition: matroskadec.c:438
Ebml::max_size
uint64_t max_size
Definition: matroskadec.c:141
MATROSKA_ID_DISCARDPADDING
#define MATROSKA_ID_DISCARDPADDING
Definition: matroska.h:250
MATROSKA_VIDEO_FIELDORDER_BB
@ MATROSKA_VIDEO_FIELDORDER_BB
Definition: matroska.h:307
matroska_cluster_parsing
static EbmlSyntax matroska_cluster_parsing[8]
Definition: matroskadec.c:441
MatroskaTrackAudio::sub_packet_cnt
int sub_packet_cnt
Definition: matroskadec.c:229
EbmlSyntax::n
const struct EbmlSyntax * n
Definition: matroskadec.c:122
MATROSKA_ID_EDITIONFLAGORDERED
#define MATROSKA_ID_EDITIONFLAGORDERED
Definition: matroska.h:272
MATROSKA_ID_DURATION
#define MATROSKA_ID_DURATION
Definition: matroska.h:66
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT
Definition: matroska.h:141
MatroskaTrackEncoding::scope
uint64_t scope
Definition: matroskadec.c:158
matroska_read_header
static int matroska_read_header(AVFormatContext *s)
Definition: matroskadec.c:3248
matroska_find_track_by_num
static MatroskaTrack * matroska_find_track_by_num(MatroskaDemuxContext *matroska, uint64_t num)
Definition: matroskadec.c:1646
MATROSKA_ID_VIDEOCOLORPRIMARIES
#define MATROSKA_ID_VIDEOCOLORPRIMARIES
Definition: matroska.h:145
matroska_chapters
static EbmlSyntax matroska_chapters[2]
Definition: matroskadec.c:439
MATROSKA_VIDEO_DISPLAYUNIT_PIXELS
@ MATROSKA_VIDEO_DISPLAYUNIT_PIXELS
Definition: matroska.h:332
dict_internal.h
av_unused
#define av_unused
Definition: attributes.h:131
MATROSKA_ID_ENCODINGSIGNATURE
#define MATROSKA_ID_ENCODINGSIGNATURE
Definition: matroska.h:190
MATROSKA_ID_SEGMENT
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:52
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
The stream should be chosen by default among other streams of the same type, unless the user has expl...
Definition: avformat.h:621
CUES_START
#define CUES_START
Definition: matroska.h:429
out_size
int out_size
Definition: movenc.c:55
MATROSKA_ID_BLKADDIDTYPE
#define MATROSKA_ID_BLKADDIDTYPE
Definition: matroska.h:195
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
MatroskaMasteringMeta::white_y
double white_y
Definition: matroskadec.c:172
MatroskaTagTarget::trackuid
uint64_t trackuid
Definition: matroskadec.c:327
MatroskaBlock::discard_padding
int64_t discard_padding
Definition: matroskadec.c:358
AV_CODEC_ID_RA_144
@ AV_CODEC_ID_RA_144
Definition: codec_id.h:425
ff_metadata_conv
void ff_metadata_conv(AVDictionary **pm, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:26
MATROSKA_ID_CHAPTERS
#define MATROSKA_ID_CHAPTERS
Definition: matroska.h:62
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
MATROSKA_ID_VIDEOCOLOR_BY
#define MATROSKA_ID_VIDEOCOLOR_BY
Definition: matroska.h:155
pixdesc.h
rmsipr.h
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:373
MATROSKA_ID_BLOCKDURATION
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:247
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
MATROSKA_ID_VIDEOCOLORRANGE
#define MATROSKA_ID_VIDEOCOLORRANGE
Definition: matroska.h:142
AVFormatContext::strict_std_compliance
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1612
MATROSKA_ID_BLOCK
#define MATROSKA_ID_BLOCK
Definition: matroska.h:246
MatroskaDemuxContext::unknown_count
int unknown_count
Definition: matroskadec.c:382
av_display_matrix_flip
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:66
AVPacket::data
uint8_t * data
Definition: packet.h:522
MatroskaTag::string
char * string
Definition: matroskadec.c:318
MATROSKA_ID_TRACKDEFAULTDURATION
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:108
MatroskaDemuxContext::num_levels
int num_levels
Definition: matroskadec.c:379
matroska_track_encodings
static EbmlSyntax matroska_track_encodings[2]
Definition: matroskadec.c:437
matroska_tags
static EbmlSyntax matroska_tags[2]
Definition: matroskadec.c:440
MATROSKA_ID_TAGTARGETS_TYPE
#define MATROSKA_ID_TAGTARGETS_TYPE
Definition: matroska.h:221
MatroskaTrackAudio::coded_framesize
int coded_framesize
Definition: matroskadec.c:225
MatroskaSeekhead
Definition: matroskadec.c:337
AVCodecParameters::seek_preroll
int seek_preroll
Audio only.
Definition: codec_par.h:214
AVOption
AVOption.
Definition: opt.h:346
matroska_video_stereo_plane
static const char *const matroska_video_stereo_plane[MATROSKA_VIDEO_STEREO_PLANE_COUNT]
Definition: matroskadec.c:821
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
matroska_read_seek
static int matroska_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: matroskadec.c:4266
CountedElement::u
uint64_t u
Definition: matroskadec.c:103
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
matroska_read_close
static int matroska_read_close(AVFormatContext *s)
Definition: matroskadec.c:4334
PacketList
Definition: packet_internal.h:33
spherical.h
MATROSKA_ID_ENCODINGSCOPE
#define MATROSKA_ID_ENCODINGSCOPE
Definition: matroska.h:177
data
const char data[16]
Definition: mxf.c:148
MATROSKA_VIDEO_INTERLACE_FLAG_INTERLACED
@ MATROSKA_VIDEO_INTERLACE_FLAG_INTERLACED
Definition: matroska.h:299
MatroskaTrack::end_timecode
int64_t end_timecode
Definition: matroskadec.c:277
AV_CODEC_ID_ALAC
@ AV_CODEC_ID_ALAC
Definition: codec_id.h:456
MATROSKA_ID_DATEUTC
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:70
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: defs.h:59
MATROSKA_ID_VIDEOCOLORCHROMASUBHORZ
#define MATROSKA_ID_VIDEOCOLORCHROMASUBHORZ
Definition: matroska.h:136
MatroskaTag::sub
EbmlList sub
Definition: matroskadec.c:321
MatroskaTrack::video
MatroskaTrackVideo video
Definition: matroskadec.c:269
AVIOContext::error
int error
contains the error code or 0 if no error happened
Definition: avio.h:239
AAC_MAX_EXTRADATA_SIZE
#define AAC_MAX_EXTRADATA_SIZE
Definition: matroskadec.c:2578
MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_LR
@ MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_LR
Definition: matroska.h:326
matroska.h
MatroskaTrackEncoding
Definition: matroskadec.c:157
ff_get_wav_header
int ff_get_wav_header(void *logctx, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:94
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
mkv_parse_video_codec
static int mkv_parse_video_codec(MatroskaTrack *track, AVCodecParameters *par, const MatroskaDemuxContext *matroska, int *extradata_offset)
Definition: matroskadec.c:2856
MATROSKA_ID_VIDEOPIXELCROPT
#define MATROSKA_ID_VIDEOPIXELCROPT
Definition: matroska.h:122
aac_profiles
static const AVProfile aac_profiles[]
Definition: audiotoolboxenc.c:605
MATROSKA_ID_VIDEOPIXELCROPB
#define MATROSKA_ID_VIDEOPIXELCROPB
Definition: matroska.h:121
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...
Definition: display.c:51
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
MATROSKA_ID_VIDEOCOLORCBSUBVERT
#define MATROSKA_ID_VIDEOCOLORCBSUBVERT
Definition: matroska.h:139
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AV_SPHERICAL_EQUIRECTANGULAR_TILE
@ AV_SPHERICAL_EQUIRECTANGULAR_TILE
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:68
MatroskaTrackVideoColor
Definition: matroskadec.c:177
mkv_parse_video_projection
static int mkv_parse_video_projection(AVStream *st, const MatroskaTrack *track, void *logctx)
Definition: matroskadec.c:2388
mathematics.h
MATROSKA_COLOUR_CHROMASITINGHORZ_UNDETERMINED
@ MATROSKA_COLOUR_CHROMASITINGHORZ_UNDETERMINED
Definition: matroska.h:340
MATROSKA_ID_CUES
#define MATROSKA_ID_CUES
Definition: matroska.h:57
AVDictionary
Definition: dict.c:34
ffio_init_read_context
void ffio_init_read_context(FFIOContext *s, const uint8_t *buffer, int buffer_size)
Wrap a buffer in an AVIOContext for reading.
Definition: aviobuf.c:98
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:452
MatroskaTrackEncoding::type
uint64_t type
Definition: matroskadec.c:159
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
matroska_blockadditions
static EbmlSyntax matroska_blockadditions[2]
Definition: matroskadec.c:441
MATROSKA_ID_CUETIME
#define MATROSKA_ID_CUETIME
Definition: matroska.h:202
MatroskaTrackVideoProjection
Definition: matroskadec.c:194
AV_PROFILE_ARIB_PROFILE_C
#define AV_PROFILE_ARIB_PROFILE_C
Definition: defs.h:187
MatroskaMasteringMeta::b_y
double b_y
Definition: matroskadec.c:170
matroska_read_packet
static int matroska_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskadec.c:4246
MATROSKA_ID_CUERELATIVEPOSITION
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:208
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:245
AV_SPHERICAL_EQUIRECTANGULAR
@ AV_SPHERICAL_EQUIRECTANGULAR
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition: spherical.h:52
intfloat.h
MatroskaDemuxContext::title
char * title
Definition: matroskadec.c:386
MatroskaTrackVideoColor::primaries
uint64_t primaries
Definition: matroskadec.c:188
MATROSKA_ID_CHAPLANG
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:267
MatroskaTrackVideoProjection::yaw
double yaw
Definition: matroskadec.c:197
ebml_parse
static int ebml_parse(MatroskaDemuxContext *matroska, EbmlSyntax *syntax, void *data)
Definition: matroskadec.c:1245
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:484
MATROSKA_ID_CUEDURATION
#define MATROSKA_ID_CUEDURATION
Definition: matroska.h:209
FFIOContext
Definition: avio_internal.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
avpriv_update_cur_dts
void avpriv_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: seek.c:35
MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_LR
@ MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_LR
Definition: matroska.h:320
MatroskaTrack::stream
AVStream * stream
Definition: matroskadec.c:276
AVIndexEntry
Definition: avformat.h:602
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:431
MATROSKA_ID_VIDEOCOLORBITSPERCHANNEL
#define MATROSKA_ID_VIDEOCOLORBITSPERCHANNEL
Definition: matroska.h:135
matroska_segment
static EbmlSyntax matroska_segment[9]
Definition: matroskadec.c:436
AV_CODEC_ID_BIN_DATA
@ AV_CODEC_ID_BIN_DATA
Definition: codec_id.h:589
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
matroska_metadata_creation_time
static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
Definition: matroskadec.c:2121
MatroskaBlock::duration
uint64_t duration
Definition: matroskadec.c:353
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:204
MatroskaDemuxContext
Definition: matroskadec.c:373
MatroskaTrackVideo::alpha_mode
uint64_t alpha_mode
Definition: matroskadec.c:213
MatroskaTrackVideo::display_unit
uint64_t display_unit
Definition: matroskadec.c:209
MATROSKA_VIDEO_DISPLAYUNIT_UNKNOWN
@ MATROSKA_VIDEO_DISPLAYUNIT_UNKNOWN
Definition: matroska.h:336
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX
Definition: matroska.h:158
update_pos
#define update_pos(td, mb_y, mb_x)
Definition: vp8.c:2385
MATROSKA_VIDEO_STEREOMODE_TYPE_ANAGLYPH_GREEN_MAG
@ MATROSKA_VIDEO_STEREOMODE_TYPE_ANAGLYPH_GREEN_MAG
Definition: matroska.h:325
MatroskaTrack::flag_default
uint64_t flag_default
Definition: matroskadec.c:261
matroska_track_encoding_compression
static EbmlSyntax matroska_track_encoding_compression[]
Definition: matroskadec.c:542
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
MATROSKA_ID_VIDEOCOLOR_WHITEY
#define MATROSKA_ID_VIDEOCOLOR_WHITEY
Definition: matroska.h:157
MatroskaTrack::block_addition_mappings
EbmlList block_addition_mappings
Definition: matroskadec.c:281
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
CodecMime
Definition: internal.h:53
primaries
enum AVColorPrimaries primaries
Definition: mediacodec_wrapper.c:2664
AV_PROFILE_ARIB_PROFILE_A
#define AV_PROFILE_ARIB_PROFILE_A
Definition: defs.h:186
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:613
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:201
ebml_read_sint
static int ebml_read_sint(AVIOContext *pb, int size, int64_t default_value, int64_t *num)
Definition: matroskadec.c:999
NOTHING
#define NOTHING(STEREOMODETYPE, WDIV, HDIV, WEBM)
ebml_syntax
static EbmlSyntax ebml_syntax[3]
Definition: matroskadec.c:436
MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
#define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
Definition: matroska.h:170
MATROSKA_BLOCK_ADD_ID_TYPE_DEFAULT
@ MATROSKA_BLOCK_ADD_ID_TYPE_DEFAULT
Definition: matroska.h:361
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:853
mpeg4audio.h
MATROSKA_ID_VIDEOPROJECTIONPRIVATE
#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE
Definition: matroska.h:163
MatroskaTrack::ms_compat
int ms_compat
Definition: matroskadec.c:278
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:197
MatroskaTag::def
uint64_t def
Definition: matroskadec.c:320
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:47
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:423
MatroskaTrackPlane::uid
uint64_t uid
Definition: matroskadec.c:236
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:329
MatroskaDemuxContext::current_cluster
MatroskaCluster current_cluster
Definition: matroskadec.c:419
MATROSKA_VIDEO_STEREOMODE_TYPE_MONO
@ MATROSKA_VIDEO_STEREOMODE_TYPE_MONO
Definition: matroska.h:313
MATROSKA_ID_ENCODINGSIGALGO
#define MATROSKA_ID_ENCODINGSIGALGO
Definition: matroska.h:187
MATROSKA_ID_VIDEOASPECTRATIO
#define MATROSKA_ID_VIDEOASPECTRATIO
Definition: matroska.h:130
fail
#define fail()
Definition: checkasm.h:179
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2435
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
MatroskaMasteringMeta
Definition: matroskadec.c:164
MatroskaDemuxContext::level1_elems
MatroskaLevel1Element level1_elems[64]
Definition: matroskadec.c:416
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
MATROSKA_ID_CHAPTERDISPLAY
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:265
inflate
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:194
av_add_index_entry
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: seek.c:120
MATROSKA_ID_TRACKUID
#define MATROSKA_ID_TRACKUID
Definition: matroska.h:78
MATROSKA_ID_ENCODINGSIGKEYID
#define MATROSKA_ID_ENCODINGSIGKEYID
Definition: matroska.h:189
EBML_ID_DOCTYPEVERSION
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:40
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
MATROSKA_COLOUR_CHROMASITINGVERT_NB
@ MATROSKA_COLOUR_CHROMASITINGVERT_NB
Definition: matroska.h:350
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
MatroskaCluster::pos
int64_t pos
Definition: matroskadec.c:364
MatroskaTrack
Definition: matroskadec.c:251
EbmlBin::buf
AVBufferRef * buf
Definition: matroskadec.c:134
ff_matroska_video_stereo_mode
const char *const ff_matroska_video_stereo_mode[MATROSKA_VIDEO_STEREOMODE_TYPE_NB]
Definition: matroska.c:130
mkv_parse_block_addition_mappings
static int mkv_parse_block_addition_mappings(AVFormatContext *s, AVStream *st, MatroskaTrack *track)
Definition: matroskadec.c:2488
AVChapter
Definition: avformat.h:1214
MatroskaBlock
Definition: matroskadec.c:352
matroska_probe
static int matroska_probe(const AVProbeData *p)
Definition: matroskadec.c:1599
AV_DISPOSITION_FORCED
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:654
MATROSKA_BLOCK_ADD_ID_TYPE_ITU_T_T35
@ MATROSKA_BLOCK_ADD_ID_TYPE_ITU_T_T35
Definition: matroska.h:363
MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_RL
@ MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_RL
Definition: matroska.h:317
matroska_segments
static EbmlSyntax matroska_segments[]
Definition: matroskadec.c:757
matroska_doctypes
static const char *const matroska_doctypes[]
Definition: matroskadec.c:827
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
MatroskaTag::lang
char * lang
Definition: matroskadec.c:319
mka_parse_audio_codec
static int mka_parse_audio_codec(MatroskaTrack *track, AVCodecParameters *par, const MatroskaDemuxContext *matroska, AVFormatContext *s, int *extradata_offset)
Definition: matroskadec.c:2582
MATROSKA_ID_VIDEOALPHAMODE
#define MATROSKA_ID_VIDEOALPHAMODE
Definition: matroska.h:129
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:441
mkv_parse_video_color
static int mkv_parse_video_color(AVStream *st, const MatroskaTrack *track)
Definition: matroskadec.c:2263
EBML_ID_DOCTYPE
#define EBML_ID_DOCTYPE
Definition: matroska.h:39
MatroskaTrackVideoColor::mastering_meta
MatroskaMasteringMeta mastering_meta
Definition: matroskadec.c:191
MatroskaTrackOperation
Definition: matroskadec.c:240
av_reduce
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
EbmlList::elem
void * elem
Definition: matroskadec.c:129
MATROSKA_ID_VIDEOCOLOR_WHITEX
#define MATROSKA_ID_VIDEOCOLOR_WHITEX
Definition: matroska.h:156
AVRational::num
int num
Numerator.
Definition: rational.h:59
EbmlSyntax::type
uint8_t type
Definition: matroskadec.c:113
MatroskaSeekhead::id
uint64_t id
Definition: matroskadec.c:338
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:203
MATROSKA_TRACK_TYPE_METADATA
@ MATROSKA_TRACK_TYPE_METADATA
Definition: matroska.h:287
AV_CODEC_ID_ATRAC3
@ AV_CODEC_ID_ATRAC3
Definition: codec_id.h:471
matroska_tag
static EbmlSyntax matroska_tag[3]
Definition: matroskadec.c:440
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
MatroskaTrackOperation::combine_planes
EbmlList combine_planes
Definition: matroskadec.c:241
MATROSKA_VIDEO_FIELDORDER_TT
@ MATROSKA_VIDEO_FIELDORDER_TT
Definition: matroska.h:305
MatroskaDemuxContext::skip_to_keyframe
int skip_to_keyframe
Definition: matroskadec.c:409
MatroskaDemuxContext::levels
MatroskaLevel levels[EBML_MAX_DEPTH]
Definition: matroskadec.c:378
AV_PKT_DATA_WEBVTT_SETTINGS
@ AV_PKT_DATA_WEBVTT_SETTINGS
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: packet.h:203
MatroskaVideoStereoModeType
MatroskaVideoStereoModeType
Definition: matroska.h:312
AV_CODEC_ID_SIPR
@ AV_CODEC_ID_SIPR
Definition: codec_id.h:481
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
CountedElement::f
double f
Definition: matroskadec.c:105
MATROSKA_ID_BLKADDIDNAME
#define MATROSKA_ID_BLKADDIDNAME
Definition: matroska.h:194
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:332
description
Tag description
Definition: snow.txt:206
MATROSKA_ID_BLOCKADDITIONAL
#define MATROSKA_ID_BLOCKADDITIONAL
Definition: matroska.h:242
SKIP_THRESHOLD
#define SKIP_THRESHOLD
Definition: matroskadec.c:84
ebml_parse_nest
static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax, void *data)
Definition: matroskadec.c:1155
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:760
pkt
AVPacket * pkt
Definition: movenc.c:59
matroska_parse_seekhead_entry
static int matroska_parse_seekhead_entry(MatroskaDemuxContext *matroska, int64_t pos)
Definition: matroskadec.c:1898
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
MatroskaTrackAudio::buf_timecode
uint64_t buf_timecode
Definition: matroskadec.c:231
MATROSKA_ID_TRACKCONTENTENCODING
#define MATROSKA_ID_TRACKCONTENTENCODING
Definition: matroska.h:110
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
MatroskaTrackVideoColor::bits_per_channel
uint64_t bits_per_channel
Definition: matroskadec.c:179
EBML_ID_VOID
#define EBML_ID_VOID
Definition: matroska.h:44
MATROSKA_ID_TAGDEFAULT_BUG
#define MATROSKA_ID_TAGDEFAULT_BUG
Definition: matroska.h:219
MATROSKA_ID_CODECDOWNLOADURL
#define MATROSKA_ID_CODECDOWNLOADURL
Definition: matroska.h:91
MATROSKA_ID_VIDEOFIELDORDER
#define MATROSKA_ID_VIDEOFIELDORDER
Definition: matroska.h:127
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
AVCodecTag
Definition: internal.h:48
matroska_info
static EbmlSyntax matroska_info[]
Definition: matroskadec.c:460
MATROSKA_ID_VIDEOPIXELCROPR
#define MATROSKA_ID_VIDEOPIXELCROPR
Definition: matroska.h:124
MATROSKA_COLOUR_CHROMASITINGHORZ_NB
@ MATROSKA_COLOUR_CHROMASITINGHORZ_NB
Definition: matroska.h:343
MATROSKA_ID_TAGS
#define MATROSKA_ID_TAGS
Definition: matroska.h:58
AV_CODEC_ID_TTA
@ AV_CODEC_ID_TTA
Definition: codec_id.h:462
matroska_index_entry
static EbmlSyntax matroska_index_entry[3]
Definition: matroskadec.c:440
AV_CODEC_ID_TTF
@ AV_CODEC_ID_TTF
Definition: codec_id.h:578
MatroskaDemuxContext::muxingapp
char * muxingapp
Definition: matroskadec.c:387
AVCOL_PRI_RESERVED0
@ AVCOL_PRI_RESERVED0
Definition: pixfmt.h:556
duration
int64_t duration
Definition: movenc.c:64
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: defs.h:199
EBML_ID_EBMLMAXIDLENGTH
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:37
mask
static const uint16_t mask[17]
Definition: lzw.c:38
AVCodecParameters::frame_size
int frame_size
Audio only.
Definition: codec_par.h:195
MatroskaTrackVideoColor::max_cll
uint64_t max_cll
Definition: matroskadec.c:189
matroska_parse_cluster
static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:4192
av_dict_get
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:62
EbmlSyntax::list_elem_size
size_t list_elem_size
Definition: matroskadec.c:115
ff_add_attached_pic
int ff_add_attached_pic(AVFormatContext *s, AVStream *st, AVIOContext *pb, AVBufferRef **buf, int size)
Add an attached pic to an AVStream.
Definition: demux_utils.c:116
ebml_read_float
static int ebml_read_float(AVIOContext *pb, int size, double default_value, double *num)
Definition: matroskadec.c:1022
av_fast_realloc
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:495
matroska_find_level1_elem
static MatroskaLevel1Element * matroska_find_level1_elem(MatroskaDemuxContext *matroska, uint32_t id, int64_t pos)
Definition: matroskadec.c:1211
MATROSKA_COLOUR_CHROMASITINGVERT_UNDETERMINED
@ MATROSKA_COLOUR_CHROMASITINGVERT_UNDETERMINED
Definition: matroska.h:347
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
intreadwrite.h
MATROSKA_ID_FILEUID
#define MATROSKA_ID_FILEUID
Definition: matroska.h:258
MatroskaMasteringMeta::b_x
double b_x
Definition: matroskadec.c:169
s
#define s(width, name)
Definition: cbs_vp9.c:198
MATROSKA_VIDEO_INTERLACE_FLAG_PROGRESSIVE
@ MATROSKA_VIDEO_INTERLACE_FLAG_PROGRESSIVE
Definition: matroska.h:300
Ebml::id_length
uint64_t id_length
Definition: matroskadec.c:142
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:98
MatroskaTag::name
char * name
Definition: matroskadec.c:317
MatroskaLevel1Element::pos
int64_t pos
Definition: matroskadec.c:368
MatroskaDemuxContext::num_level1_elems
int num_level1_elems
Definition: matroskadec.c:417
MatroskaTagTarget::attachuid
uint64_t attachuid
Definition: matroskadec.c:329
CodecTags::str
char str[22]
Definition: matroska.h:376
MatroskaTrackVideo::field_order
uint64_t field_order
Definition: matroskadec.c:211
MATROSKA_ID_VIDEODISPLAYWIDTH
#define MATROSKA_ID_VIDEODISPLAYWIDTH
Definition: matroska.h:117
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
MATROSKA_VIDEO_FIELDORDER_BT
@ MATROSKA_VIDEO_FIELDORDER_BT
Definition: matroska.h:309
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
MatroskaDemuxContext::duration
double duration
Definition: matroskadec.c:385
MatroskaTrackVideo::pixel_width
uint64_t pixel_width
Definition: matroskadec.c:206
AVSphericalMapping::bound_top
uint32_t bound_top
Distance from the top edge.
Definition: spherical.h:164
MATROSKA_ID_TAGNAME
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:215
MatroskaChapter
Definition: matroskadec.c:297
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
EbmlBin::size
int size
Definition: matroskadec.c:133
MATROSKA_ID_TAG
#define MATROSKA_ID_TAG
Definition: matroska.h:213
av_channel_layout_from_mask
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:242
MatroskaTrackAudio::sub_packet_size
int sub_packet_size
Definition: matroskadec.c:228
TRACK_NUMBER
#define TRACK_NUMBER
Definition: matroska.h:436
MATROSKA_ID_TIMECODESCALE
#define MATROSKA_ID_TIMECODESCALE
Definition: matroska.h:65
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
matroska_cluster_enter
static EbmlSyntax matroska_cluster_enter[]
Definition: matroskadec.c:797
MATROSKA_ID_CLUSTERPOSITION
#define MATROSKA_ID_CLUSTERPOSITION
Definition: matroska.h:236
bits
uint8_t bits
Definition: vp3data.h:128
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:604
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
MATROSKA_ID_CUETRACKPOSITION
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:203
CountedElement::el
union CountedElement::@322 el
MATROSKA_ID_SEEKENTRY
#define MATROSKA_ID_SEEKENTRY
Definition: matroska.h:228
matroska_decode_buffer
static int matroska_decode_buffer(uint8_t **buf, int *buf_size, MatroskaTrack *track)
Definition: matroskadec.c:1660
MatroskaDemuxContext::attachments
EbmlList attachments
Definition: matroskadec.c:390
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
MATROSKA_ID_TRACKTYPE
#define MATROSKA_ID_TRACKTYPE
Definition: matroska.h:79
AVPacketSideData::data
uint8_t * data
Definition: packet.h:374
CLUSTER_KEYFRAME
#define CLUSTER_KEYFRAME
Definition: matroska.h:434
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:107
MatroskaTrack::encodings
EbmlList encodings
Definition: matroskadec.c:272
MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_LR
@ MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_LR
Definition: matroska.h:322
MATROSKA_ID_SEGMENTUID
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:71
channels
channels
Definition: aptx.h:31
EbmlType
EbmlType
Definition: matroskadec.c:87
matroska_track
static EbmlSyntax matroska_track[33]
Definition: matroskadec.c:437
mkv_parse_subtitle_codec
static int mkv_parse_subtitle_codec(MatroskaTrack *track, AVStream *st, AVCodecParameters *par, const MatroskaDemuxContext *matroska)
Definition: matroskadec.c:3024
MATROSKA_ID_TRACKBLKADDMAPPING
#define MATROSKA_ID_TRACKBLKADDMAPPING
Definition: matroska.h:113
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
MatroskaTrackVideo::interlaced
uint64_t interlaced
Definition: matroskadec.c:210
matroska_track_video_projection
static EbmlSyntax matroska_track_video_projection[]
Definition: matroskadec.c:503
MatroskaTrackAudio::sub_packet_h
int sub_packet_h
Definition: matroskadec.c:226
AV_PKT_DATA_STEREO3D
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: packet.h:115
av_rescale_q
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
WAVPACK_EXTRADATA_SIZE
#define WAVPACK_EXTRADATA_SIZE
Definition: matroskadec.c:2580
MATROSKA_ID_INFO
#define MATROSKA_ID_INFO
Definition: matroska.h:55
Ebml::doctype_version
uint64_t doctype_version
Definition: matroskadec.c:144
MatroskaTrackEncryption::algo
uint64_t algo
Definition: matroskadec.c:153
MatroskaTrackVideo::color
EbmlList color
Definition: matroskadec.c:214
MATROSKA_ID_AUDIOCHANNELS
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:173
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:386
MATROSKA_ID_BLKADDIDVALUE
#define MATROSKA_ID_BLKADDIDVALUE
Definition: matroska.h:193
MatroskaTrackVideoColor::chroma_siting_vert
uint64_t chroma_siting_vert
Definition: matroskadec.c:185
MATROSKA_VIDEO_STEREOMODE_TYPE_ANAGLYPH_CYAN_RED
@ MATROSKA_VIDEO_STEREOMODE_TYPE_ANAGLYPH_CYAN_RED
Definition: matroska.h:323
key
const char * key
Definition: hwcontext_opencl.c:189
MatroskaAttachment::stream
AVStream * stream
Definition: matroskadec.c:294
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
MatroskaTagTarget::type
char * type
Definition: matroskadec.c:325
MatroskaDemuxContext::seekhead
EbmlList seekhead
Definition: matroskadec.c:394
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
av_content_light_metadata_alloc
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
Definition: mastering_display_metadata.c:45
MATROSKA_ID_VIDEOSTEREOMODE
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:128
MatroskaDemuxContext::queue
PacketList queue
Definition: matroskadec.c:404
MatroskaTrack::type
uint64_t type
Definition: matroskadec.c:254
matroska_clear_queue
static void matroska_clear_queue(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:3431
AV_CODEC_ID_ARIB_CAPTION
@ AV_CODEC_ID_ARIB_CAPTION
Definition: codec_id.h:574
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:182
MATROSKA_ID_VIDEOCOLORSPACE
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:131
AV_CODEC_ID_PNG
@ AV_CODEC_ID_PNG
Definition: codec_id.h:113
time_internal.h
if
if(ret)
Definition: filter_design.txt:179
MATROSKA_ID_TRACKNAME
#define MATROSKA_ID_TRACKNAME
Definition: matroska.h:95
FFFormatContext
Definition: internal.h:70
MatroskaTrackCompression::algo
uint64_t algo
Definition: matroskadec.c:148
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:392
AV_CODEC_ID_WEBVTT
@ AV_CODEC_ID_WEBVTT
Definition: codec_id.h:567
matroska_convert_tag
static void matroska_convert_tag(AVFormatContext *s, EbmlList *list, AVDictionary **metadata, char *prefix)
Definition: matroskadec.c:1798
EBML_ID_DOCTYPEREADVERSION
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:41
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
matroska_parse_content_encodings
static int matroska_parse_content_encodings(MatroskaTrackEncoding *encodings, unsigned nb_encodings, MatroskaTrack *track, char **key_id_base64, void *logctx)
Definition: matroskadec.c:2026
MATROSKA_ID_CODECSTATE
#define MATROSKA_ID_CODECSTATE
Definition: matroska.h:249
internal.h
MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED
#define MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED
Definition: matroska.h:100
AVCOL_TRC_RESERVED0
@ AVCOL_TRC_RESERVED0
Definition: pixfmt.h:581
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:505
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM
@ MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM
Definition: matroska.h:316
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
MatroskaAttachment::filename
char * filename
Definition: matroskadec.c:289
MATROSKA_ID_ENCODINGENCALGO
#define MATROSKA_ID_ENCODINGENCALGO
Definition: matroska.h:185
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
MATROSKA_ID_BLOCKGROUP
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:238
MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN
#define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN
Definition: matroska.h:159
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:782
NULL
#define NULL
Definition: coverity.c:32
MATROSKA_ID_ATTACHMENTS
#define MATROSKA_ID_ATTACHMENTS
Definition: matroska.h:60
STEREOMODE_STEREO3D_MAPPING
#define STEREOMODE_STEREO3D_MAPPING(MAP, MKV_ONLY)
Definition: matroska.h:401
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
MATROSKA_ID_CHAPTERATOM
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:262
ebml_parse_id
static EbmlSyntax * ebml_parse_id(EbmlSyntax *syntax, uint32_t id)
Definition: matroskadec.c:1142
MATROSKA_ID_TRACKCONTENTENCODINGS
#define MATROSKA_ID_TRACKCONTENTENCODINGS
Definition: matroska.h:109
av_buffer_unref
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:139
MatroskaDemuxContext::index
EbmlList index
Definition: matroskadec.c:392
matroska_parse_cues
static void matroska_parse_cues(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:2007
MATROSKA_TRACK_TYPE_AUDIO
@ MATROSKA_TRACK_TYPE_AUDIO
Definition: matroska.h:281
MATROSKA_ID_EDITIONUID
#define MATROSKA_ID_EDITIONUID
Definition: matroska.h:269
isom.h
MATROSKA_ID_TRACKFLAGORIGINAL
#define MATROSKA_ID_TRACKFLAGORIGINAL
Definition: matroska.h:103
matroska_reset_status
static int matroska_reset_status(MatroskaDemuxContext *matroska, uint32_t id, int64_t position)
Definition: matroskadec.c:832
ff_matroska_demuxer
const FFInputFormat ff_matroska_demuxer
Definition: matroskadec.c:4794
matroska_execute_seekhead
static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:1936
MatroskaTrackVideo::pixel_height
uint64_t pixel_height
Definition: matroskadec.c:207
matroska_ebmlnum_sint
static int matroska_ebmlnum_sint(MatroskaDemuxContext *matroska, AVIOContext *pb, int64_t *num)
Definition: matroskadec.c:1123
MATROSKA_ID_ENCODINGORDER
#define MATROSKA_ID_ENCODINGORDER
Definition: matroska.h:176
flac_parse_block_header
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:63
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
SKIP_TRACK
@ SKIP_TRACK
Definition: matroskadec.c:2575
matroska_parse_webvtt
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:3715
MATROSKA_ID_WRITINGAPP
#define MATROSKA_ID_WRITINGAPP
Definition: matroska.h:68
isnan
#define isnan(x)
Definition: libm.h:340
AV_DISPOSITION_COMMENT
#define AV_DISPOSITION_COMMENT
The stream is a commentary track.
Definition: avformat.h:639
MATROSKA_ID_VIDEOCOLOR_GY
#define MATROSKA_ID_VIDEOCOLOR_GY
Definition: matroska.h:153
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
matroska_track_operation
static EbmlSyntax matroska_track_operation[2]
Definition: matroskadec.c:438
MATROSKA_VIDEO_STEREOMODE_TYPE_BOTTOM_TOP
@ MATROSKA_VIDEO_STEREOMODE_TYPE_BOTTOM_TOP
Definition: matroska.h:315
MatroskaBlockAdditionMapping::extradata
EbmlBin extradata
Definition: matroskadec.c:248
MatroskaTrackVideo
Definition: matroskadec.c:202
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:907
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1297
MatroskaBlockMore::additional
EbmlBin additional
Definition: matroskadec.c:349
mkv_field_order
static int mkv_field_order(const MatroskaDemuxContext *matroska, uint64_t field_order)
Definition: matroskadec.c:2182
MatroskaTrackVideoColor::cb_sub_horz
uint64_t cb_sub_horz
Definition: matroskadec.c:182
MATROSKA_ID_SIMPLETAG
#define MATROSKA_ID_SIMPLETAG
Definition: matroska.h:214
MATROSKA_ID_TRACKPLANEUID
#define MATROSKA_ID_TRACKPLANEUID
Definition: matroska.h:85
FFStream::nb_index_entries
int nb_index_entries
Definition: internal.h:257
MATROSKA_ID_VIDEOPROJECTION
#define MATROSKA_ID_VIDEOPROJECTION
Definition: matroska.h:161
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:823
MATROSKA_ID_SEEKID
#define MATROSKA_ID_SEEKID
Definition: matroska.h:231
FLAC_STREAMINFO_SIZE
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:32
AV_DISPOSITION_METADATA
#define AV_DISPOSITION_METADATA
The subtitle stream contains time-aligned metadata that is not intended to be directly presented to t...
Definition: avformat.h:703
MatroskaTrackAudio::buf
uint8_t * buf
Definition: matroskadec.c:232
double
double
Definition: af_crystalizer.c:131
MatroskaTrack::codec_delay
uint64_t codec_delay
Definition: matroskadec.c:273
LEVEL_ENDED
#define LEVEL_ENDED
Definition: matroskadec.c:83
MATROSKA_ID_CHAPTERTIMESTART
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:263
MatroskaTagTarget::typevalue
uint64_t typevalue
Definition: matroskadec.c:326
ff_codec_movvideo_tags
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom_tags.c:29
MatroskaMasteringMeta::min_luminance
CountedElement min_luminance
Definition: matroskadec.c:174
MATROSKA_ID_CUEBLOCKNUMBER
#define MATROSKA_ID_CUEBLOCKNUMBER
Definition: matroska.h:210
AV_DISPOSITION_ORIGINAL
#define AV_DISPOSITION_ORIGINAL
The stream is in original language.
Definition: avformat.h:635
MatroskaLevel1Element::parsed
int parsed
Definition: matroskadec.c:370
MatroskaTrack::flag_hearingimpaired
uint64_t flag_hearingimpaired
Definition: matroskadec.c:264
MATROSKA_TRACK_TYPE_VIDEO
@ MATROSKA_TRACK_TYPE_VIDEO
Definition: matroska.h:280
CountedElement::s
char * s
Definition: matroskadec.c:106
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
av_chroma_location_pos_to_enum
enum AVChromaLocation av_chroma_location_pos_to_enum(int xpos, int ypos)
Converts swscale x/y chroma position to AVChromaLocation.
Definition: pixdesc.c:3392
MATROSKA_ID_FILEMIMETYPE
#define MATROSKA_ID_FILEMIMETYPE
Definition: matroska.h:256
MATROSKA_ID_VIDEODISPLAYHEIGHT
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:118
base64.h
MatroskaTrackPlane::type
uint64_t type
Definition: matroskadec.c:237
MatroskaLevel1Element
Definition: matroskadec.c:367
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
MATROSKA_ID_TRACKAUDIO
#define MATROSKA_ID_TRACKAUDIO
Definition: matroska.h:81
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:649
matroska_index_pos
static EbmlSyntax matroska_index_pos[]
Definition: matroskadec.c:684
CUES_END
#define CUES_END
Definition: matroska.h:430
ff_codec_movaudio_tags
const AVCodecTag ff_codec_movaudio_tags[]
Definition: isom_tags.c:296
MatroskaTrackEncoding::compression
MatroskaTrackCompression compression
Definition: matroskadec.c:160
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVPALETTE_COUNT
#define AVPALETTE_COUNT
Definition: pixfmt.h:33
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:461
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
ff_log2_tab
const uint8_t ff_log2_tab[256]
Definition: log2_tab.c:23
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
MatroskaChapter::start
uint64_t start
Definition: matroskadec.c:298
EBML_STR
@ EBML_STR
Definition: matroskadec.c:92
MATROSKA_ID_VIDEOCOLORMAXCLL
#define MATROSKA_ID_VIDEOCOLORMAXCLL
Definition: matroska.h:146
AV_PKT_DATA_SPHERICAL
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition: packet.h:229
MATROSKA_ID_TRACKENTRY
#define MATROSKA_ID_TRACKENTRY
Definition: matroska.h:74
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:417
matroska_track_encoding_encryption
static EbmlSyntax matroska_track_encoding_encryption[]
Definition: matroskadec.c:548
EBML_FLOAT
@ EBML_FLOAT
Definition: matroskadec.c:91
MatroskaTrack::default_duration
uint64_t default_duration
Definition: matroskadec.c:260
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
ebml_read_uint
static int ebml_read_uint(AVIOContext *pb, int size, uint64_t default_value, uint64_t *num)
Definition: matroskadec.c:978
MATROSKA_ID_TAGDEFAULT
#define MATROSKA_ID_TAGDEFAULT
Definition: matroska.h:218
MatroskaTrackVideoProjection::type
uint64_t type
Definition: matroskadec.c:195
MATROSKA_TRACK_ENCODING_COMP_BZLIB
@ MATROSKA_TRACK_ENCODING_COMP_BZLIB
Definition: matroska.h:292
options
const OptionDef options[]
AV_DISPOSITION_CAPTIONS
#define AV_DISPOSITION_CAPTIONS
The subtitle stream contains captions, providing a transcription and possibly a translation of audio.
Definition: avformat.h:692
MATROSKA_ID_AUDIOBITDEPTH
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:172
MatroskaDemuxContext::tracks
EbmlList tracks
Definition: matroskadec.c:389
MatroskaTrackVideoColor::cb_sub_vert
uint64_t cb_sub_vert
Definition: matroskadec.c:183
MatroskaTrack::flag_visualimpaired
uint64_t flag_visualimpaired
Definition: matroskadec.c:265
MATROSKA_VIDEO_STEREOMODE_TYPE_LEFT_RIGHT
@ MATROSKA_VIDEO_STEREOMODE_TYPE_LEFT_RIGHT
Definition: matroska.h:314
MATROSKA_ID_TRACKFLAGDEFAULT
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:98
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:340
MatroskaCluster::block
MatroskaBlock block
Definition: matroskadec.c:362
av_lzo1x_decode
int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen)
Decodes LZO 1x compressed data.
Definition: lzo.c:136
AV_SPHERICAL_CUBEMAP
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition: spherical.h:61
MATROSKA_ID_ENCODINGCOMPALGO
#define MATROSKA_ID_ENCODINGCOMPALGO
Definition: matroska.h:180
AV_CODEC_ID_OTF
@ AV_CODEC_ID_OTF
Definition: codec_id.h:585
MATROSKA_ID_TRACKFLAGCOMMENTARY
#define MATROSKA_ID_TRACKFLAGCOMMENTARY
Definition: matroska.h:104
MatroskaTrack::flag_textdescriptions
uint64_t flag_textdescriptions
Definition: matroskadec.c:266
STEREO_MODE_CONV
#define STEREO_MODE_CONV(STEREOMODETYPE, STEREO3DTYPE, FLAGS, WDIV, HDIV, WEBM)
MatroskaDemuxContext::is_live
int is_live
Definition: matroskadec.c:424
EbmlSyntax
Definition: matroskadec.c:111
MATROSKA_ID_TRACKFLAGLACING
#define MATROSKA_ID_TRACKFLAGLACING
Definition: matroska.h:105
AVPacket::size
int size
Definition: packet.h:523
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
FFFormatContext::parse_pkt
AVPacket * parse_pkt
The generic code uses this as a temporary packet to parse packets or for muxing, especially flushing.
Definition: internal.h:133
MatroskaTrackVideoColor::matrix_coefficients
uint64_t matrix_coefficients
Definition: matroskadec.c:178
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:145
MATROSKA_ID_VIDEOCOLOR_GX
#define MATROSKA_ID_VIDEOCOLOR_GX
Definition: matroska.h:152
mkv_create_display_matrix
static int mkv_create_display_matrix(AVStream *st, const MatroskaTrackVideoProjection *proj, void *logctx)
Definition: matroskadec.c:2346
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
avpriv_packet_list_free
void avpriv_packet_list_free(PacketList *pkt_buf)
Wipe the list and unref all the packets in it.
Definition: avpacket.c:594
qtpalette.h
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
FFStream
Definition: internal.h:199
matroska_convert_tags
static void matroska_convert_tags(AVFormatContext *s)
Definition: matroskadec.c:1833
AVSphericalMapping::bound_right
uint32_t bound_right
Distance from the right edge.
Definition: spherical.h:165
AV_PKT_DATA_DYNAMIC_HDR10_PLUS
@ AV_PKT_DATA_DYNAMIC_HDR10_PLUS
HDR10+ dynamic metadata associated with a video frame.
Definition: packet.h:300
MatroskaTrackEncoding::encryption
MatroskaTrackEncryption encryption
Definition: matroskadec.c:161
MATROSKA_ID_TRACKFLAGENABLED
#define MATROSKA_ID_TRACKFLAGENABLED
Definition: matroska.h:97
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:29
MatroskaTrackAudio::frame_size
int frame_size
Definition: matroskadec.c:227
EBML_NONE
@ EBML_NONE
Definition: matroskadec.c:88
MATROSKA_ID_FILEDATA
#define MATROSKA_ID_FILEDATA
Definition: matroska.h:257
bps
unsigned bps
Definition: movenc.c:1787
MatroskaTrack::max_block_additional_id
uint64_t max_block_additional_id
Definition: matroskadec.c:280
MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH
#define MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH
Definition: matroska.h:165
MatroskaTrack::uid
uint64_t uid
Definition: matroskadec.c:253
size
int size
Definition: twinvq_data.h:10344
MATROSKA_VIDEO_FIELDORDER_UNDETERMINED
@ MATROSKA_VIDEO_FIELDORDER_UNDETERMINED
Definition: matroska.h:306
MATROSKA_ID_BLOCKMORE
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:240
mka_parse_audio
static int mka_parse_audio(MatroskaTrack *track, AVStream *st, AVCodecParameters *par, const MatroskaDemuxContext *matroska, AVFormatContext *s, int *extradata_offset)
Definition: matroskadec.c:2812
MATROSKA_BLOCK_ADD_ID_TYPE_OPAQUE
@ MATROSKA_BLOCK_ADD_ID_TYPE_OPAQUE
Definition: matroska.h:362
ff_get_qtpalette
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:323
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
mkv_stereo_mode_display_mul
static void mkv_stereo_mode_display_mul(int stereo_mode, int *h_width, int *h_height)
Definition: matroskadec.c:2209
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
MATROSKA_ID_VIDEOCOLORMAXFALL
#define MATROSKA_ID_VIDEOCOLORMAXFALL
Definition: matroska.h:147
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:30
matroska_attachments
static EbmlSyntax matroska_attachments[2]
Definition: matroskadec.c:439
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:165
EbmlBin
Definition: matroskadec.c:132
NEEDS_CHECKING
#define NEEDS_CHECKING
Definition: matroskadec.c:82
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:128
AV_DISPOSITION_DUB
#define AV_DISPOSITION_DUB
The stream is not in original language.
Definition: avformat.h:629
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2646
EBML_UNKNOWN_LENGTH
#define EBML_UNKNOWN_LENGTH
Definition: matroskadec.c:81
MATROSKA_ID_VIDEOCOLORCBSUBHORZ
#define MATROSKA_ID_VIDEOCOLORCBSUBHORZ
Definition: matroska.h:138
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:821
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:35
INITIALIZATION_RANGE
#define INITIALIZATION_RANGE
Definition: matroska.h:428
EBML_NEST
@ EBML_NEST
Definition: matroskadec.c:95
MATROSKA_ID_POINTENTRY
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:199
dovi_isom.h
header
static const uint8_t header[24]
Definition: sdr2.c:68
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:658
MATROSKA_ID_BLKADDIDEXTRADATA
#define MATROSKA_ID_BLKADDIDEXTRADATA
Definition: matroska.h:196
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:410
MatroskaTrack::codec_id
char * codec_id
Definition: matroskadec.c:256
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:602
matroska_simpletag
static EbmlSyntax matroska_simpletag[]
Definition: matroskadec.c:704
AVSphericalMapping::padding
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition: spherical.h:178
MatroskaTrack::num
uint64_t num
Definition: matroskadec.c:252
EbmlList::nb_elem
int nb_elem
Definition: matroskadec.c:127
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
MATROSKA_ID_ENCODINGTYPE
#define MATROSKA_ID_ENCODINGTYPE
Definition: matroska.h:178
EBML_SINT
@ EBML_SINT
Definition: matroskadec.c:90
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition: avpacket.c:697
AV_CODEC_ID_RV30
@ AV_CODEC_ID_RV30
Definition: codec_id.h:120
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
MatroskaIndexPos::track
uint64_t track
Definition: matroskadec.c:307
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
MatroskaTrack::codec_delay_in_track_tb
uint64_t codec_delay_in_track_tb
Definition: matroskadec.c:274
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
version
version
Definition: libkvazaar.c:321
MATROSKA_ID_VIDEOPIXELHEIGHT
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:120
MatroskaTrackVideoColor::chroma_siting_horz
uint64_t chroma_siting_horz
Definition: matroskadec.c:184
MatroskaTagTarget
Definition: matroskadec.c:324
MatroskaBlockMore::additional_id
uint64_t additional_id
Definition: matroskadec.c:348
MATROSKA_ID_VIDEOFRAMERATE
#define MATROSKA_ID_VIDEOFRAMERATE
Definition: matroska.h:116
MatroskaBlock::non_simple
uint64_t non_simple
Definition: matroskadec.c:355
MatroskaBlockAdditionMapping
Definition: matroskadec.c:244
EBML_UTF8
@ EBML_UTF8
Definition: matroskadec.c:93
MatroskaIndex::pos
EbmlList pos
Definition: matroskadec.c:313
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
CountedElement::count
unsigned count
Definition: matroskadec.c:108
matroska_aac_sri
static int matroska_aac_sri(int samplerate)
Definition: matroskadec.c:2111
MatroskaChapter::chapter
AVChapter * chapter
Definition: matroskadec.c:303
MATROSKA_ID_MUXINGAPP
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:69
MatroskaDemuxContext::resync_pos
int64_t resync_pos
Definition: matroskadec.c:381
MATROSKA_ID_EDITIONFLAGDEFAULT
#define MATROSKA_ID_EDITIONFLAGDEFAULT
Definition: matroska.h:271
AVFormatContext::error_recognition
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1517
MATROSKA_ID_TRACKPLANETYPE
#define MATROSKA_ID_TRACKPLANETYPE
Definition: matroska.h:86
FFStream::skip_to_keyframe
int skip_to_keyframe
Indicates that everything up to the next keyframe should be discarded.
Definition: internal.h:274
ffio_limit
int ffio_limit(AVIOContext *s, int size)
Definition: aviobuf.c:1060
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
MATROSKA_ID_CODECINFOURL
#define MATROSKA_ID_CODECINFOURL
Definition: matroska.h:90
MatroskaTrackVideo::display_height
uint64_t display_height
Definition: matroskadec.c:205
EBML_TYPE_COUNT
@ EBML_TYPE_COUNT
Definition: matroskadec.c:98
MATROSKA_ID_FILEDESC
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:254
AV_CODEC_ID_GIF
@ AV_CODEC_ID_GIF
Definition: codec_id.h:149
MATROSKA_ID_VIDEOPROJECTIONTYPE
#define MATROSKA_ID_VIDEOPROJECTIONTYPE
Definition: matroska.h:162
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
MatroskaLevel::length
uint64_t length
Definition: matroskadec.c:344
EbmlSyntax::i
int64_t i
Definition: matroskadec.c:118
MATROSKA_ID_FILENAME
#define MATROSKA_ID_FILENAME
Definition: matroska.h:255
interlaced
uint8_t interlaced
Definition: mxfenc.c:2263
AV_CODEC_ID_ATRAC1
@ AV_CODEC_ID_ATRAC1
Definition: codec_id.h:486
MatroskaDemuxContext::chapters
EbmlList chapters
Definition: matroskadec.c:391
AV_CODEC_ID_RA_288
@ AV_CODEC_ID_RA_288
Definition: codec_id.h:426
FILENAME
#define FILENAME
Definition: matroska.h:431
bprint.h
AV_CODEC_ID_RV40
@ AV_CODEC_ID_RV40
Definition: codec_id.h:121
MatroskaTrackAudio::pkt_cnt
int pkt_cnt
Definition: matroskadec.c:230
AV_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
AVSphericalMapping::roll
int32_t roll
Rotation around the forward vector [-180, 180].
Definition: spherical.h:124
MatroskaChapter::uid
uint64_t uid
Definition: matroskadec.c:300
MATROSKA_ID_CODECID
#define MATROSKA_ID_CODECID
Definition: matroska.h:87
MatroskaTrackVideoColor::range
uint64_t range
Definition: matroskadec.c:186
AV_CODEC_ID_RV10
@ AV_CODEC_ID_RV10
Definition: codec_id.h:57
MatroskaTrackVideo::color_space
EbmlBin color_space
Definition: matroskadec.c:208
EbmlSyntax::def
union EbmlSyntax::@323 def
MatroskaLevel::start
uint64_t start
Definition: matroskadec.c:343
matroska_track_video
static EbmlSyntax matroska_track_video[19]
Definition: matroskadec.c:436
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
avio_internal.h
AV_LZO_OUTPUT_PADDING
#define AV_LZO_OUTPUT_PADDING
Definition: lzo.h:47
MatroskaIndex::time
uint64_t time
Definition: matroskadec.c:312
matroska_track_audio
static EbmlSyntax matroska_track_audio[]
Definition: matroskadec.c:534
ff_isom_parse_dvcc_dvvc
int ff_isom_parse_dvcc_dvvc(void *logctx, AVStream *st, const uint8_t *buf_ptr, uint64_t size)
Definition: dovi_isom.c:31
MatroskaIndexPos
Definition: matroskadec.c:306
matroska_tagtargets
static EbmlSyntax matroska_tagtargets[]
Definition: matroskadec.c:714
MatroskaTags::target
MatroskaTagTarget target
Definition: matroskadec.c:333
BANDWIDTH
#define BANDWIDTH
Definition: matroska.h:432
MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP
@ MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP
Definition: matroska.h:294
algo
Definition: dct.c:56
AVCodecParameters::height
int height
Definition: codec_par.h:135
CountedElement::i
int64_t i
Definition: matroskadec.c:104
DURATION
#define DURATION
Definition: matroska.h:433
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
MATROSKA_ID_CUECLUSTERPOSITION
#define MATROSKA_ID_CUECLUSTERPOSITION
Definition: matroska.h:207
MATROSKA_TRACK_ENCODING_COMP_ZLIB
@ MATROSKA_TRACK_ENCODING_COMP_ZLIB
Definition: matroska.h:291
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
MatroskaMasteringMeta::r_x
double r_x
Definition: matroskadec.c:165
MATROSKA_ID_CHAPTERPHYSEQUIV
#define MATROSKA_ID_CHAPTERPHYSEQUIV
Definition: matroska.h:276
MatroskaTrackVideo::projection
MatroskaTrackVideoProjection projection
Definition: matroskadec.c:215
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
MATROSKA_ID_CUETRACK
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:206
display.h
Ebml::doctype
char * doctype
Definition: matroskadec.c:143
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:202
MATROSKA_ID_SEEKPOSITION
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:232
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
MATROSKA_ID_CLUSTER
#define MATROSKA_ID_CLUSTER
Definition: matroska.h:61
MATROSKA_ID_TRACKLANGUAGE
#define MATROSKA_ID_TRACKLANGUAGE
Definition: matroska.h:96
AV_CODEC_ID_RV20
@ AV_CODEC_ID_RV20
Definition: codec_id.h:58
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
MatroskaDemuxContext::is_webm
int is_webm
Definition: matroskadec.c:421
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
MATROSKA_ID_VIDEOFLAGINTERLACED
#define MATROSKA_ID_VIDEOFLAGINTERLACED
Definition: matroska.h:126
matroska_chapter
static EbmlSyntax matroska_chapter[6]
Definition: matroskadec.c:439
CUE_TIMESTAMPS
#define CUE_TIMESTAMPS
Definition: matroska.h:435
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:337
MatroskaTrackAudio
Definition: matroskadec.c:218
EBML_ID_CRC32
#define EBML_ID_CRC32
Definition: matroska.h:45
EbmlSyntax::data_offset
size_t data_offset
Definition: matroskadec.c:116
MatroskaDemuxContext::tags
EbmlList tags
Definition: matroskadec.c:393
MatroskaLevel1Element::id
uint32_t id
Definition: matroskadec.c:369
EbmlSyntax::f
double f
Definition: matroskadec.c:120
ff_mkv_metadata_conv
const AVMetadataConv ff_mkv_metadata_conv[]
Definition: matroska.c:124
demux.h
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:166
MatroskaTrack::flag_forced
uint64_t flag_forced
Definition: matroskadec.c:262
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
len
int len
Definition: vorbis_enc_data.h:426
MatroskaTrack::flag_comment
uint64_t flag_comment
Definition: matroskadec.c:263
get_qt_codec
static int get_qt_codec(MatroskaTrack *track, uint32_t *fourcc, enum AVCodecID *codec_id)
Definition: matroskadec.c:2543
profile
int profile
Definition: mxfenc.c:2226
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
av_rescale
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
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
MATROSKA_ID_EDITIONFLAGHIDDEN
#define MATROSKA_ID_EDITIONFLAGHIDDEN
Definition: matroska.h:270
MATROSKA_ID_CHAPTERUID
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:273
EbmlList::alloc_elem_size
unsigned int alloc_elem_size
Definition: matroskadec.c:128
matroska_index
static EbmlSyntax matroska_index[2]
Definition: matroskadec.c:440
MatroskaTrackCompression::settings
EbmlBin settings
Definition: matroskadec.c:149
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
AVDynamicHDRPlus
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
Definition: hdr_dynamic_metadata.h:243
MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
@ MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
Definition: matroska.h:324
MatroskaAttachment::uid
uint64_t uid
Definition: matroskadec.c:288
MatroskaTrackAudio::bitdepth
uint64_t bitdepth
Definition: matroskadec.c:221
matroska_mastering_meta
static EbmlSyntax matroska_mastering_meta[]
Definition: matroskadec.c:471
MATROSKA_ID_VIDEOPROJECTIONPOSEYAW
#define MATROSKA_ID_VIDEOPROJECTIONPOSEYAW
Definition: matroska.h:164
language
Undefined Behavior In the C language
Definition: undefined.txt:3
matroska_track_video_color
static EbmlSyntax matroska_track_video_color[15]
Definition: matroskadec.c:436
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:812
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
@ AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
Data found in BlockAdditional element of matroska container.
Definition: packet.h:192
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:662
MatroskaMasteringMeta::g_x
double g_x
Definition: matroskadec.c:167
MatroskaTags::tag
EbmlList tag
Definition: matroskadec.c:334
tag
uint32_t tag
Definition: movenc.c:1786
MatroskaTagTarget::chapteruid
uint64_t chapteruid
Definition: matroskadec.c:328
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
mkv_mime_tags
static const CodecMime mkv_mime_tags[]
Definition: matroskadec.c:812
EbmlBin::pos
int64_t pos
Definition: matroskadec.c:136
mkv_parse_video
static int mkv_parse_video(MatroskaTrack *track, AVStream *st, AVCodecParameters *par, const MatroskaDemuxContext *matroska, int *extradata_offset)
Definition: matroskadec.c:2924
av_stereo3d_alloc
AVStereo3D * av_stereo3d_alloc(void)
Allocate an AVStereo3D structure and set its fields to default values.
Definition: stereo3d.c:29
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:230
AVClass::class_name
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:71
av_strlcat
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:95
AVSphericalMapping::pitch
int32_t pitch
Rotation around the right vector [-90, 90].
Definition: spherical.h:123
FLAC_METADATA_TYPE_VORBIS_COMMENT
@ FLAC_METADATA_TYPE_VORBIS_COMMENT
Definition: flac.h:50
MATROSKA_ID_TRACKCOMBINEPLANES
#define MATROSKA_ID_TRACKCOMBINEPLANES
Definition: matroska.h:83
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:177
MatroskaTrackCompression
Definition: matroskadec.c:147
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:774
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
EbmlSyntax::u
uint64_t u
Definition: matroskadec.c:119
planes
static const struct @383 planes[]
matroska_blockmore
static EbmlSyntax matroska_blockmore[]
Definition: matroskadec.c:762
MATROSKA_ID_VIDEOCOLOR_BX
#define MATROSKA_ID_VIDEOCOLOR_BX
Definition: matroska.h:154
MATROSKA_ID_TAGSTRING
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:216
MatroskaDemuxContext::ctx
AVFormatContext * ctx
Definition: matroskadec.c:375
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
pos
unsigned int pos
Definition: spdifenc.c:413
MATROSKA_ID_VIDEOCOLORMATRIXCOEFF
#define MATROSKA_ID_VIDEOCOLORMATRIXCOEFF
Definition: matroska.h:134
avformat.h
MatroskaDemuxContext::time_scale
uint64_t time_scale
Definition: matroskadec.c:384
MatroskaAttachment
Definition: matroskadec.c:287
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
dict.h
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: avpacket.c:704
lzo.h
MATROSKA_ID_SIMPLEBLOCK
#define MATROSKA_ID_SIMPLEBLOCK
Definition: matroska.h:243
MATROSKA_ID_TRACKPLANE
#define MATROSKA_ID_TRACKPLANE
Definition: matroska.h:84
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
The subtitle stream contains a textual description of the video content.
Definition: avformat.h:698
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
id
enum AVCodecID id
Definition: dts2pts.c:364
MATROSKA_ID_VIDEOPIXELCROPL
#define MATROSKA_ID_VIDEOPIXELCROPL
Definition: matroska.h:123
MATROSKA_BLOCK_ADD_ID_TYPE_DVVC
@ MATROSKA_BLOCK_ADD_ID_TYPE_DVVC
Definition: matroska.h:365
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
MatroskaIndex
Definition: matroskadec.c:311
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:170
MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_RL
@ MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_RL
Definition: matroska.h:321
MATROSKA_ID_CODECNAME
#define MATROSKA_ID_CODECNAME
Definition: matroska.h:89
AV_PKT_DATA_WEBVTT_IDENTIFIER
@ AV_PKT_DATA_WEBVTT_IDENTIFIER
The optional first identifier line of a WebVTT cue.
Definition: packet.h:197
webm_dash_class
static const AVClass webm_dash_class
Definition: webmdashenc.c:538
MatroskaTrackVideo::frame_rate
double frame_rate
Definition: matroskadec.c:203
oggdec.h
MATROSKA_ID_EDITIONENTRY
#define MATROSKA_ID_EDITIONENTRY
Definition: matroska.h:261
MatroskaChapter::title
char * title
Definition: matroskadec.c:301
OFFSET
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
syntax
static const ParseSyntax syntax[]
Definition: concatdec.c:442
matroska_seekhead_entry
static EbmlSyntax matroska_seekhead_entry[]
Definition: matroskadec.c:734
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
MATROSKA_ID_TRACKMAXCACHE
#define MATROSKA_ID_TRACKMAXCACHE
Definition: matroska.h:107
matroska_seekhead
static EbmlSyntax matroska_seekhead[2]
Definition: matroskadec.c:440
ff_codec_bmp_tags
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:36
matroska_add_index_entries
static void matroska_add_index_entries(MatroskaDemuxContext *matroska)
Definition: matroskadec.c:1974
MATROSKA_ID_TRACKMAXBLKADDID
#define MATROSKA_ID_TRACKMAXBLKADDID
Definition: matroska.h:112
EBML_ID_HEADER
#define EBML_ID_HEADER
Definition: matroska.h:32
MatroskaTrack::needs_decoding
int needs_decoding
Definition: matroskadec.c:279
matroska_blockgroup
static EbmlSyntax matroska_blockgroup[8]
Definition: matroskadec.c:441
MATROSKA_ID_TAGTARGETS_TYPEVALUE
#define MATROSKA_ID_TAGTARGETS_TYPEVALUE
Definition: matroska.h:222
EBML_ID_EBMLVERSION
#define EBML_ID_EBMLVERSION
Definition: matroska.h:35
MatroskaTrackType
MatroskaTrackType
Definition: matroska.h:278
MatroskaLevel
Definition: matroskadec.c:342
MATROSKA_ID_CLUSTERPREVSIZE
#define MATROSKA_ID_CLUSTERPREVSIZE
Definition: matroska.h:237
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: avpacket.c:231
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
MatroskaTrackVideo::display_width
uint64_t display_width
Definition: matroskadec.c:204
ff_sipr_subpk_size
const unsigned char ff_sipr_subpk_size[4]
Definition: rmsipr.c:25
MATROSKA_ID_TAGLANG
#define MATROSKA_ID_TAGLANG
Definition: matroska.h:217
MatroskaTrackVideoColor::chroma_sub_horz
uint64_t chroma_sub_horz
Definition: matroskadec.c:180
is_ebml_id_valid
static int is_ebml_id_valid(uint32_t id)
Definition: matroskadec.c:1198
AVRational::den
int den
Denominator.
Definition: rational.h:60
MatroskaTrackAudio::channels
uint64_t channels
Definition: matroskadec.c:222
MATROSKA_VIDEO_STEREO_PLANE_COUNT
#define MATROSKA_VIDEO_STEREO_PLANE_COUNT
Definition: matroska.h:383
mkv_parse_dvcc_dvvc
static int mkv_parse_dvcc_dvvc(AVFormatContext *s, AVStream *st, const MatroskaTrack *track, EbmlBin *bin)
Definition: matroskadec.c:2482
MATROSKA_ID_VIDEOCOLOR
#define MATROSKA_ID_VIDEOCOLOR
Definition: matroska.h:132
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
MatroskaChapter::end
uint64_t end
Definition: matroskadec.c:299
matroska_tracks
static EbmlSyntax matroska_tracks[2]
Definition: matroskadec.c:438
defs.h
MatroskaDemuxContext::date_utc
EbmlBin date_utc
Definition: matroskadec.c:388
MATROSKA_ID_VIDEOCOLORTRANSFERCHARACTERISTICS
#define MATROSKA_ID_VIDEOCOLORTRANSFERCHARACTERISTICS
Definition: matroska.h:143
video
A Quick Description Of Rate Distortion Theory We want to encode a video
Definition: rate_distortion.txt:3
MATROSKA_ID_VIDEOCOLOR_RX
#define MATROSKA_ID_VIDEOCOLOR_RX
Definition: matroska.h:150
matroska_parse_wavpack
static int matroska_parse_wavpack(MatroskaTrack *track, uint8_t **data, int *size)
Definition: matroskadec.c:3610
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:611
MATROSKA_TRACK_TYPE_SUBTITLE
@ MATROSKA_TRACK_TYPE_SUBTITLE
Definition: matroska.h:284
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
MatroskaMasteringMeta::max_luminance
double max_luminance
Definition: matroskadec.c:173
hdr_dynamic_metadata.h
temp
else temp
Definition: vf_mcdeint.c:263
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:909
AV_LZO_OUTPUT_FULL
#define AV_LZO_OUTPUT_FULL
decoded data did not fit into output buffer
Definition: lzo.h:39
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:238
av_base64_encode
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:145
MatroskaBlockAdditionMapping::name
char * name
Definition: matroskadec.c:246
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
MATROSKA_ID_VIDEOCOLORCHROMASUBVERT
#define MATROSKA_ID_VIDEOCOLORCHROMASUBVERT
Definition: matroska.h:137
MATROSKA_VIDEO_PROJECTION_TYPE_EQUIRECTANGULAR
@ MATROSKA_VIDEO_PROJECTION_TYPE_EQUIRECTANGULAR
Definition: matroska.h:355
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
EBML_UINT
@ EBML_UINT
Definition: matroskadec.c:89
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1390
AVPacket::stream_index
int stream_index
Definition: packet.h:524
matroska_parse_rm_audio
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:3532
MatroskaTrackVideoColor::max_fall
uint64_t max_fall
Definition: matroskadec.c:190
av_buffer_realloc
int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
Reallocate a given buffer.
Definition: buffer.c:183
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:317
MatroskaTrackVideoProjection::private
EbmlBin private
Definition: matroskadec.c:196
MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
#define MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ
Definition: matroska.h:140
MATROSKA_TRACK_ENCODING_COMP_LZO
@ MATROSKA_TRACK_ENCODING_COMP_LZO
Definition: matroska.h:293
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:255
ff_mpeg4audio_sample_rates
const int ff_mpeg4audio_sample_rates[16]
Definition: mpeg4audio_sample_rates.h:26
av_dict_set_int
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:167
CodecMime::id
enum AVCodecID id
Definition: internal.h:55
av_spherical_alloc
AVSphericalMapping * av_spherical_alloc(size_t *size)
Allocate a AVSphericalVideo structure and initialize its fields to default values.
Definition: spherical.c:26
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:273
MATROSKA_ID_BLOCKREFERENCE
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:248
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:336
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
MatroskaBlock::bin
EbmlBin bin
Definition: matroskadec.c:356
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
CodecTags::id
enum AVCodecID id
Definition: matroska.h:377
packet_internal.h
MATROSKA_ID_VIDEOCOLOR_RY
#define MATROSKA_ID_VIDEOCOLOR_RY
Definition: matroska.h:151
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:333
MATROSKA_VIDEO_FIELDORDER_TB
@ MATROSKA_VIDEO_FIELDORDER_TB
Definition: matroska.h:308
mastering_display_metadata.h
EbmlSyntax::s
const char * s
Definition: matroskadec.c:121
AVSphericalMapping::bound_left
uint32_t bound_left
Distance from the left edge.
Definition: spherical.h:163
MatroskaTrack::has_palette
int has_palette
Definition: matroskadec.c:284
MatroskaTrackVideoProjection::roll
double roll
Definition: matroskadec.c:199
AVCOL_TRC_RESERVED
@ AVCOL_TRC_RESERVED
Definition: pixfmt.h:584
MATROSKA_ID_TRACKVIDEO
#define MATROSKA_ID_TRACKVIDEO
Definition: matroska.h:80
av_dynamic_hdr_plus_alloc
AVDynamicHDRPlus * av_dynamic_hdr_plus_alloc(size_t *size)
Allocate an AVDynamicHDRPlus structure and set its fields to default values.
Definition: hdr_dynamic_metadata.c:36
MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_RL
@ MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_RL
Definition: matroska.h:327
AVIOContext::buffer
unsigned char * buffer
Start of the buffer.
Definition: avio.h:225
ff_mkv_codec_tags
const CodecTags ff_mkv_codec_tags[]
Definition: matroska.c:27
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:351
MatroskaAttachment::mime
char * mime
Definition: matroskadec.c:291
MATROSKA_ID_TRACKFLAGFORCED
#define MATROSKA_ID_TRACKFLAGFORCED
Definition: matroska.h:99
MATROSKA_VIDEO_STEREOMODE_TYPE_NB
@ MATROSKA_VIDEO_STEREOMODE_TYPE_NB
Definition: matroska.h:328
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
MatroskaBlockMore
Definition: matroskadec.c:347
EBML_VERSION
#define EBML_VERSION
Definition: matroska.h:29
EBML_ID_EBMLREADVERSION
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:36
matroska_deliver_packet
static int matroska_deliver_packet(MatroskaDemuxContext *matroska, AVPacket *pkt)
Definition: matroskadec.c:3404
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
MatroskaTrack::palette
uint32_t palette[AVPALETTE_COUNT]
Definition: matroskadec.c:283
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AVPacket
This structure stores compressed data.
Definition: packet.h:499
MatroskaTrackEncryption::key_id
EbmlBin key_id
Definition: matroskadec.c:154
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
MATROSKA_ID_ENCODINGENCAESSETTINGS
#define MATROSKA_ID_ENCODINGENCAESSETTINGS
Definition: matroska.h:184
MATROSKA_ID_CHAPTERFLAGHIDDEN
#define MATROSKA_ID_CHAPTERFLAGHIDDEN
Definition: matroska.h:274
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
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:88
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
riff.h
MATROSKA_ID_ATTACHEDFILE
#define MATROSKA_ID_ATTACHEDFILE
Definition: matroska.h:253
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:542
MATROSKA_ID_TRACKMINCACHE
#define MATROSKA_ID_TRACKMINCACHE
Definition: matroska.h:106
av_dynamic_hdr_plus_from_t35
int av_dynamic_hdr_plus_from_t35(AVDynamicHDRPlus *s, const uint8_t *data, size_t size)
Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus).
Definition: hdr_dynamic_metadata.c:61
MATROSKA_ID_CODECDELAY
#define MATROSKA_ID_CODECDELAY
Definition: matroska.h:93
FFInputFormat
Definition: demux.h:31
MatroskaMasteringMeta::g_y
double g_y
Definition: matroskadec.c:168
MatroskaTrackVideoColor::transfer_characteristics
uint64_t transfer_characteristics
Definition: matroskadec.c:187
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
mkv_stereo3d_conv
static int mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
Definition: matroskadec.c:2234
matroska_track_plane
static EbmlSyntax matroska_track_plane[]
Definition: matroskadec.c:572
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
MATROSKA_ID_ENCODINGCOMPRESSION
#define MATROSKA_ID_ENCODINGCOMPRESSION
Definition: matroska.h:179
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
MATROSKA_ID_TAGTARGETS_TRACKUID
#define MATROSKA_ID_TAGTARGETS_TRACKUID
Definition: matroska.h:223
MatroskaTrackVideoProjection::pitch
double pitch
Definition: matroskadec.c:198
av_strlcpy
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:85
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:349
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
MatroskaTrack::flag_original
CountedElement flag_original
Definition: matroskadec.c:267
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MatroskaBlock::blockmore
EbmlList blockmore
Definition: matroskadec.c:357
MatroskaTrackVideo::stereo_mode
uint64_t stereo_mode
Definition: matroskadec.c:212
AV_CODEC_ID_WAVPACK
@ AV_CODEC_ID_WAVPACK
Definition: codec_id.h:465
UNKNOWN_EQUIV
#define UNKNOWN_EQUIV
Definition: matroskadec.c:85
AV_CODEC_ID_COOK
@ AV_CODEC_ID_COOK
Definition: codec_id.h:460
MATROSKA_ID_CHAPTERTIMEEND
#define MATROSKA_ID_CHAPTERTIMEEND
Definition: matroska.h:264
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
matroska_track_encoding
static EbmlSyntax matroska_track_encoding[6]
Definition: matroskadec.c:437
MatroskaTrack::seek_preroll
uint64_t seek_preroll
Definition: matroskadec.c:268
matroska_chapter_display
static EbmlSyntax matroska_chapter_display[]
Definition: matroskadec.c:651
MatroskaCluster
Definition: matroskadec.c:361
MatroskaTrackVideoColor::chroma_sub_vert
uint64_t chroma_sub_vert
Definition: matroskadec.c:181
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
MATROSKA_ID_TRACKS
#define MATROSKA_ID_TRACKS
Definition: matroska.h:56
MATROSKA_ID_ENCODINGENCKEYID
#define MATROSKA_ID_ENCODINGENCKEYID
Definition: matroska.h:186
h
h
Definition: vp9dsp_template.c:2038
MatroskaTrackAudio::samplerate
double samplerate
Definition: matroskadec.c:219
MatroskaMasteringMeta::white_x
double white_x
Definition: matroskadec.c:171
ebml_free
static void ebml_free(EbmlSyntax *syntax, void *data)
Definition: matroskadec.c:1564
AV_CODEC_ID_TIFF
@ AV_CODEC_ID_TIFF
Definition: codec_id.h:148
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:173
AVDictionaryEntry::value
char * value
Definition: dict.h:91
EbmlSyntax::is_counted
uint8_t is_counted
Definition: matroskadec.c:114
avstring.h
ff_reduce_index
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: seek.c:48
MATROSKA_ID_ENCODINGCOMPSETTINGS
#define MATROSKA_ID_ENCODINGCOMPSETTINGS
Definition: matroska.h:181
flac.h
MatroskaDemuxContext::cues_parsing_deferred
int cues_parsing_deferred
Definition: matroskadec.c:413
ff_vorbis_comment
int ff_vorbis_comment(AVFormatContext *ms, AVDictionary **m, const uint8_t *buf, int size, int parse_picture)
Parse Vorbis comments.
Definition: oggparsevorbis.c:148
MatroskaIndexPos::pos
uint64_t pos
Definition: matroskadec.c:308
MATROSKA_ID_SEEKPREROLL
#define MATROSKA_ID_SEEKPREROLL
Definition: matroska.h:94
AVIOContext::buf_ptr
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:227
MATROSKA_ID_SEEKHEAD
#define MATROSKA_ID_SEEKHEAD
Definition: matroska.h:59
CHILD_OF
#define CHILD_OF(parent)
Definition: matroskadec.c:430
MatroskaBlock::reference
CountedElement reference
Definition: matroskadec.c:354
EbmlBin::data
uint8_t * data
Definition: matroskadec.c:135
EBML_LEVEL1
@ EBML_LEVEL1
Definition: matroskadec.c:96
MATROSKA_BLOCK_ADD_ID_TYPE_DVCC
@ MATROSKA_BLOCK_ADD_ID_TYPE_DVCC
Definition: matroska.h:364
fourcc
uint32_t fourcc
Definition: vaapi_decode.c:239
snprintf
#define snprintf
Definition: snprintf.h:34
MatroskaDemuxContext::skip_to_timecode
uint64_t skip_to_timecode
Definition: matroskadec.c:410
AVCodecParameters::initial_padding
int initial_padding
Audio only.
Definition: codec_par.h:203
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
MATROSKA_ID_VIDEOPROJECTIONPOSEROLL
#define MATROSKA_ID_VIDEOPROJECTIONPOSEROLL
Definition: matroska.h:166
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:341
MATROSKA_ID_BLOCKADDID
#define MATROSKA_ID_BLOCKADDID
Definition: matroska.h:241
AVSphericalMapping
This structure describes how to handle spherical videos, outlining information about projection,...
Definition: spherical.h:78
avpriv_dict_set_timestamp
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:278
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
MatroskaBlockAdditionMapping::value
uint64_t value
Definition: matroskadec.c:245
MatroskaTrackAudio::out_samplerate
double out_samplerate
Definition: matroskadec.c:220
AVSphericalMapping::yaw
int32_t yaw
Rotation around the up vector [-180, 180].
Definition: spherical.h:122
MATROSKA_ID_TAGTARGETS_CHAPTERUID
#define MATROSKA_ID_TAGTARGETS_CHAPTERUID
Definition: matroska.h:224
MatroskaTrackEncryption
Definition: matroskadec.c:152
ebml_read_length
static int ebml_read_length(MatroskaDemuxContext *matroska, AVIOContext *pb, uint64_t *number)
Read a EBML length value.
Definition: matroskadec.c:965
read
static uint32_t BS_FUNC() read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition: bitstream_template.h:231
MATROSKA_ID_TRACKTIMECODESCALE
#define MATROSKA_ID_TRACKTIMECODESCALE
Definition: matroska.h:111
matroska_chapter_entry
static EbmlSyntax matroska_chapter_entry[9]
Definition: matroskadec.c:439
MATROSKA_VIDEO_PROJECTION_TYPE_CUBEMAP
@ MATROSKA_VIDEO_PROJECTION_TYPE_CUBEMAP
Definition: matroska.h:356
matroska_aac_profile
static int matroska_aac_profile(char *codec_id)
Definition: matroskadec.c:2100
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:469
is_keyframe
static int is_keyframe(NalUnitType naltype)
Definition: libx265.c:83
MatroskaTrack::time_scale
double time_scale
Definition: matroskadec.c:259
MatroskaTrack::language
char * language
Definition: matroskadec.c:258
ff_webm_dash_manifest_demuxer
const FFInputFormat ff_webm_dash_manifest_demuxer
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition: codec_id.h:200
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
CountedElement
Definition: matroskadec.c:101
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:345
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:243
MatroskaMasteringMeta::r_y
double r_y
Definition: matroskadec.c:166
matroska_parse_flac
static int matroska_parse_flac(AVFormatContext *s, MatroskaTrack *track, int *offset)
Definition: matroskadec.c:2127
ff_alloc_extradata
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:239
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:345
MATROSKA_ID_BLOCKADDITIONS
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:239
MATROSKA_VIDEO_INTERLACE_FLAG_UNDETERMINED
@ MATROSKA_VIDEO_INTERLACE_FLAG_UNDETERMINED
Definition: matroska.h:298
MatroskaDemuxContext::done
int done
Definition: matroskadec.c:406