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