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