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