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