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