FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
matroskadec.c
Go to the documentation of this file.
1 /*
2  * Matroska file demuxer
3  * Copyright (c) 2003-2008 The FFmpeg Project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Matroska file demuxer
25  * @author Ronald Bultje <rbultje@ronald.bitfreak.net>
26  * @author with a little help from Moritz Bunkus <moritz@bunkus.org>
27  * @author totally reworked by Aurelien Jacobs <aurel@gnuage.org>
28  * @see specs available on the Matroska project page: http://www.matroska.org/
29  */
30 
31 #include "config.h"
32 
33 #include <inttypes.h>
34 #include <stdio.h>
35 #if CONFIG_BZLIB
36 #include <bzlib.h>
37 #endif
38 #if CONFIG_ZLIB
39 #include <zlib.h>
40 #endif
41 
42 #include "libavutil/avstring.h"
43 #include "libavutil/base64.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/intfloat.h"
46 #include "libavutil/intreadwrite.h"
47 #include "libavutil/lzo.h"
48 #include "libavutil/mathematics.h"
50 
51 #include "libavcodec/bytestream.h"
52 #include "libavcodec/flac.h"
53 #include "libavcodec/mpeg4audio.h"
54 
55 #include "avformat.h"
56 #include "avio_internal.h"
57 #include "internal.h"
58 #include "isom.h"
59 #include "matroska.h"
60 #include "oggdec.h"
61 /* For ff_codec_get_id(). */
62 #include "riff.h"
63 #include "rmsipr.h"
64 
65 typedef enum {
77 } EbmlType;
78 
79 typedef const struct EbmlSyntax {
80  uint32_t id;
84  union {
85  uint64_t u;
86  double f;
87  const char *s;
88  const struct EbmlSyntax *n;
89  } def;
90 } EbmlSyntax;
91 
92 typedef struct {
93  int nb_elem;
94  void *elem;
95 } EbmlList;
96 
97 typedef struct {
98  int size;
100  int64_t pos;
101 } EbmlBin;
102 
103 typedef struct {
104  uint64_t version;
105  uint64_t max_size;
106  uint64_t id_length;
107  char *doctype;
108  uint64_t doctype_version;
109 } Ebml;
110 
111 typedef struct {
112  uint64_t algo;
115 
116 typedef struct {
117  uint64_t algo;
120 
121 typedef struct {
122  uint64_t scope;
123  uint64_t type;
127 
128 typedef struct {
129  double frame_rate;
130  uint64_t display_width;
131  uint64_t display_height;
132  uint64_t pixel_width;
133  uint64_t pixel_height;
135  uint64_t stereo_mode;
136  uint64_t alpha_mode;
138 
139 typedef struct {
140  double samplerate;
142  uint64_t bitdepth;
143  uint64_t channels;
144 
145  /* real audio header (extracted from extradata) */
151  int pkt_cnt;
152  uint64_t buf_timecode;
155 
156 typedef struct {
157  uint64_t uid;
158  uint64_t type;
160 
161 typedef struct {
164 
165 typedef struct {
166  uint64_t num;
167  uint64_t uid;
168  uint64_t type;
169  char *name;
170  char *codec_id;
172  char *language;
173  double time_scale;
175  uint64_t flag_default;
176  uint64_t flag_forced;
177  uint64_t seek_preroll;
182  uint64_t codec_delay;
183 
185  int64_t end_timecode;
188 } MatroskaTrack;
189 
190 typedef struct {
191  uint64_t uid;
192  char *filename;
193  char *mime;
195 
198 
199 typedef struct {
200  uint64_t start;
201  uint64_t end;
202  uint64_t uid;
203  char *title;
204 
207 
208 typedef struct {
209  uint64_t track;
210  uint64_t pos;
212 
213 typedef struct {
214  uint64_t time;
216 } MatroskaIndex;
217 
218 typedef struct {
219  char *name;
220  char *string;
221  char *lang;
222  uint64_t def;
224 } MatroskaTag;
225 
226 typedef struct {
227  char *type;
228  uint64_t typevalue;
229  uint64_t trackuid;
230  uint64_t chapteruid;
231  uint64_t attachuid;
233 
234 typedef struct {
237 } MatroskaTags;
238 
239 typedef struct {
240  uint64_t id;
241  uint64_t pos;
243 
244 typedef struct {
245  uint64_t start;
246  uint64_t length;
247 } MatroskaLevel;
248 
249 typedef struct {
250  uint64_t timecode;
253 
254 typedef struct {
256 
257  /* EBML stuff */
260  int level_up;
261  uint32_t current_id;
262 
263  uint64_t time_scale;
264  double duration;
265  char *title;
266  char *muxingapp;
274 
275  /* byte position of the segment inside the stream */
276  int64_t segment_start;
277 
278  /* the packet queue */
282 
283  int done;
284 
285  /* What to skip before effectively reading a packet. */
288 
289  /* File has a CUES element, but we defer parsing until it is needed. */
291 
295 
296  /* File has SSA subtitles which prevent incremental cluster parsing. */
299 
300 typedef struct {
301  uint64_t duration;
302  int64_t reference;
303  uint64_t non_simple;
305  uint64_t additional_id;
308 } MatroskaBlock;
309 
311  { EBML_ID_EBMLREADVERSION, EBML_UINT, 0, offsetof(Ebml, version), { .u = EBML_VERSION } },
312  { EBML_ID_EBMLMAXSIZELENGTH, EBML_UINT, 0, offsetof(Ebml, max_size), { .u = 8 } },
313  { EBML_ID_EBMLMAXIDLENGTH, EBML_UINT, 0, offsetof(Ebml, id_length), { .u = 4 } },
314  { EBML_ID_DOCTYPE, EBML_STR, 0, offsetof(Ebml, doctype), { .s = "(none)" } },
315  { EBML_ID_DOCTYPEREADVERSION, EBML_UINT, 0, offsetof(Ebml, doctype_version), { .u = 1 } },
318  { 0 }
319 };
320 
322  { EBML_ID_HEADER, EBML_NEST, 0, 0, { .n = ebml_header } },
323  { 0 }
324 };
325 
327  { MATROSKA_ID_TIMECODESCALE, EBML_UINT, 0, offsetof(MatroskaDemuxContext, time_scale), { .u = 1000000 } },
329  { MATROSKA_ID_TITLE, EBML_UTF8, 0, offsetof(MatroskaDemuxContext, title) },
331  { MATROSKA_ID_MUXINGAPP, EBML_UTF8, 0, offsetof(MatroskaDemuxContext, muxingapp) },
332  { MATROSKA_ID_DATEUTC, EBML_BIN, 0, offsetof(MatroskaDemuxContext, date_utc) },
334  { 0 }
335 };
336 
338  { MATROSKA_ID_VIDEOFRAMERATE, EBML_FLOAT, 0, offsetof(MatroskaTrackVideo, frame_rate) },
339  { MATROSKA_ID_VIDEODISPLAYWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo, display_width), { .u=-1 } },
340  { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo, display_height), { .u=-1 } },
341  { MATROSKA_ID_VIDEOPIXELWIDTH, EBML_UINT, 0, offsetof(MatroskaTrackVideo, pixel_width) },
342  { MATROSKA_ID_VIDEOPIXELHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo, pixel_height) },
343  { MATROSKA_ID_VIDEOCOLORSPACE, EBML_BIN, 0, offsetof(MatroskaTrackVideo, color_space) },
344  { MATROSKA_ID_VIDEOALPHAMODE, EBML_UINT, 0, offsetof(MatroskaTrackVideo, alpha_mode) },
353  { 0 }
354 };
355 
357  { MATROSKA_ID_AUDIOSAMPLINGFREQ, EBML_FLOAT, 0, offsetof(MatroskaTrackAudio, samplerate), { .f = 8000.0 } },
358  { MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, EBML_FLOAT, 0, offsetof(MatroskaTrackAudio, out_samplerate) },
360  { MATROSKA_ID_AUDIOCHANNELS, EBML_UINT, 0, offsetof(MatroskaTrackAudio, channels), { .u = 1 } },
361  { 0 }
362 };
363 
367  { 0 }
368 };
369 
378  { 0 }
379 };
381  { MATROSKA_ID_ENCODINGSCOPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding, scope), { .u = 1 } },
382  { MATROSKA_ID_ENCODINGTYPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding, type), { .u = 0 } },
383  { MATROSKA_ID_ENCODINGCOMPRESSION, EBML_NEST, 0, offsetof(MatroskaTrackEncoding, compression), { .n = matroska_track_encoding_compression } },
384  { MATROSKA_ID_ENCODINGENCRYPTION, EBML_NEST, 0, offsetof(MatroskaTrackEncoding, encryption), { .n = matroska_track_encoding_encryption } },
386  { 0 }
387 };
388 
390  { MATROSKA_ID_TRACKCONTENTENCODING, EBML_NEST, sizeof(MatroskaTrackEncoding), offsetof(MatroskaTrack, encodings), { .n = matroska_track_encoding } },
391  { 0 }
392 };
393 
397  { 0 }
398 };
399 
401  { MATROSKA_ID_TRACKPLANE, EBML_NEST, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n = matroska_track_plane} },
402  { 0 }
403 };
404 
406  { MATROSKA_ID_TRACKCOMBINEPLANES, EBML_NEST, 0, 0, {.n = matroska_track_combine_planes} },
407  { 0 }
408 };
409 
411  { MATROSKA_ID_TRACKNUMBER, EBML_UINT, 0, offsetof(MatroskaTrack, num) },
413  { MATROSKA_ID_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTrack, uid) },
416  { MATROSKA_ID_CODECPRIVATE, EBML_BIN, 0, offsetof(MatroskaTrack, codec_priv) },
417  { MATROSKA_ID_CODECDELAY, EBML_UINT, 0, offsetof(MatroskaTrack, codec_delay) },
418  { MATROSKA_ID_TRACKLANGUAGE, EBML_UTF8, 0, offsetof(MatroskaTrack, language), { .s = "eng" } },
419  { MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, offsetof(MatroskaTrack, default_duration) },
420  { MATROSKA_ID_TRACKTIMECODESCALE, EBML_FLOAT, 0, offsetof(MatroskaTrack, time_scale), { .f = 1.0 } },
421  { MATROSKA_ID_TRACKFLAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTrack, flag_default), { .u = 1 } },
422  { MATROSKA_ID_TRACKFLAGFORCED, EBML_UINT, 0, offsetof(MatroskaTrack, flag_forced), { .u = 0 } },
423  { MATROSKA_ID_TRACKVIDEO, EBML_NEST, 0, offsetof(MatroskaTrack, video), { .n = matroska_track_video } },
424  { MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, offsetof(MatroskaTrack, audio), { .n = matroska_track_audio } },
425  { MATROSKA_ID_TRACKOPERATION, EBML_NEST, 0, offsetof(MatroskaTrack, operation), { .n = matroska_track_operation } },
426  { MATROSKA_ID_TRACKCONTENTENCODINGS, EBML_NEST, 0, 0, { .n = matroska_track_encodings } },
427  { MATROSKA_ID_TRACKMAXBLKADDID, EBML_UINT, 0, offsetof(MatroskaTrack, max_block_additional_id) },
428  { MATROSKA_ID_SEEKPREROLL, EBML_UINT, 0, offsetof(MatroskaTrack, seek_preroll) },
437  { 0 }
438 };
439 
441  { MATROSKA_ID_TRACKENTRY, EBML_NEST, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext, tracks), { .n = matroska_track } },
442  { 0 }
443 };
444 
447  { MATROSKA_ID_FILENAME, EBML_UTF8, 0, offsetof(MatroskaAttachment, filename) },
448  { MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, offsetof(MatroskaAttachment, mime) },
449  { MATROSKA_ID_FILEDATA, EBML_BIN, 0, offsetof(MatroskaAttachment, bin) },
451  { 0 }
452 };
453 
455  { MATROSKA_ID_ATTACHEDFILE, EBML_NEST, sizeof(MatroskaAttachment), offsetof(MatroskaDemuxContext, attachments), { .n = matroska_attachment } },
456  { 0 }
457 };
458 
460  { MATROSKA_ID_CHAPSTRING, EBML_UTF8, 0, offsetof(MatroskaChapter, title) },
462  { 0 }
463 };
464 
469  { MATROSKA_ID_CHAPTERDISPLAY, EBML_NEST, 0, 0, { .n = matroska_chapter_display } },
474  { 0 }
475 };
476 
478  { MATROSKA_ID_CHAPTERATOM, EBML_NEST, sizeof(MatroskaChapter), offsetof(MatroskaDemuxContext, chapters), { .n = matroska_chapter_entry } },
483  { 0 }
484 };
485 
487  { MATROSKA_ID_EDITIONENTRY, EBML_NEST, 0, 0, { .n = matroska_chapter } },
488  { 0 }
489 };
490 
492  { MATROSKA_ID_CUETRACK, EBML_UINT, 0, offsetof(MatroskaIndexPos, track) },
497  { 0 }
498 };
499 
501  { MATROSKA_ID_CUETIME, EBML_UINT, 0, offsetof(MatroskaIndex, time) },
502  { MATROSKA_ID_CUETRACKPOSITION, EBML_NEST, sizeof(MatroskaIndexPos), offsetof(MatroskaIndex, pos), { .n = matroska_index_pos } },
503  { 0 }
504 };
505 
507  { MATROSKA_ID_POINTENTRY, EBML_NEST, sizeof(MatroskaIndex), offsetof(MatroskaDemuxContext, index), { .n = matroska_index_entry } },
508  { 0 }
509 };
510 
512  { MATROSKA_ID_TAGNAME, EBML_UTF8, 0, offsetof(MatroskaTag, name) },
513  { MATROSKA_ID_TAGSTRING, EBML_UTF8, 0, offsetof(MatroskaTag, string) },
514  { MATROSKA_ID_TAGLANG, EBML_STR, 0, offsetof(MatroskaTag, lang), { .s = "und" } },
515  { MATROSKA_ID_TAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTag, def) },
516  { MATROSKA_ID_TAGDEFAULT_BUG, EBML_UINT, 0, offsetof(MatroskaTag, def) },
517  { MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTag, sub), { .n = matroska_simpletag } },
518  { 0 }
519 };
520 
523  { MATROSKA_ID_TAGTARGETS_TYPEVALUE, EBML_UINT, 0, offsetof(MatroskaTagTarget, typevalue), { .u = 50 } },
524  { MATROSKA_ID_TAGTARGETS_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, trackuid) },
525  { MATROSKA_ID_TAGTARGETS_CHAPTERUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, chapteruid) },
526  { MATROSKA_ID_TAGTARGETS_ATTACHUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, attachuid) },
527  { 0 }
528 };
529 
531  { MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTags, tag), { .n = matroska_simpletag } },
532  { MATROSKA_ID_TAGTARGETS, EBML_NEST, 0, offsetof(MatroskaTags, target), { .n = matroska_tagtargets } },
533  { 0 }
534 };
535 
537  { MATROSKA_ID_TAG, EBML_NEST, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext, tags), { .n = matroska_tag } },
538  { 0 }
539 };
540 
542  { MATROSKA_ID_SEEKID, EBML_UINT, 0, offsetof(MatroskaSeekhead, id) },
543  { MATROSKA_ID_SEEKPOSITION, EBML_UINT, 0, offsetof(MatroskaSeekhead, pos), { .u = -1 } },
544  { 0 }
545 };
546 
548  { MATROSKA_ID_SEEKENTRY, EBML_NEST, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext, seekhead), { .n = matroska_seekhead_entry } },
549  { 0 }
550 };
551 
553  { MATROSKA_ID_INFO, EBML_NEST, 0, 0, { .n = matroska_info } },
554  { MATROSKA_ID_TRACKS, EBML_NEST, 0, 0, { .n = matroska_tracks } },
555  { MATROSKA_ID_ATTACHMENTS, EBML_NEST, 0, 0, { .n = matroska_attachments } },
556  { MATROSKA_ID_CHAPTERS, EBML_NEST, 0, 0, { .n = matroska_chapters } },
557  { MATROSKA_ID_CUES, EBML_NEST, 0, 0, { .n = matroska_index } },
558  { MATROSKA_ID_TAGS, EBML_NEST, 0, 0, { .n = matroska_tags } },
559  { MATROSKA_ID_SEEKHEAD, EBML_NEST, 0, 0, { .n = matroska_seekhead } },
561  { 0 }
562 };
563 
565  { MATROSKA_ID_SEGMENT, EBML_NEST, 0, 0, { .n = matroska_segment } },
566  { 0 }
567 };
568 
570  { MATROSKA_ID_BLOCKADDID, EBML_UINT, 0, offsetof(MatroskaBlock,additional_id) },
571  { MATROSKA_ID_BLOCKADDITIONAL, EBML_BIN, 0, offsetof(MatroskaBlock,additional) },
572  { 0 }
573 };
574 
576  { MATROSKA_ID_BLOCKMORE, EBML_NEST, 0, 0, {.n = matroska_blockmore} },
577  { 0 }
578 };
579 
581  { MATROSKA_ID_BLOCK, EBML_BIN, 0, offsetof(MatroskaBlock, bin) },
582  { MATROSKA_ID_BLOCKADDITIONS, EBML_NEST, 0, 0, { .n = matroska_blockadditions} },
583  { MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, offsetof(MatroskaBlock, bin) },
585  { MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, offsetof(MatroskaBlock, discard_padding) },
586  { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, offsetof(MatroskaBlock, reference) },
588  { 1, EBML_UINT, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
589  { 0 }
590 };
591 
593  { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, offsetof(MatroskaCluster, timecode) },
594  { MATROSKA_ID_BLOCKGROUP, EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
595  { MATROSKA_ID_SIMPLEBLOCK, EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
598  { 0 }
599 };
600 
602  { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, { .n = matroska_cluster } },
607  { 0 }
608 };
609 
611  { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, offsetof(MatroskaCluster, timecode) },
612  { MATROSKA_ID_BLOCKGROUP, EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
613  { MATROSKA_ID_SIMPLEBLOCK, EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
621  { 0 }
622 };
623 
625  { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, offsetof(MatroskaCluster, timecode) },
630  { 0 }
631 };
632 
634  { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, { .n = matroska_cluster_incremental } },
639  { 0 }
640 };
641 
642 static const char *const matroska_doctypes[] = { "matroska", "webm" };
643 
644 static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
645 {
646  AVIOContext *pb = matroska->ctx->pb;
647  uint32_t id;
648  matroska->current_id = 0;
649  matroska->num_levels = 0;
650 
651  /* seek to next position to resync from */
652  if (avio_seek(pb, last_pos + 1, SEEK_SET) < 0)
653  goto eof;
654 
655  id = avio_rb32(pb);
656 
657  // try to find a toplevel element
658  while (!avio_feof(pb)) {
659  if (id == MATROSKA_ID_INFO || id == MATROSKA_ID_TRACKS ||
660  id == MATROSKA_ID_CUES || id == MATROSKA_ID_TAGS ||
662  id == MATROSKA_ID_CLUSTER || id == MATROSKA_ID_CHAPTERS) {
663  matroska->current_id = id;
664  return 0;
665  }
666  id = (id << 8) | avio_r8(pb);
667  }
668 
669 eof:
670  matroska->done = 1;
671  return AVERROR_EOF;
672 }
673 
674 /*
675  * Return: Whether we reached the end of a level in the hierarchy or not.
676  */
678 {
679  AVIOContext *pb = matroska->ctx->pb;
680  int64_t pos = avio_tell(pb);
681 
682  if (matroska->num_levels > 0) {
683  MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
684  if (pos - level->start >= level->length || matroska->current_id) {
685  matroska->num_levels--;
686  return 1;
687  }
688  }
689  return 0;
690 }
691 
692 /*
693  * Read: an "EBML number", which is defined as a variable-length
694  * array of bytes. The first byte indicates the length by giving a
695  * number of 0-bits followed by a one. The position of the first
696  * "one" bit inside the first byte indicates the length of this
697  * number.
698  * Returns: number of bytes read, < 0 on error
699  */
701  int max_size, uint64_t *number)
702 {
703  int read = 1, n = 1;
704  uint64_t total = 0;
705 
706  /* The first byte tells us the length in bytes - avio_r8() can normally
707  * return 0, but since that's not a valid first ebmlID byte, we can
708  * use it safely here to catch EOS. */
709  if (!(total = avio_r8(pb))) {
710  /* we might encounter EOS here */
711  if (!avio_feof(pb)) {
712  int64_t pos = avio_tell(pb);
713  av_log(matroska->ctx, AV_LOG_ERROR,
714  "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
715  pos, pos);
716  return pb->error ? pb->error : AVERROR(EIO);
717  }
718  return AVERROR_EOF;
719  }
720 
721  /* get the length of the EBML number */
722  read = 8 - ff_log2_tab[total];
723  if (read > max_size) {
724  int64_t pos = avio_tell(pb) - 1;
725  av_log(matroska->ctx, AV_LOG_ERROR,
726  "Invalid EBML number size tag 0x%02x at pos %"PRIu64" (0x%"PRIx64")\n",
727  (uint8_t) total, pos, pos);
728  return AVERROR_INVALIDDATA;
729  }
730 
731  /* read out length */
732  total ^= 1 << ff_log2_tab[total];
733  while (n++ < read)
734  total = (total << 8) | avio_r8(pb);
735 
736  *number = total;
737 
738  return read;
739 }
740 
741 /**
742  * Read a EBML length value.
743  * This needs special handling for the "unknown length" case which has multiple
744  * encodings.
745  */
747  uint64_t *number)
748 {
749  int res = ebml_read_num(matroska, pb, 8, number);
750  if (res > 0 && *number + 1 == 1ULL << (7 * res))
751  *number = 0xffffffffffffffULL;
752  return res;
753 }
754 
755 /*
756  * Read the next element as an unsigned int.
757  * 0 is success, < 0 is failure.
758  */
759 static int ebml_read_uint(AVIOContext *pb, int size, uint64_t *num)
760 {
761  int n = 0;
762 
763  if (size > 8)
764  return AVERROR_INVALIDDATA;
765 
766  /* big-endian ordering; build up number */
767  *num = 0;
768  while (n++ < size)
769  *num = (*num << 8) | avio_r8(pb);
770 
771  return 0;
772 }
773 
774 /*
775  * Read the next element as a signed int.
776  * 0 is success, < 0 is failure.
777  */
778 static int ebml_read_sint(AVIOContext *pb, int size, int64_t *num)
779 {
780  int n = 1;
781 
782  if (size > 8)
783  return AVERROR_INVALIDDATA;
784 
785  if (size == 0) {
786  *num = 0;
787  } else {
788  *num = sign_extend(avio_r8(pb), 8);
789 
790  /* big-endian ordering; build up number */
791  while (n++ < size)
792  *num = (*num << 8) | avio_r8(pb);
793  }
794 
795  return 0;
796 }
797 
798 /*
799  * Read the next element as a float.
800  * 0 is success, < 0 is failure.
801  */
802 static int ebml_read_float(AVIOContext *pb, int size, double *num)
803 {
804  if (size == 0)
805  *num = 0;
806  else if (size == 4)
807  *num = av_int2float(avio_rb32(pb));
808  else if (size == 8)
809  *num = av_int2double(avio_rb64(pb));
810  else
811  return AVERROR_INVALIDDATA;
812 
813  return 0;
814 }
815 
816 /*
817  * Read the next element as an ASCII string.
818  * 0 is success, < 0 is failure.
819  */
820 static int ebml_read_ascii(AVIOContext *pb, int size, char **str)
821 {
822  char *res;
823 
824  /* EBML strings are usually not 0-terminated, so we allocate one
825  * byte more, read the string and NULL-terminate it ourselves. */
826  if (!(res = av_malloc(size + 1)))
827  return AVERROR(ENOMEM);
828  if (avio_read(pb, (uint8_t *) res, size) != size) {
829  av_free(res);
830  return AVERROR(EIO);
831  }
832  (res)[size] = '\0';
833  av_free(*str);
834  *str = res;
835 
836  return 0;
837 }
838 
839 /*
840  * Read the next element as binary data.
841  * 0 is success, < 0 is failure.
842  */
843 static int ebml_read_binary(AVIOContext *pb, int length, EbmlBin *bin)
844 {
845  av_fast_padded_malloc(&bin->data, &bin->size, length);
846  if (!bin->data)
847  return AVERROR(ENOMEM);
848 
849  bin->size = length;
850  bin->pos = avio_tell(pb);
851  if (avio_read(pb, bin->data, length) != length) {
852  av_freep(&bin->data);
853  bin->size = 0;
854  return AVERROR(EIO);
855  }
856 
857  return 0;
858 }
859 
860 /*
861  * Read the next element, but only the header. The contents
862  * are supposed to be sub-elements which can be read separately.
863  * 0 is success, < 0 is failure.
864  */
865 static int ebml_read_master(MatroskaDemuxContext *matroska, uint64_t length)
866 {
867  AVIOContext *pb = matroska->ctx->pb;
869 
870  if (matroska->num_levels >= EBML_MAX_DEPTH) {
871  av_log(matroska->ctx, AV_LOG_ERROR,
872  "File moves beyond max. allowed depth (%d)\n", EBML_MAX_DEPTH);
873  return AVERROR(ENOSYS);
874  }
875 
876  level = &matroska->levels[matroska->num_levels++];
877  level->start = avio_tell(pb);
878  level->length = length;
879 
880  return 0;
881 }
882 
883 /*
884  * Read signed/unsigned "EBML" numbers.
885  * Return: number of bytes processed, < 0 on error
886  */
888  uint8_t *data, uint32_t size, uint64_t *num)
889 {
890  AVIOContext pb;
891  ffio_init_context(&pb, data, size, 0, NULL, NULL, NULL, NULL);
892  return ebml_read_num(matroska, &pb, FFMIN(size, 8), num);
893 }
894 
895 /*
896  * Same as above, but signed.
897  */
899  uint8_t *data, uint32_t size, int64_t *num)
900 {
901  uint64_t unum;
902  int res;
903 
904  /* read as unsigned number first */
905  if ((res = matroska_ebmlnum_uint(matroska, data, size, &unum)) < 0)
906  return res;
907 
908  /* make signed (weird way) */
909  *num = unum - ((1LL << (7 * res - 1)) - 1);
910 
911  return res;
912 }
913 
914 static int ebml_parse_elem(MatroskaDemuxContext *matroska,
915  EbmlSyntax *syntax, void *data);
916 
917 static int ebml_parse_id(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
918  uint32_t id, void *data)
919 {
920  int i;
921  for (i = 0; syntax[i].id; i++)
922  if (id == syntax[i].id)
923  break;
924  if (!syntax[i].id && id == MATROSKA_ID_CLUSTER &&
925  matroska->num_levels > 0 &&
926  matroska->levels[matroska->num_levels - 1].length == 0xffffffffffffff)
927  return 0; // we reached the end of an unknown size cluster
928  if (!syntax[i].id && id != EBML_ID_VOID && id != EBML_ID_CRC32) {
929  av_log(matroska->ctx, AV_LOG_INFO, "Unknown entry 0x%"PRIX32"\n", id);
930  if (matroska->ctx->error_recognition & AV_EF_EXPLODE)
931  return AVERROR_INVALIDDATA;
932  }
933  return ebml_parse_elem(matroska, &syntax[i], data);
934 }
935 
936 static int ebml_parse(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
937  void *data)
938 {
939  if (!matroska->current_id) {
940  uint64_t id;
941  int res = ebml_read_num(matroska, matroska->ctx->pb, 4, &id);
942  if (res < 0)
943  return res;
944  matroska->current_id = id | 1 << 7 * res;
945  }
946  return ebml_parse_id(matroska, syntax, matroska->current_id, data);
947 }
948 
949 static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
950  void *data)
951 {
952  int i, res = 0;
953 
954  for (i = 0; syntax[i].id; i++)
955  switch (syntax[i].type) {
956  case EBML_UINT:
957  *(uint64_t *) ((char *) data + syntax[i].data_offset) = syntax[i].def.u;
958  break;
959  case EBML_FLOAT:
960  *(double *) ((char *) data + syntax[i].data_offset) = syntax[i].def.f;
961  break;
962  case EBML_STR:
963  case EBML_UTF8:
964  // the default may be NULL
965  if (syntax[i].def.s) {
966  uint8_t **dst = (uint8_t **) ((uint8_t *) data + syntax[i].data_offset);
967  *dst = av_strdup(syntax[i].def.s);
968  if (!*dst)
969  return AVERROR(ENOMEM);
970  }
971  break;
972  }
973 
974  while (!res && !ebml_level_end(matroska))
975  res = ebml_parse(matroska, syntax, data);
976 
977  return res;
978 }
979 
981  EbmlSyntax *syntax, void *data)
982 {
983  static const uint64_t max_lengths[EBML_TYPE_COUNT] = {
984  [EBML_UINT] = 8,
985  [EBML_FLOAT] = 8,
986  // max. 16 MB for strings
987  [EBML_STR] = 0x1000000,
988  [EBML_UTF8] = 0x1000000,
989  // max. 256 MB for binary data
990  [EBML_BIN] = 0x10000000,
991  // no limits for anything else
992  };
993  AVIOContext *pb = matroska->ctx->pb;
994  uint32_t id = syntax->id;
995  uint64_t length;
996  int res;
997  void *newelem;
998 
999  data = (char *) data + syntax->data_offset;
1000  if (syntax->list_elem_size) {
1001  EbmlList *list = data;
1002  newelem = av_realloc_array(list->elem, list->nb_elem + 1, syntax->list_elem_size);
1003  if (!newelem)
1004  return AVERROR(ENOMEM);
1005  list->elem = newelem;
1006  data = (char *) list->elem + list->nb_elem * syntax->list_elem_size;
1007  memset(data, 0, syntax->list_elem_size);
1008  list->nb_elem++;
1009  }
1010 
1011  if (syntax->type != EBML_PASS && syntax->type != EBML_STOP) {
1012  matroska->current_id = 0;
1013  if ((res = ebml_read_length(matroska, pb, &length)) < 0)
1014  return res;
1015  if (max_lengths[syntax->type] && length > max_lengths[syntax->type]) {
1016  av_log(matroska->ctx, AV_LOG_ERROR,
1017  "Invalid length 0x%"PRIx64" > 0x%"PRIx64" for syntax element %i\n",
1018  length, max_lengths[syntax->type], syntax->type);
1019  return AVERROR_INVALIDDATA;
1020  }
1021  }
1022 
1023  switch (syntax->type) {
1024  case EBML_UINT:
1025  res = ebml_read_uint(pb, length, data);
1026  break;
1027  case EBML_SINT:
1028  res = ebml_read_sint(pb, length, data);
1029  break;
1030  case EBML_FLOAT:
1031  res = ebml_read_float(pb, length, data);
1032  break;
1033  case EBML_STR:
1034  case EBML_UTF8:
1035  res = ebml_read_ascii(pb, length, data);
1036  break;
1037  case EBML_BIN:
1038  res = ebml_read_binary(pb, length, data);
1039  break;
1040  case EBML_NEST:
1041  if ((res = ebml_read_master(matroska, length)) < 0)
1042  return res;
1043  if (id == MATROSKA_ID_SEGMENT)
1044  matroska->segment_start = avio_tell(matroska->ctx->pb);
1045  return ebml_parse_nest(matroska, syntax->def.n, data);
1046  case EBML_PASS:
1047  return ebml_parse_id(matroska, syntax->def.n, id, data);
1048  case EBML_STOP:
1049  return 1;
1050  default:
1051  if (ffio_limit(pb, length) != length)
1052  return AVERROR(EIO);
1053  return avio_skip(pb, length) < 0 ? AVERROR(EIO) : 0;
1054  }
1055  if (res == AVERROR_INVALIDDATA)
1056  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
1057  else if (res == AVERROR(EIO))
1058  av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
1059  return res;
1060 }
1061 
1062 static void ebml_free(EbmlSyntax *syntax, void *data)
1063 {
1064  int i, j;
1065  for (i = 0; syntax[i].id; i++) {
1066  void *data_off = (char *) data + syntax[i].data_offset;
1067  switch (syntax[i].type) {
1068  case EBML_STR:
1069  case EBML_UTF8:
1070  av_freep(data_off);
1071  break;
1072  case EBML_BIN:
1073  av_freep(&((EbmlBin *) data_off)->data);
1074  break;
1075  case EBML_NEST:
1076  if (syntax[i].list_elem_size) {
1077  EbmlList *list = data_off;
1078  char *ptr = list->elem;
1079  for (j = 0; j < list->nb_elem;
1080  j++, ptr += syntax[i].list_elem_size)
1081  ebml_free(syntax[i].def.n, ptr);
1082  av_free(list->elem);
1083  } else
1084  ebml_free(syntax[i].def.n, data_off);
1085  default:
1086  break;
1087  }
1088  }
1089 }
1090 
1091 /*
1092  * Autodetecting...
1093  */
1095 {
1096  uint64_t total = 0;
1097  int len_mask = 0x80, size = 1, n = 1, i;
1098 
1099  /* EBML header? */
1100  if (AV_RB32(p->buf) != EBML_ID_HEADER)
1101  return 0;
1102 
1103  /* length of header */
1104  total = p->buf[4];
1105  while (size <= 8 && !(total & len_mask)) {
1106  size++;
1107  len_mask >>= 1;
1108  }
1109  if (size > 8)
1110  return 0;
1111  total &= (len_mask - 1);
1112  while (n < size)
1113  total = (total << 8) | p->buf[4 + n++];
1114 
1115  /* Does the probe data contain the whole header? */
1116  if (p->buf_size < 4 + size + total)
1117  return 0;
1118 
1119  /* The header should contain a known document type. For now,
1120  * we don't parse the whole header but simply check for the
1121  * availability of that array of characters inside the header.
1122  * Not fully fool-proof, but good enough. */
1123  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++) {
1124  int probelen = strlen(matroska_doctypes[i]);
1125  if (total < probelen)
1126  continue;
1127  for (n = 4 + size; n <= 4 + size + total - probelen; n++)
1128  if (!memcmp(p->buf + n, matroska_doctypes[i], probelen))
1129  return AVPROBE_SCORE_MAX;
1130  }
1131 
1132  // probably valid EBML header but no recognized doctype
1133  return AVPROBE_SCORE_EXTENSION;
1134 }
1135 
1137  int num)
1138 {
1139  MatroskaTrack *tracks = matroska->tracks.elem;
1140  int i;
1141 
1142  for (i = 0; i < matroska->tracks.nb_elem; i++)
1143  if (tracks[i].num == num)
1144  return &tracks[i];
1145 
1146  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %d\n", num);
1147  return NULL;
1148 }
1149 
1150 static int matroska_decode_buffer(uint8_t **buf, int *buf_size,
1151  MatroskaTrack *track)
1152 {
1153  MatroskaTrackEncoding *encodings = track->encodings.elem;
1154  uint8_t *data = *buf;
1155  int isize = *buf_size;
1156  uint8_t *pkt_data = NULL;
1157  uint8_t av_unused *newpktdata;
1158  int pkt_size = isize;
1159  int result = 0;
1160  int olen;
1161 
1162  if (pkt_size >= 10000000U)
1163  return AVERROR_INVALIDDATA;
1164 
1165  switch (encodings[0].compression.algo) {
1167  {
1168  int header_size = encodings[0].compression.settings.size;
1169  uint8_t *header = encodings[0].compression.settings.data;
1170 
1171  if (header_size && !header) {
1172  av_log(NULL, AV_LOG_ERROR, "Compression size but no data in headerstrip\n");
1173  return -1;
1174  }
1175 
1176  if (!header_size)
1177  return 0;
1178 
1179  pkt_size = isize + header_size;
1180  pkt_data = av_malloc(pkt_size);
1181  if (!pkt_data)
1182  return AVERROR(ENOMEM);
1183 
1184  memcpy(pkt_data, header, header_size);
1185  memcpy(pkt_data + header_size, data, isize);
1186  break;
1187  }
1188 #if CONFIG_LZO
1190  do {
1191  olen = pkt_size *= 3;
1192  newpktdata = av_realloc(pkt_data, pkt_size + AV_LZO_OUTPUT_PADDING);
1193  if (!newpktdata) {
1194  result = AVERROR(ENOMEM);
1195  goto failed;
1196  }
1197  pkt_data = newpktdata;
1198  result = av_lzo1x_decode(pkt_data, &olen, data, &isize);
1199  } while (result == AV_LZO_OUTPUT_FULL && pkt_size < 10000000);
1200  if (result) {
1201  result = AVERROR_INVALIDDATA;
1202  goto failed;
1203  }
1204  pkt_size -= olen;
1205  break;
1206 #endif
1207 #if CONFIG_ZLIB
1209  {
1210  z_stream zstream = { 0 };
1211  if (inflateInit(&zstream) != Z_OK)
1212  return -1;
1213  zstream.next_in = data;
1214  zstream.avail_in = isize;
1215  do {
1216  pkt_size *= 3;
1217  newpktdata = av_realloc(pkt_data, pkt_size);
1218  if (!newpktdata) {
1219  inflateEnd(&zstream);
1220  goto failed;
1221  }
1222  pkt_data = newpktdata;
1223  zstream.avail_out = pkt_size - zstream.total_out;
1224  zstream.next_out = pkt_data + zstream.total_out;
1225  if (pkt_data) {
1226  result = inflate(&zstream, Z_NO_FLUSH);
1227  } else
1228  result = Z_MEM_ERROR;
1229  } while (result == Z_OK && pkt_size < 10000000);
1230  pkt_size = zstream.total_out;
1231  inflateEnd(&zstream);
1232  if (result != Z_STREAM_END) {
1233  if (result == Z_MEM_ERROR)
1234  result = AVERROR(ENOMEM);
1235  else
1236  result = AVERROR_INVALIDDATA;
1237  goto failed;
1238  }
1239  break;
1240  }
1241 #endif
1242 #if CONFIG_BZLIB
1244  {
1245  bz_stream bzstream = { 0 };
1246  if (BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
1247  return -1;
1248  bzstream.next_in = data;
1249  bzstream.avail_in = isize;
1250  do {
1251  pkt_size *= 3;
1252  newpktdata = av_realloc(pkt_data, pkt_size);
1253  if (!newpktdata) {
1254  BZ2_bzDecompressEnd(&bzstream);
1255  goto failed;
1256  }
1257  pkt_data = newpktdata;
1258  bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
1259  bzstream.next_out = pkt_data + bzstream.total_out_lo32;
1260  if (pkt_data) {
1261  result = BZ2_bzDecompress(&bzstream);
1262  } else
1263  result = BZ_MEM_ERROR;
1264  } while (result == BZ_OK && pkt_size < 10000000);
1265  pkt_size = bzstream.total_out_lo32;
1266  BZ2_bzDecompressEnd(&bzstream);
1267  if (result != BZ_STREAM_END) {
1268  if (result == BZ_MEM_ERROR)
1269  result = AVERROR(ENOMEM);
1270  else
1271  result = AVERROR_INVALIDDATA;
1272  goto failed;
1273  }
1274  break;
1275  }
1276 #endif
1277  default:
1278  return AVERROR_INVALIDDATA;
1279  }
1280 
1281  *buf = pkt_data;
1282  *buf_size = pkt_size;
1283  return 0;
1284 
1285 failed:
1286  av_free(pkt_data);
1287  return result;
1288 }
1289 
1291  AVDictionary **metadata, char *prefix)
1292 {
1293  MatroskaTag *tags = list->elem;
1294  char key[1024];
1295  int i;
1296 
1297  for (i = 0; i < list->nb_elem; i++) {
1298  const char *lang = tags[i].lang &&
1299  strcmp(tags[i].lang, "und") ? tags[i].lang : NULL;
1300 
1301  if (!tags[i].name) {
1302  av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no TagName.\n");
1303  continue;
1304  }
1305  if (prefix)
1306  snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
1307  else
1308  av_strlcpy(key, tags[i].name, sizeof(key));
1309  if (tags[i].def || !lang) {
1310  av_dict_set(metadata, key, tags[i].string, 0);
1311  if (tags[i].sub.nb_elem)
1312  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1313  }
1314  if (lang) {
1315  av_strlcat(key, "-", sizeof(key));
1316  av_strlcat(key, lang, sizeof(key));
1317  av_dict_set(metadata, key, tags[i].string, 0);
1318  if (tags[i].sub.nb_elem)
1319  matroska_convert_tag(s, &tags[i].sub, metadata, key);
1320  }
1321  }
1322  ff_metadata_conv(metadata, NULL, ff_mkv_metadata_conv);
1323 }
1324 
1326 {
1327  MatroskaDemuxContext *matroska = s->priv_data;
1328  MatroskaTags *tags = matroska->tags.elem;
1329  int i, j;
1330 
1331  for (i = 0; i < matroska->tags.nb_elem; i++) {
1332  if (tags[i].target.attachuid) {
1333  MatroskaAttachment *attachment = matroska->attachments.elem;
1334  for (j = 0; j < matroska->attachments.nb_elem; j++)
1335  if (attachment[j].uid == tags[i].target.attachuid &&
1336  attachment[j].stream)
1337  matroska_convert_tag(s, &tags[i].tag,
1338  &attachment[j].stream->metadata, NULL);
1339  } else if (tags[i].target.chapteruid) {
1340  MatroskaChapter *chapter = matroska->chapters.elem;
1341  for (j = 0; j < matroska->chapters.nb_elem; j++)
1342  if (chapter[j].uid == tags[i].target.chapteruid &&
1343  chapter[j].chapter)
1344  matroska_convert_tag(s, &tags[i].tag,
1345  &chapter[j].chapter->metadata, NULL);
1346  } else if (tags[i].target.trackuid) {
1347  MatroskaTrack *track = matroska->tracks.elem;
1348  for (j = 0; j < matroska->tracks.nb_elem; j++)
1349  if (track[j].uid == tags[i].target.trackuid && track[j].stream)
1350  matroska_convert_tag(s, &tags[i].tag,
1351  &track[j].stream->metadata, NULL);
1352  } else {
1353  matroska_convert_tag(s, &tags[i].tag, &s->metadata,
1354  tags[i].target.type);
1355  }
1356  }
1357 }
1358 
1360  int idx)
1361 {
1362  EbmlList *seekhead_list = &matroska->seekhead;
1363  uint32_t level_up = matroska->level_up;
1364  uint32_t saved_id = matroska->current_id;
1365  MatroskaSeekhead *seekhead = seekhead_list->elem;
1366  int64_t before_pos = avio_tell(matroska->ctx->pb);
1368  int64_t offset;
1369  int ret = 0;
1370 
1371  if (idx >= seekhead_list->nb_elem ||
1372  seekhead[idx].id == MATROSKA_ID_SEEKHEAD ||
1373  seekhead[idx].id == MATROSKA_ID_CLUSTER)
1374  return 0;
1375 
1376  /* seek */
1377  offset = seekhead[idx].pos + matroska->segment_start;
1378  if (avio_seek(matroska->ctx->pb, offset, SEEK_SET) == offset) {
1379  /* We don't want to lose our seekhead level, so we add
1380  * a dummy. This is a crude hack. */
1381  if (matroska->num_levels == EBML_MAX_DEPTH) {
1382  av_log(matroska->ctx, AV_LOG_INFO,
1383  "Max EBML element depth (%d) reached, "
1384  "cannot parse further.\n", EBML_MAX_DEPTH);
1385  ret = AVERROR_INVALIDDATA;
1386  } else {
1387  level.start = 0;
1388  level.length = (uint64_t) -1;
1389  matroska->levels[matroska->num_levels] = level;
1390  matroska->num_levels++;
1391  matroska->current_id = 0;
1392 
1393  ret = ebml_parse(matroska, matroska_segment, matroska);
1394 
1395  /* remove dummy level */
1396  while (matroska->num_levels) {
1397  uint64_t length = matroska->levels[--matroska->num_levels].length;
1398  if (length == (uint64_t) -1)
1399  break;
1400  }
1401  }
1402  }
1403  /* seek back */
1404  avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
1405  matroska->level_up = level_up;
1406  matroska->current_id = saved_id;
1407 
1408  return ret;
1409 }
1410 
1412 {
1413  EbmlList *seekhead_list = &matroska->seekhead;
1414  int64_t before_pos = avio_tell(matroska->ctx->pb);
1415  int i;
1416 
1417  // we should not do any seeking in the streaming case
1418  if (!matroska->ctx->pb->seekable ||
1419  (matroska->ctx->flags & AVFMT_FLAG_IGNIDX))
1420  return;
1421 
1422  for (i = 0; i < seekhead_list->nb_elem; i++) {
1423  MatroskaSeekhead *seekhead = seekhead_list->elem;
1424  if (seekhead[i].pos <= before_pos)
1425  continue;
1426 
1427  // defer cues parsing until we actually need cue data.
1428  if (seekhead[i].id == MATROSKA_ID_CUES) {
1429  matroska->cues_parsing_deferred = 1;
1430  continue;
1431  }
1432 
1433  if (matroska_parse_seekhead_entry(matroska, i) < 0) {
1434  // mark index as broken
1435  matroska->cues_parsing_deferred = -1;
1436  break;
1437  }
1438  }
1439 }
1440 
1442 {
1443  EbmlList *index_list;
1445  int index_scale = 1;
1446  int i, j;
1447 
1448  index_list = &matroska->index;
1449  index = index_list->elem;
1450  if (index_list->nb_elem &&
1451  index[0].time > 1E14 / matroska->time_scale) {
1452  av_log(matroska->ctx, AV_LOG_WARNING, "Working around broken index.\n");
1453  index_scale = matroska->time_scale;
1454  }
1455  for (i = 0; i < index_list->nb_elem; i++) {
1456  EbmlList *pos_list = &index[i].pos;
1457  MatroskaIndexPos *pos = pos_list->elem;
1458  for (j = 0; j < pos_list->nb_elem; j++) {
1459  MatroskaTrack *track = matroska_find_track_by_num(matroska,
1460  pos[j].track);
1461  if (track && track->stream)
1462  av_add_index_entry(track->stream,
1463  pos[j].pos + matroska->segment_start,
1464  index[i].time / index_scale, 0, 0,
1466  }
1467  }
1468 }
1469 
1471  EbmlList *seekhead_list = &matroska->seekhead;
1472  MatroskaSeekhead *seekhead = seekhead_list->elem;
1473  int i;
1474 
1475  for (i = 0; i < seekhead_list->nb_elem; i++)
1476  if (seekhead[i].id == MATROSKA_ID_CUES)
1477  break;
1478  av_assert1(i <= seekhead_list->nb_elem);
1479 
1480  if (matroska_parse_seekhead_entry(matroska, i) < 0)
1481  matroska->cues_parsing_deferred = -1;
1482  matroska_add_index_entries(matroska);
1483 }
1484 
1486 {
1487  static const char *const aac_profiles[] = { "MAIN", "LC", "SSR" };
1488  int profile;
1489 
1490  for (profile = 0; profile < FF_ARRAY_ELEMS(aac_profiles); profile++)
1491  if (strstr(codec_id, aac_profiles[profile]))
1492  break;
1493  return profile + 1;
1494 }
1495 
1496 static int matroska_aac_sri(int samplerate)
1497 {
1498  int sri;
1499 
1500  for (sri = 0; sri < FF_ARRAY_ELEMS(avpriv_mpeg4audio_sample_rates); sri++)
1501  if (avpriv_mpeg4audio_sample_rates[sri] == samplerate)
1502  break;
1503  return sri;
1504 }
1505 
1506 static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
1507 {
1508  char buffer[32];
1509  /* Convert to seconds and adjust by number of seconds between 2001-01-01 and Epoch */
1510  time_t creation_time = date_utc / 1000000000 + 978307200;
1511  struct tm tmpbuf, *ptm = gmtime_r(&creation_time, &tmpbuf);
1512  if (!ptm) return;
1513  if (strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm))
1514  av_dict_set(metadata, "creation_time", buffer, 0);
1515 }
1516 
1518  MatroskaTrack *track,
1519  int *offset)
1520 {
1521  AVStream *st = track->stream;
1522  uint8_t *p = track->codec_priv.data;
1523  int size = track->codec_priv.size;
1524 
1525  if (size < 8 + FLAC_STREAMINFO_SIZE || p[4] & 0x7f) {
1526  av_log(s, AV_LOG_WARNING, "Invalid FLAC private data\n");
1527  track->codec_priv.size = 0;
1528  return 0;
1529  }
1530  *offset = 8;
1531  track->codec_priv.size = 8 + FLAC_STREAMINFO_SIZE;
1532 
1533  p += track->codec_priv.size;
1534  size -= track->codec_priv.size;
1535 
1536  /* parse the remaining metadata blocks if present */
1537  while (size >= 4) {
1538  int block_last, block_type, block_size;
1539 
1540  flac_parse_block_header(p, &block_last, &block_type, &block_size);
1541 
1542  p += 4;
1543  size -= 4;
1544  if (block_size > size)
1545  return 0;
1546 
1547  /* check for the channel mask */
1548  if (block_type == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
1549  AVDictionary *dict = NULL;
1550  AVDictionaryEntry *chmask;
1551 
1552  ff_vorbis_comment(s, &dict, p, block_size, 0);
1553  chmask = av_dict_get(dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", NULL, 0);
1554  if (chmask) {
1555  uint64_t mask = strtol(chmask->value, NULL, 0);
1556  if (!mask || mask & ~0x3ffffULL) {
1558  "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
1559  } else
1560  st->codec->channel_layout = mask;
1561  }
1562  av_dict_free(&dict);
1563  }
1564 
1565  p += block_size;
1566  size -= block_size;
1567  }
1568 
1569  return 0;
1570 }
1571 
1573 {
1574  MatroskaDemuxContext *matroska = s->priv_data;
1575  MatroskaTrack *tracks = matroska->tracks.elem;
1576  AVStream *st;
1577  int i, j, ret;
1578  int k;
1579 
1580  for (i = 0; i < matroska->tracks.nb_elem; i++) {
1581  MatroskaTrack *track = &tracks[i];
1583  EbmlList *encodings_list = &track->encodings;
1584  MatroskaTrackEncoding *encodings = encodings_list->elem;
1585  uint8_t *extradata = NULL;
1586  int extradata_size = 0;
1587  int extradata_offset = 0;
1588  uint32_t fourcc = 0;
1589  AVIOContext b;
1590  char* key_id_base64 = NULL;
1591  int bit_depth = -1;
1592 
1593  /* Apply some sanity checks. */
1594  if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
1595  track->type != MATROSKA_TRACK_TYPE_AUDIO &&
1596  track->type != MATROSKA_TRACK_TYPE_SUBTITLE &&
1597  track->type != MATROSKA_TRACK_TYPE_METADATA) {
1598  av_log(matroska->ctx, AV_LOG_INFO,
1599  "Unknown or unsupported track type %"PRIu64"\n",
1600  track->type);
1601  continue;
1602  }
1603  if (!track->codec_id)
1604  continue;
1605 
1606  if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
1607  if (!track->default_duration && track->video.frame_rate > 0)
1608  track->default_duration = 1000000000 / track->video.frame_rate;
1609  if (track->video.display_width == -1)
1610  track->video.display_width = track->video.pixel_width;
1611  if (track->video.display_height == -1)
1612  track->video.display_height = track->video.pixel_height;
1613  if (track->video.color_space.size == 4)
1614  fourcc = AV_RL32(track->video.color_space.data);
1615  } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
1616  if (!track->audio.out_samplerate)
1617  track->audio.out_samplerate = track->audio.samplerate;
1618  }
1619  if (encodings_list->nb_elem > 1) {
1620  av_log(matroska->ctx, AV_LOG_ERROR,
1621  "Multiple combined encodings not supported");
1622  } else if (encodings_list->nb_elem == 1) {
1623  if (encodings[0].type) {
1624  if (encodings[0].encryption.key_id.size > 0) {
1625  /* Save the encryption key id to be stored later as a
1626  metadata tag. */
1627  const int b64_size = AV_BASE64_SIZE(encodings[0].encryption.key_id.size);
1628  key_id_base64 = av_malloc(b64_size);
1629  if (key_id_base64 == NULL)
1630  return AVERROR(ENOMEM);
1631 
1632  av_base64_encode(key_id_base64, b64_size,
1633  encodings[0].encryption.key_id.data,
1634  encodings[0].encryption.key_id.size);
1635  } else {
1636  encodings[0].scope = 0;
1637  av_log(matroska->ctx, AV_LOG_ERROR,
1638  "Unsupported encoding type");
1639  }
1640  } else if (
1641 #if CONFIG_ZLIB
1642  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB &&
1643 #endif
1644 #if CONFIG_BZLIB
1646 #endif
1647 #if CONFIG_LZO
1649 #endif
1651  encodings[0].scope = 0;
1652  av_log(matroska->ctx, AV_LOG_ERROR,
1653  "Unsupported encoding type");
1654  } else if (track->codec_priv.size && encodings[0].scope & 2) {
1655  uint8_t *codec_priv = track->codec_priv.data;
1656  int ret = matroska_decode_buffer(&track->codec_priv.data,
1657  &track->codec_priv.size,
1658  track);
1659  if (ret < 0) {
1660  track->codec_priv.data = NULL;
1661  track->codec_priv.size = 0;
1662  av_log(matroska->ctx, AV_LOG_ERROR,
1663  "Failed to decode codec private data\n");
1664  }
1665 
1666  if (codec_priv != track->codec_priv.data)
1667  av_free(codec_priv);
1668  }
1669  }
1670 
1671  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
1672  if (!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
1673  strlen(ff_mkv_codec_tags[j].str))) {
1674  codec_id = ff_mkv_codec_tags[j].id;
1675  break;
1676  }
1677  }
1678 
1679  st = track->stream = avformat_new_stream(s, NULL);
1680  if (!st) {
1681  av_free(key_id_base64);
1682  return AVERROR(ENOMEM);
1683  }
1684 
1685  if (key_id_base64) {
1686  /* export encryption key id as base64 metadata tag */
1687  av_dict_set(&st->metadata, "enc_key_id", key_id_base64, 0);
1688  av_freep(&key_id_base64);
1689  }
1690 
1691  if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC") &&
1692  track->codec_priv.size >= 40 &&
1693  track->codec_priv.data) {
1694  track->ms_compat = 1;
1695  bit_depth = AV_RL16(track->codec_priv.data + 14);
1696  fourcc = AV_RL32(track->codec_priv.data + 16);
1698  fourcc);
1699  if (!codec_id)
1701  fourcc);
1702  extradata_offset = 40;
1703  } else if (!strcmp(track->codec_id, "A_MS/ACM") &&
1704  track->codec_priv.size >= 14 &&
1705  track->codec_priv.data) {
1706  int ret;
1707  ffio_init_context(&b, track->codec_priv.data,
1708  track->codec_priv.size,
1709  0, NULL, NULL, NULL, NULL);
1710  ret = ff_get_wav_header(&b, st->codec, track->codec_priv.size);
1711  if (ret < 0)
1712  return ret;
1713  codec_id = st->codec->codec_id;
1714  extradata_offset = FFMIN(track->codec_priv.size, 18);
1715  } else if (!strcmp(track->codec_id, "A_QUICKTIME")
1716  && (track->codec_priv.size >= 86)
1717  && (track->codec_priv.data)) {
1718  fourcc = AV_RL32(track->codec_priv.data + 4);
1719  codec_id = ff_codec_get_id(ff_codec_movaudio_tags, fourcc);
1721  fourcc = AV_RL32(track->codec_priv.data);
1722  codec_id = ff_codec_get_id(ff_codec_movaudio_tags, fourcc);
1723  }
1724  } else if (!strcmp(track->codec_id, "V_QUICKTIME") &&
1725  (track->codec_priv.size >= 21) &&
1726  (track->codec_priv.data)) {
1727  fourcc = AV_RL32(track->codec_priv.data + 4);
1728  codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
1730  fourcc = AV_RL32(track->codec_priv.data);
1731  codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
1732  }
1733  if (codec_id == AV_CODEC_ID_NONE && AV_RL32(track->codec_priv.data+4) == AV_RL32("SMI "))
1734  codec_id = AV_CODEC_ID_SVQ3;
1735  } else if (codec_id == AV_CODEC_ID_PCM_S16BE) {
1736  switch (track->audio.bitdepth) {
1737  case 8:
1738  codec_id = AV_CODEC_ID_PCM_U8;
1739  break;
1740  case 24:
1741  codec_id = AV_CODEC_ID_PCM_S24BE;
1742  break;
1743  case 32:
1744  codec_id = AV_CODEC_ID_PCM_S32BE;
1745  break;
1746  }
1747  } else if (codec_id == AV_CODEC_ID_PCM_S16LE) {
1748  switch (track->audio.bitdepth) {
1749  case 8:
1750  codec_id = AV_CODEC_ID_PCM_U8;
1751  break;
1752  case 24:
1753  codec_id = AV_CODEC_ID_PCM_S24LE;
1754  break;
1755  case 32:
1756  codec_id = AV_CODEC_ID_PCM_S32LE;
1757  break;
1758  }
1759  } else if (codec_id == AV_CODEC_ID_PCM_F32LE &&
1760  track->audio.bitdepth == 64) {
1761  codec_id = AV_CODEC_ID_PCM_F64LE;
1762  } else if (codec_id == AV_CODEC_ID_AAC && !track->codec_priv.size) {
1763  int profile = matroska_aac_profile(track->codec_id);
1764  int sri = matroska_aac_sri(track->audio.samplerate);
1765  extradata = av_mallocz(5 + FF_INPUT_BUFFER_PADDING_SIZE);
1766  if (!extradata)
1767  return AVERROR(ENOMEM);
1768  extradata[0] = (profile << 3) | ((sri & 0x0E) >> 1);
1769  extradata[1] = ((sri & 0x01) << 7) | (track->audio.channels << 3);
1770  if (strstr(track->codec_id, "SBR")) {
1771  sri = matroska_aac_sri(track->audio.out_samplerate);
1772  extradata[2] = 0x56;
1773  extradata[3] = 0xE5;
1774  extradata[4] = 0x80 | (sri << 3);
1775  extradata_size = 5;
1776  } else
1777  extradata_size = 2;
1778  } else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size && track->codec_priv.size < INT_MAX - 12 - FF_INPUT_BUFFER_PADDING_SIZE) {
1779  /* Only ALAC's magic cookie is stored in Matroska's track headers.
1780  * Create the "atom size", "tag", and "tag version" fields the
1781  * decoder expects manually. */
1782  extradata_size = 12 + track->codec_priv.size;
1783  extradata = av_mallocz(extradata_size +
1785  if (!extradata)
1786  return AVERROR(ENOMEM);
1787  AV_WB32(extradata, extradata_size);
1788  memcpy(&extradata[4], "alac", 4);
1789  AV_WB32(&extradata[8], 0);
1790  memcpy(&extradata[12], track->codec_priv.data,
1791  track->codec_priv.size);
1792  } else if (codec_id == AV_CODEC_ID_TTA) {
1793  extradata_size = 30;
1794  extradata = av_mallocz(extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1795  if (!extradata)
1796  return AVERROR(ENOMEM);
1797  ffio_init_context(&b, extradata, extradata_size, 1,
1798  NULL, NULL, NULL, NULL);
1799  avio_write(&b, "TTA1", 4);
1800  avio_wl16(&b, 1);
1801  avio_wl16(&b, track->audio.channels);
1802  avio_wl16(&b, track->audio.bitdepth);
1803  if (track->audio.out_samplerate < 0 || track->audio.out_samplerate > INT_MAX)
1804  return AVERROR_INVALIDDATA;
1805  avio_wl32(&b, track->audio.out_samplerate);
1806  avio_wl32(&b, av_rescale((matroska->duration * matroska->time_scale),
1807  track->audio.out_samplerate,
1808  AV_TIME_BASE * 1000));
1809  } else if (codec_id == AV_CODEC_ID_RV10 ||
1810  codec_id == AV_CODEC_ID_RV20 ||
1811  codec_id == AV_CODEC_ID_RV30 ||
1812  codec_id == AV_CODEC_ID_RV40) {
1813  extradata_offset = 26;
1814  } else if (codec_id == AV_CODEC_ID_RA_144) {
1815  track->audio.out_samplerate = 8000;
1816  track->audio.channels = 1;
1817  } else if ((codec_id == AV_CODEC_ID_RA_288 ||
1818  codec_id == AV_CODEC_ID_COOK ||
1819  codec_id == AV_CODEC_ID_ATRAC3 ||
1820  codec_id == AV_CODEC_ID_SIPR)
1821  && track->codec_priv.data) {
1822  int flavor;
1823 
1824  ffio_init_context(&b, track->codec_priv.data,
1825  track->codec_priv.size,
1826  0, NULL, NULL, NULL, NULL);
1827  avio_skip(&b, 22);
1828  flavor = avio_rb16(&b);
1829  track->audio.coded_framesize = avio_rb32(&b);
1830  avio_skip(&b, 12);
1831  track->audio.sub_packet_h = avio_rb16(&b);
1832  track->audio.frame_size = avio_rb16(&b);
1833  track->audio.sub_packet_size = avio_rb16(&b);
1834  if (flavor < 0 ||
1835  track->audio.coded_framesize <= 0 ||
1836  track->audio.sub_packet_h <= 0 ||
1837  track->audio.frame_size <= 0 ||
1838  track->audio.sub_packet_size <= 0)
1839  return AVERROR_INVALIDDATA;
1840  track->audio.buf = av_malloc_array(track->audio.sub_packet_h,
1841  track->audio.frame_size);
1842  if (!track->audio.buf)
1843  return AVERROR(ENOMEM);
1844  if (codec_id == AV_CODEC_ID_RA_288) {
1845  st->codec->block_align = track->audio.coded_framesize;
1846  track->codec_priv.size = 0;
1847  } else {
1848  if (codec_id == AV_CODEC_ID_SIPR && flavor < 4) {
1849  static const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
1850  track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
1851  st->codec->bit_rate = sipr_bit_rate[flavor];
1852  }
1853  st->codec->block_align = track->audio.sub_packet_size;
1854  extradata_offset = 78;
1855  }
1856  } else if (codec_id == AV_CODEC_ID_FLAC && track->codec_priv.size) {
1857  ret = matroska_parse_flac(s, track, &extradata_offset);
1858  if (ret < 0)
1859  return ret;
1860  } else if (codec_id == AV_CODEC_ID_PRORES && track->codec_priv.size == 4) {
1861  fourcc = AV_RL32(track->codec_priv.data);
1862  }
1863  track->codec_priv.size -= extradata_offset;
1864 
1865  if (codec_id == AV_CODEC_ID_NONE)
1866  av_log(matroska->ctx, AV_LOG_INFO,
1867  "Unknown/unsupported AVCodecID %s.\n", track->codec_id);
1868 
1869  if (track->time_scale < 0.01)
1870  track->time_scale = 1.0;
1871  avpriv_set_pts_info(st, 64, matroska->time_scale * track->time_scale,
1872  1000 * 1000 * 1000); /* 64 bit pts in ns */
1873 
1874  /* convert the delay from ns to the track timebase */
1875  track->codec_delay = av_rescale_q(track->codec_delay,
1876  (AVRational){ 1, 1000000000 },
1877  st->time_base);
1878 
1879  st->codec->codec_id = codec_id;
1880 
1881  if (strcmp(track->language, "und"))
1882  av_dict_set(&st->metadata, "language", track->language, 0);
1883  av_dict_set(&st->metadata, "title", track->name, 0);
1884 
1885  if (track->flag_default)
1887  if (track->flag_forced)
1889 
1890  if (!st->codec->extradata) {
1891  if (extradata) {
1892  st->codec->extradata = extradata;
1893  st->codec->extradata_size = extradata_size;
1894  } else if (track->codec_priv.data && track->codec_priv.size > 0) {
1895  if (ff_alloc_extradata(st->codec, track->codec_priv.size))
1896  return AVERROR(ENOMEM);
1897  memcpy(st->codec->extradata,
1898  track->codec_priv.data + extradata_offset,
1899  track->codec_priv.size);
1900  }
1901  }
1902 
1903  if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
1904  MatroskaTrackPlane *planes = track->operation.combine_planes.elem;
1905 
1907  st->codec->codec_tag = fourcc;
1908  if (bit_depth >= 0)
1909  st->codec->bits_per_coded_sample = bit_depth;
1910  st->codec->width = track->video.pixel_width;
1911  st->codec->height = track->video.pixel_height;
1913  &st->sample_aspect_ratio.den,
1914  st->codec->height * track->video.display_width,
1915  st->codec->width * track->video.display_height,
1916  255);
1917  if (st->codec->codec_id != AV_CODEC_ID_HEVC)
1919 
1920  if (track->default_duration) {
1922  1000000000, track->default_duration, 30000);
1923 #if FF_API_R_FRAME_RATE
1924  if ( st->avg_frame_rate.num < st->avg_frame_rate.den * 1000L
1925  && st->avg_frame_rate.num > st->avg_frame_rate.den * 5L)
1926  st->r_frame_rate = st->avg_frame_rate;
1927 #endif
1928  }
1929 
1930  /* export stereo mode flag as metadata tag */
1931  if (track->video.stereo_mode && track->video.stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
1932  av_dict_set(&st->metadata, "stereo_mode", ff_matroska_video_stereo_mode[track->video.stereo_mode], 0);
1933 
1934  /* export alpha mode flag as metadata tag */
1935  if (track->video.alpha_mode)
1936  av_dict_set(&st->metadata, "alpha_mode", "1", 0);
1937 
1938  /* if we have virtual track, mark the real tracks */
1939  for (j=0; j < track->operation.combine_planes.nb_elem; j++) {
1940  char buf[32];
1941  if (planes[j].type >= MATROSKA_VIDEO_STEREO_PLANE_COUNT)
1942  continue;
1943  snprintf(buf, sizeof(buf), "%s_%d",
1944  ff_matroska_video_stereo_plane[planes[j].type], i);
1945  for (k=0; k < matroska->tracks.nb_elem; k++)
1946  if (planes[j].uid == tracks[k].uid) {
1947  av_dict_set(&s->streams[k]->metadata,
1948  "stereo_mode", buf, 0);
1949  break;
1950  }
1951  }
1952  // add stream level stereo3d side data if it is a supported format
1953  if (track->video.stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB &&
1954  track->video.stereo_mode != 10 && track->video.stereo_mode != 12) {
1955  int ret = ff_mkv_stereo3d_conv(st, track->video.stereo_mode);
1956  if (ret < 0)
1957  return ret;
1958  }
1959  } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
1961  st->codec->sample_rate = track->audio.out_samplerate;
1962  st->codec->channels = track->audio.channels;
1963  if (!st->codec->bits_per_coded_sample)
1964  st->codec->bits_per_coded_sample = track->audio.bitdepth;
1965  if (st->codec->codec_id != AV_CODEC_ID_AAC)
1967  if (track->codec_delay > 0) {
1968  st->codec->delay = av_rescale_q(track->codec_delay,
1969  st->time_base,
1970  (AVRational){1, st->codec->sample_rate});
1971  }
1972  if (track->seek_preroll > 0) {
1974  av_rescale_q(track->seek_preroll,
1975  (AVRational){1, 1000000000},
1976  (AVRational){1, st->codec->sample_rate}));
1977  }
1978  } else if (codec_id == AV_CODEC_ID_WEBVTT) {
1979  st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
1980 
1981  if (!strcmp(track->codec_id, "D_WEBVTT/CAPTIONS")) {
1982  st->disposition |= AV_DISPOSITION_CAPTIONS;
1983  } else if (!strcmp(track->codec_id, "D_WEBVTT/DESCRIPTIONS")) {
1984  st->disposition |= AV_DISPOSITION_DESCRIPTIONS;
1985  } else if (!strcmp(track->codec_id, "D_WEBVTT/METADATA")) {
1986  st->disposition |= AV_DISPOSITION_METADATA;
1987  }
1988  } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
1989  st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
1990  if (st->codec->codec_id == AV_CODEC_ID_ASS)
1991  matroska->contains_ssa = 1;
1992  }
1993  }
1994 
1995  return 0;
1996 }
1997 
1999 {
2000  MatroskaDemuxContext *matroska = s->priv_data;
2001  EbmlList *attachments_list = &matroska->attachments;
2002  EbmlList *chapters_list = &matroska->chapters;
2003  MatroskaAttachment *attachments;
2004  MatroskaChapter *chapters;
2005  uint64_t max_start = 0;
2006  int64_t pos;
2007  Ebml ebml = { 0 };
2008  int i, j, res;
2009 
2010  matroska->ctx = s;
2011 
2012  /* First read the EBML header. */
2013  if (ebml_parse(matroska, ebml_syntax, &ebml) ||
2014  ebml.version > EBML_VERSION ||
2015  ebml.max_size > sizeof(uint64_t) ||
2016  ebml.id_length > sizeof(uint32_t) ||
2017  ebml.doctype_version > 3 ||
2018  !ebml.doctype) {
2019  av_log(matroska->ctx, AV_LOG_ERROR,
2020  "EBML header using unsupported features\n"
2021  "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
2022  ebml.version, ebml.doctype, ebml.doctype_version);
2023  ebml_free(ebml_syntax, &ebml);
2024  return AVERROR_PATCHWELCOME;
2025  } else if (ebml.doctype_version == 3) {
2026  av_log(matroska->ctx, AV_LOG_WARNING,
2027  "EBML header using unsupported features\n"
2028  "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
2029  ebml.version, ebml.doctype, ebml.doctype_version);
2030  }
2031  for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++)
2032  if (!strcmp(ebml.doctype, matroska_doctypes[i]))
2033  break;
2034  if (i >= FF_ARRAY_ELEMS(matroska_doctypes)) {
2035  av_log(s, AV_LOG_WARNING, "Unknown EBML doctype '%s'\n", ebml.doctype);
2036  if (matroska->ctx->error_recognition & AV_EF_EXPLODE) {
2037  ebml_free(ebml_syntax, &ebml);
2038  return AVERROR_INVALIDDATA;
2039  }
2040  }
2041  ebml_free(ebml_syntax, &ebml);
2042 
2043  /* The next thing is a segment. */
2044  pos = avio_tell(matroska->ctx->pb);
2045  res = ebml_parse(matroska, matroska_segments, matroska);
2046  // try resyncing until we find a EBML_STOP type element.
2047  while (res != 1) {
2048  res = matroska_resync(matroska, pos);
2049  if (res < 0)
2050  return res;
2051  pos = avio_tell(matroska->ctx->pb);
2052  res = ebml_parse(matroska, matroska_segment, matroska);
2053  }
2054  matroska_execute_seekhead(matroska);
2055 
2056  if (!matroska->time_scale)
2057  matroska->time_scale = 1000000;
2058  if (matroska->duration)
2059  matroska->ctx->duration = matroska->duration * matroska->time_scale *
2060  1000 / AV_TIME_BASE;
2061  av_dict_set(&s->metadata, "title", matroska->title, 0);
2062  av_dict_set(&s->metadata, "encoder", matroska->muxingapp, 0);
2063 
2064  if (matroska->date_utc.size == 8)
2066 
2067  res = matroska_parse_tracks(s);
2068  if (res < 0)
2069  return res;
2070 
2071  attachments = attachments_list->elem;
2072  for (j = 0; j < attachments_list->nb_elem; j++) {
2073  if (!(attachments[j].filename && attachments[j].mime &&
2074  attachments[j].bin.data && attachments[j].bin.size > 0)) {
2075  av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
2076  } else {
2077  AVStream *st = avformat_new_stream(s, NULL);
2078  if (!st)
2079  break;
2080  av_dict_set(&st->metadata, "filename", attachments[j].filename, 0);
2081  av_dict_set(&st->metadata, "mimetype", attachments[j].mime, 0);
2084  if (ff_alloc_extradata(st->codec, attachments[j].bin.size))
2085  break;
2086  memcpy(st->codec->extradata, attachments[j].bin.data,
2087  attachments[j].bin.size);
2088 
2089  for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
2090  if (!strncmp(ff_mkv_mime_tags[i].str, attachments[j].mime,
2091  strlen(ff_mkv_mime_tags[i].str))) {
2092  st->codec->codec_id = ff_mkv_mime_tags[i].id;
2093  break;
2094  }
2095  }
2096  attachments[j].stream = st;
2097  }
2098  }
2099 
2100  chapters = chapters_list->elem;
2101  for (i = 0; i < chapters_list->nb_elem; i++)
2102  if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid &&
2103  (max_start == 0 || chapters[i].start > max_start)) {
2104  chapters[i].chapter =
2105  avpriv_new_chapter(s, chapters[i].uid,
2106  (AVRational) { 1, 1000000000 },
2107  chapters[i].start, chapters[i].end,
2108  chapters[i].title);
2109  if (chapters[i].chapter) {
2110  av_dict_set(&chapters[i].chapter->metadata,
2111  "title", chapters[i].title, 0);
2112  }
2113  max_start = chapters[i].start;
2114  }
2115 
2116  matroska_add_index_entries(matroska);
2117 
2119 
2120  return 0;
2121 }
2122 
2123 /*
2124  * Put one packet in an application-supplied AVPacket struct.
2125  * Returns 0 on success or -1 on failure.
2126  */
2128  AVPacket *pkt)
2129 {
2130  if (matroska->num_packets > 0) {
2131  memcpy(pkt, matroska->packets[0], sizeof(AVPacket));
2132  av_free(matroska->packets[0]);
2133  if (matroska->num_packets > 1) {
2134  void *newpackets;
2135  memmove(&matroska->packets[0], &matroska->packets[1],
2136  (matroska->num_packets - 1) * sizeof(AVPacket *));
2137  newpackets = av_realloc(matroska->packets,
2138  (matroska->num_packets - 1) *
2139  sizeof(AVPacket *));
2140  if (newpackets)
2141  matroska->packets = newpackets;
2142  } else {
2143  av_freep(&matroska->packets);
2144  matroska->prev_pkt = NULL;
2145  }
2146  matroska->num_packets--;
2147  return 0;
2148  }
2149 
2150  return -1;
2151 }
2152 
2153 /*
2154  * Free all packets in our internal queue.
2155  */
2157 {
2158  matroska->prev_pkt = NULL;
2159  if (matroska->packets) {
2160  int n;
2161  for (n = 0; n < matroska->num_packets; n++) {
2162  av_free_packet(matroska->packets[n]);
2163  av_free(matroska->packets[n]);
2164  }
2165  av_freep(&matroska->packets);
2166  matroska->num_packets = 0;
2167  }
2168 }
2169 
2171  int *buf_size, int type,
2172  uint32_t **lace_buf, int *laces)
2173 {
2174  int res = 0, n, size = *buf_size;
2175  uint8_t *data = *buf;
2176  uint32_t *lace_size;
2177 
2178  if (!type) {
2179  *laces = 1;
2180  *lace_buf = av_mallocz(sizeof(int));
2181  if (!*lace_buf)
2182  return AVERROR(ENOMEM);
2183 
2184  *lace_buf[0] = size;
2185  return 0;
2186  }
2187 
2188  av_assert0(size > 0);
2189  *laces = *data + 1;
2190  data += 1;
2191  size -= 1;
2192  lace_size = av_mallocz(*laces * sizeof(int));
2193  if (!lace_size)
2194  return AVERROR(ENOMEM);
2195 
2196  switch (type) {
2197  case 0x1: /* Xiph lacing */
2198  {
2199  uint8_t temp;
2200  uint32_t total = 0;
2201  for (n = 0; res == 0 && n < *laces - 1; n++) {
2202  while (1) {
2203  if (size <= total) {
2204  res = AVERROR_INVALIDDATA;
2205  break;
2206  }
2207  temp = *data;
2208  total += temp;
2209  lace_size[n] += temp;
2210  data += 1;
2211  size -= 1;
2212  if (temp != 0xff)
2213  break;
2214  }
2215  }
2216  if (size <= total) {
2217  res = AVERROR_INVALIDDATA;
2218  break;
2219  }
2220 
2221  lace_size[n] = size - total;
2222  break;
2223  }
2224 
2225  case 0x2: /* fixed-size lacing */
2226  if (size % (*laces)) {
2227  res = AVERROR_INVALIDDATA;
2228  break;
2229  }
2230  for (n = 0; n < *laces; n++)
2231  lace_size[n] = size / *laces;
2232  break;
2233 
2234  case 0x3: /* EBML lacing */
2235  {
2236  uint64_t num;
2237  uint64_t total;
2238  n = matroska_ebmlnum_uint(matroska, data, size, &num);
2239  if (n < 0 || num > INT_MAX) {
2240  av_log(matroska->ctx, AV_LOG_INFO,
2241  "EBML block data error\n");
2242  res = n<0 ? n : AVERROR_INVALIDDATA;
2243  break;
2244  }
2245  data += n;
2246  size -= n;
2247  total = lace_size[0] = num;
2248  for (n = 1; res == 0 && n < *laces - 1; n++) {
2249  int64_t snum;
2250  int r;
2251  r = matroska_ebmlnum_sint(matroska, data, size, &snum);
2252  if (r < 0 || lace_size[n - 1] + snum > (uint64_t)INT_MAX) {
2253  av_log(matroska->ctx, AV_LOG_INFO,
2254  "EBML block data error\n");
2255  res = r<0 ? r : AVERROR_INVALIDDATA;
2256  break;
2257  }
2258  data += r;
2259  size -= r;
2260  lace_size[n] = lace_size[n - 1] + snum;
2261  total += lace_size[n];
2262  }
2263  if (size <= total) {
2264  res = AVERROR_INVALIDDATA;
2265  break;
2266  }
2267  lace_size[*laces - 1] = size - total;
2268  break;
2269  }
2270  }
2271 
2272  *buf = data;
2273  *lace_buf = lace_size;
2274  *buf_size = size;
2275 
2276  return res;
2277 }
2278 
2280  MatroskaTrack *track, AVStream *st,
2281  uint8_t *data, int size, uint64_t timecode,
2282  int64_t pos)
2283 {
2284  int a = st->codec->block_align;
2285  int sps = track->audio.sub_packet_size;
2286  int cfs = track->audio.coded_framesize;
2287  int h = track->audio.sub_packet_h;
2288  int y = track->audio.sub_packet_cnt;
2289  int w = track->audio.frame_size;
2290  int x;
2291 
2292  if (!track->audio.pkt_cnt) {
2293  if (track->audio.sub_packet_cnt == 0)
2294  track->audio.buf_timecode = timecode;
2295  if (st->codec->codec_id == AV_CODEC_ID_RA_288) {
2296  if (size < cfs * h / 2) {
2297  av_log(matroska->ctx, AV_LOG_ERROR,
2298  "Corrupt int4 RM-style audio packet size\n");
2299  return AVERROR_INVALIDDATA;
2300  }
2301  for (x = 0; x < h / 2; x++)
2302  memcpy(track->audio.buf + x * 2 * w + y * cfs,
2303  data + x * cfs, cfs);
2304  } else if (st->codec->codec_id == AV_CODEC_ID_SIPR) {
2305  if (size < w) {
2306  av_log(matroska->ctx, AV_LOG_ERROR,
2307  "Corrupt sipr RM-style audio packet size\n");
2308  return AVERROR_INVALIDDATA;
2309  }
2310  memcpy(track->audio.buf + y * w, data, w);
2311  } else {
2312  if (size < sps * w / sps || h<=0 || w%sps) {
2313  av_log(matroska->ctx, AV_LOG_ERROR,
2314  "Corrupt generic RM-style audio packet size\n");
2315  return AVERROR_INVALIDDATA;
2316  }
2317  for (x = 0; x < w / sps; x++)
2318  memcpy(track->audio.buf +
2319  sps * (h * x + ((h + 1) / 2) * (y & 1) + (y >> 1)),
2320  data + x * sps, sps);
2321  }
2322 
2323  if (++track->audio.sub_packet_cnt >= h) {
2324  if (st->codec->codec_id == AV_CODEC_ID_SIPR)
2325  ff_rm_reorder_sipr_data(track->audio.buf, h, w);
2326  track->audio.sub_packet_cnt = 0;
2327  track->audio.pkt_cnt = h * w / a;
2328  }
2329  }
2330 
2331  while (track->audio.pkt_cnt) {
2332  int ret;
2333  AVPacket *pkt = av_mallocz(sizeof(AVPacket));
2334  if (!pkt)
2335  return AVERROR(ENOMEM);
2336 
2337  ret = av_new_packet(pkt, a);
2338  if (ret < 0) {
2339  av_free(pkt);
2340  return ret;
2341  }
2342  memcpy(pkt->data,
2343  track->audio.buf + a * (h * w / a - track->audio.pkt_cnt--),
2344  a);
2345  pkt->pts = track->audio.buf_timecode;
2347  pkt->pos = pos;
2348  pkt->stream_index = st->index;
2349  dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
2350  }
2351 
2352  return 0;
2353 }
2354 
2355 /* reconstruct full wavpack blocks from mangled matroska ones */
2357  uint8_t **pdst, int *size)
2358 {
2359  uint8_t *dst = NULL;
2360  int dstlen = 0;
2361  int srclen = *size;
2362  uint32_t samples;
2363  uint16_t ver;
2364  int ret, offset = 0;
2365 
2366  if (srclen < 12 || track->stream->codec->extradata_size < 2)
2367  return AVERROR_INVALIDDATA;
2368 
2369  ver = AV_RL16(track->stream->codec->extradata);
2370 
2371  samples = AV_RL32(src);
2372  src += 4;
2373  srclen -= 4;
2374 
2375  while (srclen >= 8) {
2376  int multiblock;
2377  uint32_t blocksize;
2378  uint8_t *tmp;
2379 
2380  uint32_t flags = AV_RL32(src);
2381  uint32_t crc = AV_RL32(src + 4);
2382  src += 8;
2383  srclen -= 8;
2384 
2385  multiblock = (flags & 0x1800) != 0x1800;
2386  if (multiblock) {
2387  if (srclen < 4) {
2388  ret = AVERROR_INVALIDDATA;
2389  goto fail;
2390  }
2391  blocksize = AV_RL32(src);
2392  src += 4;
2393  srclen -= 4;
2394  } else
2395  blocksize = srclen;
2396 
2397  if (blocksize > srclen) {
2398  ret = AVERROR_INVALIDDATA;
2399  goto fail;
2400  }
2401 
2402  tmp = av_realloc(dst, dstlen + blocksize + 32);
2403  if (!tmp) {
2404  ret = AVERROR(ENOMEM);
2405  goto fail;
2406  }
2407  dst = tmp;
2408  dstlen += blocksize + 32;
2409 
2410  AV_WL32(dst + offset, MKTAG('w', 'v', 'p', 'k')); // tag
2411  AV_WL32(dst + offset + 4, blocksize + 24); // blocksize - 8
2412  AV_WL16(dst + offset + 8, ver); // version
2413  AV_WL16(dst + offset + 10, 0); // track/index_no
2414  AV_WL32(dst + offset + 12, 0); // total samples
2415  AV_WL32(dst + offset + 16, 0); // block index
2416  AV_WL32(dst + offset + 20, samples); // number of samples
2417  AV_WL32(dst + offset + 24, flags); // flags
2418  AV_WL32(dst + offset + 28, crc); // crc
2419  memcpy(dst + offset + 32, src, blocksize); // block data
2420 
2421  src += blocksize;
2422  srclen -= blocksize;
2423  offset += blocksize + 32;
2424  }
2425 
2426  *pdst = dst;
2427  *size = dstlen;
2428 
2429  return 0;
2430 
2431 fail:
2432  av_freep(&dst);
2433  return ret;
2434 }
2435 
2437  MatroskaTrack *track,
2438  AVStream *st,
2439  uint8_t *data, int data_len,
2440  uint64_t timecode,
2441  uint64_t duration,
2442  int64_t pos)
2443 {
2444  AVPacket *pkt;
2445  uint8_t *id, *settings, *text, *buf;
2446  int id_len, settings_len, text_len;
2447  uint8_t *p, *q;
2448  int err;
2449 
2450  if (data_len <= 0)
2451  return AVERROR_INVALIDDATA;
2452 
2453  p = data;
2454  q = data + data_len;
2455 
2456  id = p;
2457  id_len = -1;
2458  while (p < q) {
2459  if (*p == '\r' || *p == '\n') {
2460  id_len = p - id;
2461  if (*p == '\r')
2462  p++;
2463  break;
2464  }
2465  p++;
2466  }
2467 
2468  if (p >= q || *p != '\n')
2469  return AVERROR_INVALIDDATA;
2470  p++;
2471 
2472  settings = p;
2473  settings_len = -1;
2474  while (p < q) {
2475  if (*p == '\r' || *p == '\n') {
2476  settings_len = p - settings;
2477  if (*p == '\r')
2478  p++;
2479  break;
2480  }
2481  p++;
2482  }
2483 
2484  if (p >= q || *p != '\n')
2485  return AVERROR_INVALIDDATA;
2486  p++;
2487 
2488  text = p;
2489  text_len = q - p;
2490  while (text_len > 0) {
2491  const int len = text_len - 1;
2492  const uint8_t c = p[len];
2493  if (c != '\r' && c != '\n')
2494  break;
2495  text_len = len;
2496  }
2497 
2498  if (text_len <= 0)
2499  return AVERROR_INVALIDDATA;
2500 
2501  pkt = av_mallocz(sizeof(*pkt));
2502  err = av_new_packet(pkt, text_len);
2503  if (err < 0) {
2504  av_free(pkt);
2505  return AVERROR(err);
2506  }
2507 
2508  memcpy(pkt->data, text, text_len);
2509 
2510  if (id_len > 0) {
2511  buf = av_packet_new_side_data(pkt,
2513  id_len);
2514  if (!buf) {
2515  av_free(pkt);
2516  return AVERROR(ENOMEM);
2517  }
2518  memcpy(buf, id, id_len);
2519  }
2520 
2521  if (settings_len > 0) {
2522  buf = av_packet_new_side_data(pkt,
2524  settings_len);
2525  if (!buf) {
2526  av_free(pkt);
2527  return AVERROR(ENOMEM);
2528  }
2529  memcpy(buf, settings, settings_len);
2530  }
2531 
2532  // Do we need this for subtitles?
2533  // pkt->flags = AV_PKT_FLAG_KEY;
2534 
2535  pkt->stream_index = st->index;
2536  pkt->pts = timecode;
2537 
2538  // Do we need this for subtitles?
2539  // pkt->dts = timecode;
2540 
2541  pkt->duration = duration;
2542  pkt->pos = pos;
2543 
2544  dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
2545  matroska->prev_pkt = pkt;
2546 
2547  return 0;
2548 }
2549 
2551  MatroskaTrack *track, AVStream *st,
2552  uint8_t *data, int pkt_size,
2553  uint64_t timecode, uint64_t lace_duration,
2554  int64_t pos, int is_keyframe,
2555  uint8_t *additional, uint64_t additional_id, int additional_size,
2556  int64_t discard_padding)
2557 {
2558  MatroskaTrackEncoding *encodings = track->encodings.elem;
2559  uint8_t *pkt_data = data;
2560  int offset = 0, res;
2561  AVPacket *pkt;
2562 
2563  if (encodings && !encodings->type && encodings->scope & 1) {
2564  res = matroska_decode_buffer(&pkt_data, &pkt_size, track);
2565  if (res < 0)
2566  return res;
2567  }
2568 
2569  if (st->codec->codec_id == AV_CODEC_ID_WAVPACK) {
2570  uint8_t *wv_data;
2571  res = matroska_parse_wavpack(track, pkt_data, &wv_data, &pkt_size);
2572  if (res < 0) {
2573  av_log(matroska->ctx, AV_LOG_ERROR,
2574  "Error parsing a wavpack block.\n");
2575  goto fail;
2576  }
2577  if (pkt_data != data)
2578  av_freep(&pkt_data);
2579  pkt_data = wv_data;
2580  }
2581 
2582  if (st->codec->codec_id == AV_CODEC_ID_PRORES &&
2583  AV_RB32(&data[4]) != MKBETAG('i', 'c', 'p', 'f'))
2584  offset = 8;
2585 
2586  pkt = av_mallocz(sizeof(AVPacket));
2587  /* XXX: prevent data copy... */
2588  if (av_new_packet(pkt, pkt_size + offset) < 0) {
2589  av_free(pkt);
2590  res = AVERROR(ENOMEM);
2591  goto fail;
2592  }
2593 
2594  if (st->codec->codec_id == AV_CODEC_ID_PRORES && offset == 8) {
2595  uint8_t *buf = pkt->data;
2596  bytestream_put_be32(&buf, pkt_size);
2597  bytestream_put_be32(&buf, MKBETAG('i', 'c', 'p', 'f'));
2598  }
2599 
2600  memcpy(pkt->data + offset, pkt_data, pkt_size);
2601 
2602  if (pkt_data != data)
2603  av_freep(&pkt_data);
2604 
2605  pkt->flags = is_keyframe;
2606  pkt->stream_index = st->index;
2607 
2608  if (additional_size > 0) {
2609  uint8_t *side_data = av_packet_new_side_data(pkt,
2611  additional_size + 8);
2612  if (!side_data) {
2613  av_free_packet(pkt);
2614  av_free(pkt);
2615  return AVERROR(ENOMEM);
2616  }
2617  AV_WB64(side_data, additional_id);
2618  memcpy(side_data + 8, additional, additional_size);
2619  }
2620 
2621  if (discard_padding) {
2622  uint8_t *side_data = av_packet_new_side_data(pkt,
2624  10);
2625  if (!side_data) {
2626  av_free_packet(pkt);
2627  av_free(pkt);
2628  return AVERROR(ENOMEM);
2629  }
2630  AV_WL32(side_data, 0);
2631  AV_WL32(side_data + 4, av_rescale_q(discard_padding,
2632  (AVRational){1, 1000000000},
2633  (AVRational){1, st->codec->sample_rate}));
2634  }
2635 
2636  if (track->ms_compat)
2637  pkt->dts = timecode;
2638  else
2639  pkt->pts = timecode;
2640  pkt->pos = pos;
2641  if (st->codec->codec_id == AV_CODEC_ID_SUBRIP) {
2642  /*
2643  * For backward compatibility.
2644  * Historically, we have put subtitle duration
2645  * in convergence_duration, on the off chance
2646  * that the time_scale is less than 1us, which
2647  * could result in a 32bit overflow on the
2648  * normal duration field.
2649  */
2650  pkt->convergence_duration = lace_duration;
2651  }
2652 
2653  if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE ||
2654  lace_duration <= INT_MAX) {
2655  /*
2656  * For non subtitle tracks, just store the duration
2657  * as normal.
2658  *
2659  * If it's a subtitle track and duration value does
2660  * not overflow a uint32, then also store it normally.
2661  */
2662  pkt->duration = lace_duration;
2663  }
2664 
2665  dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
2666  matroska->prev_pkt = pkt;
2667 
2668  return 0;
2669 
2670 fail:
2671  if (pkt_data != data)
2672  av_freep(&pkt_data);
2673  return res;
2674 }
2675 
2677  int size, int64_t pos, uint64_t cluster_time,
2678  uint64_t block_duration, int is_keyframe,
2679  uint8_t *additional, uint64_t additional_id, int additional_size,
2680  int64_t cluster_pos, int64_t discard_padding)
2681 {
2682  uint64_t timecode = AV_NOPTS_VALUE;
2683  MatroskaTrack *track;
2684  int res = 0;
2685  AVStream *st;
2686  int16_t block_time;
2687  uint32_t *lace_size = NULL;
2688  int n, flags, laces = 0;
2689  uint64_t num;
2690  int trust_default_duration = 1;
2691 
2692  if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
2693  av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
2694  return n;
2695  }
2696  data += n;
2697  size -= n;
2698 
2699  track = matroska_find_track_by_num(matroska, num);
2700  if (!track || !track->stream) {
2701  av_log(matroska->ctx, AV_LOG_INFO,
2702  "Invalid stream %"PRIu64" or size %u\n", num, size);
2703  return AVERROR_INVALIDDATA;
2704  } else if (size <= 3)
2705  return 0;
2706  st = track->stream;
2707  if (st->discard >= AVDISCARD_ALL)
2708  return res;
2709  av_assert1(block_duration != AV_NOPTS_VALUE);
2710 
2711  block_time = sign_extend(AV_RB16(data), 16);
2712  data += 2;
2713  flags = *data++;
2714  size -= 3;
2715  if (is_keyframe == -1)
2716  is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
2717 
2718  if (cluster_time != (uint64_t) -1 &&
2719  (block_time >= 0 || cluster_time >= -block_time)) {
2720  timecode = cluster_time + block_time - track->codec_delay;
2721  if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
2722  timecode < track->end_timecode)
2723  is_keyframe = 0; /* overlapping subtitles are not key frame */
2724  if (is_keyframe)
2725  av_add_index_entry(st, cluster_pos, timecode, 0, 0,
2727  }
2728 
2729  if (matroska->skip_to_keyframe &&
2730  track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
2731  if (timecode < matroska->skip_to_timecode)
2732  return res;
2733  if (is_keyframe)
2734  matroska->skip_to_keyframe = 0;
2735  else if (!st->skip_to_keyframe) {
2736  av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
2737  matroska->skip_to_keyframe = 0;
2738  }
2739  }
2740 
2741  res = matroska_parse_laces(matroska, &data, &size, (flags & 0x06) >> 1,
2742  &lace_size, &laces);
2743 
2744  if (res)
2745  goto end;
2746 
2747  if (track->audio.samplerate == 8000) {
2748  // If this is needed for more codecs, then add them here
2749  if (st->codec->codec_id == AV_CODEC_ID_AC3) {
2750  if (track->audio.samplerate != st->codec->sample_rate || !st->codec->frame_size)
2751  trust_default_duration = 0;
2752  }
2753  }
2754 
2755  if (!block_duration && trust_default_duration)
2756  block_duration = track->default_duration * laces / matroska->time_scale;
2757 
2758  if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
2759  track->end_timecode =
2760  FFMAX(track->end_timecode, timecode + block_duration);
2761 
2762  for (n = 0; n < laces; n++) {
2763  int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
2764 
2765  if (lace_size[n] > size) {
2766  av_log(matroska->ctx, AV_LOG_ERROR, "Invalid packet size\n");
2767  break;
2768  }
2769 
2770  if ((st->codec->codec_id == AV_CODEC_ID_RA_288 ||
2771  st->codec->codec_id == AV_CODEC_ID_COOK ||
2772  st->codec->codec_id == AV_CODEC_ID_SIPR ||
2773  st->codec->codec_id == AV_CODEC_ID_ATRAC3) &&
2774  st->codec->block_align && track->audio.sub_packet_size) {
2775  res = matroska_parse_rm_audio(matroska, track, st, data,
2776  lace_size[n],
2777  timecode, pos);
2778  if (res)
2779  goto end;
2780 
2781  } else if (st->codec->codec_id == AV_CODEC_ID_WEBVTT) {
2782  res = matroska_parse_webvtt(matroska, track, st,
2783  data, lace_size[n],
2784  timecode, lace_duration,
2785  pos);
2786  if (res)
2787  goto end;
2788  } else {
2789  res = matroska_parse_frame(matroska, track, st, data, lace_size[n],
2790  timecode, lace_duration, pos,
2791  !n ? is_keyframe : 0,
2792  additional, additional_id, additional_size,
2793  discard_padding);
2794  if (res)
2795  goto end;
2796  }
2797 
2798  if (timecode != AV_NOPTS_VALUE)
2799  timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
2800  data += lace_size[n];
2801  size -= lace_size[n];
2802  }
2803 
2804 end:
2805  av_free(lace_size);
2806  return res;
2807 }
2808 
2810 {
2811  EbmlList *blocks_list;
2812  MatroskaBlock *blocks;
2813  int i, res;
2814  res = ebml_parse(matroska,
2815  matroska_cluster_incremental_parsing,
2816  &matroska->current_cluster);
2817  if (res == 1) {
2818  /* New Cluster */
2819  if (matroska->current_cluster_pos)
2820  ebml_level_end(matroska);
2821  ebml_free(matroska_cluster, &matroska->current_cluster);
2822  memset(&matroska->current_cluster, 0, sizeof(MatroskaCluster));
2823  matroska->current_cluster_num_blocks = 0;
2824  matroska->current_cluster_pos = avio_tell(matroska->ctx->pb);
2825  matroska->prev_pkt = NULL;
2826  /* sizeof the ID which was already read */
2827  if (matroska->current_id)
2828  matroska->current_cluster_pos -= 4;
2829  res = ebml_parse(matroska,
2830  matroska_clusters_incremental,
2831  &matroska->current_cluster);
2832  /* Try parsing the block again. */
2833  if (res == 1)
2834  res = ebml_parse(matroska,
2835  matroska_cluster_incremental_parsing,
2836  &matroska->current_cluster);
2837  }
2838 
2839  if (!res &&
2840  matroska->current_cluster_num_blocks <
2841  matroska->current_cluster.blocks.nb_elem) {
2842  blocks_list = &matroska->current_cluster.blocks;
2843  blocks = blocks_list->elem;
2844 
2845  matroska->current_cluster_num_blocks = blocks_list->nb_elem;
2846  i = blocks_list->nb_elem - 1;
2847  if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
2848  int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
2849  uint8_t* additional = blocks[i].additional.size > 0 ?
2850  blocks[i].additional.data : NULL;
2851  if (!blocks[i].non_simple)
2852  blocks[i].duration = 0;
2853  res = matroska_parse_block(matroska, blocks[i].bin.data,
2854  blocks[i].bin.size, blocks[i].bin.pos,
2855  matroska->current_cluster.timecode,
2856  blocks[i].duration, is_keyframe,
2857  additional, blocks[i].additional_id,
2858  blocks[i].additional.size,
2859  matroska->current_cluster_pos,
2860  blocks[i].discard_padding);
2861  }
2862  }
2863 
2864  return res;
2865 }
2866 
2868 {
2869  MatroskaCluster cluster = { 0 };
2870  EbmlList *blocks_list;
2871  MatroskaBlock *blocks;
2872  int i, res;
2873  int64_t pos;
2874 
2875  if (!matroska->contains_ssa)
2876  return matroska_parse_cluster_incremental(matroska);
2877  pos = avio_tell(matroska->ctx->pb);
2878  matroska->prev_pkt = NULL;
2879  if (matroska->current_id)
2880  pos -= 4; /* sizeof the ID which was already read */
2881  res = ebml_parse(matroska, matroska_clusters, &cluster);
2882  blocks_list = &cluster.blocks;
2883  blocks = blocks_list->elem;
2884  for (i = 0; i < blocks_list->nb_elem; i++)
2885  if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
2886  int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
2887  res = matroska_parse_block(matroska, blocks[i].bin.data,
2888  blocks[i].bin.size, blocks[i].bin.pos,
2889  cluster.timecode, blocks[i].duration,
2890  is_keyframe, NULL, 0, 0, pos,
2891  blocks[i].discard_padding);
2892  }
2893  ebml_free(matroska_cluster, &cluster);
2894  return res;
2895 }
2896 
2898 {
2899  MatroskaDemuxContext *matroska = s->priv_data;
2900 
2901  while (matroska_deliver_packet(matroska, pkt)) {
2902  int64_t pos = avio_tell(matroska->ctx->pb);
2903  if (matroska->done)
2904  return AVERROR_EOF;
2905  if (matroska_parse_cluster(matroska) < 0)
2906  matroska_resync(matroska, pos);
2907  }
2908 
2909  return 0;
2910 }
2911 
2912 static int matroska_read_seek(AVFormatContext *s, int stream_index,
2913  int64_t timestamp, int flags)
2914 {
2915  MatroskaDemuxContext *matroska = s->priv_data;
2916  MatroskaTrack *tracks = NULL;
2917  AVStream *st = s->streams[stream_index];
2918  int i, index, index_sub, index_min;
2919 
2920  /* Parse the CUES now since we need the index data to seek. */
2921  if (matroska->cues_parsing_deferred > 0) {
2922  matroska->cues_parsing_deferred = 0;
2923  matroska_parse_cues(matroska);
2924  }
2925 
2926  if (!st->nb_index_entries)
2927  goto err;
2928  timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
2929 
2930  if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 || index == st->nb_index_entries - 1) {
2931  avio_seek(s->pb, st->index_entries[st->nb_index_entries - 1].pos,
2932  SEEK_SET);
2933  matroska->current_id = 0;
2934  while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 || index == st->nb_index_entries - 1) {
2935  matroska_clear_queue(matroska);
2936  if (matroska_parse_cluster(matroska) < 0)
2937  break;
2938  }
2939  }
2940 
2941  matroska_clear_queue(matroska);
2942  if (index < 0 || (matroska->cues_parsing_deferred < 0 && index == st->nb_index_entries - 1))
2943  goto err;
2944 
2945  index_min = index;
2946  tracks = matroska->tracks.elem;
2947  for (i = 0; i < matroska->tracks.nb_elem; i++) {
2948  tracks[i].audio.pkt_cnt = 0;
2949  tracks[i].audio.sub_packet_cnt = 0;
2950  tracks[i].audio.buf_timecode = AV_NOPTS_VALUE;
2951  tracks[i].end_timecode = 0;
2952  if (tracks[i].type == MATROSKA_TRACK_TYPE_SUBTITLE &&
2953  tracks[i].stream->discard != AVDISCARD_ALL) {
2954  index_sub = av_index_search_timestamp(
2955  tracks[i].stream, st->index_entries[index].timestamp,
2957  while (index_sub >= 0 &&
2958  index_min > 0 &&
2959  tracks[i].stream->index_entries[index_sub].pos < st->index_entries[index_min].pos &&
2960  st->index_entries[index].timestamp - tracks[i].stream->index_entries[index_sub].timestamp < 30000000000 / matroska->time_scale)
2961  index_min--;
2962  }
2963  }
2964 
2965  avio_seek(s->pb, st->index_entries[index_min].pos, SEEK_SET);
2966  matroska->current_id = 0;
2967  if (flags & AVSEEK_FLAG_ANY) {
2968  st->skip_to_keyframe = 0;
2969  matroska->skip_to_timecode = timestamp;
2970  } else {
2971  st->skip_to_keyframe = 1;
2972  matroska->skip_to_timecode = st->index_entries[index].timestamp;
2973  }
2974  matroska->skip_to_keyframe = 1;
2975  matroska->done = 0;
2976  matroska->num_levels = 0;
2977  ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
2978  return 0;
2979 err:
2980  // slightly hackish but allows proper fallback to
2981  // the generic seeking code.
2982  matroska_clear_queue(matroska);
2983  matroska->current_id = 0;
2984  st->skip_to_keyframe =
2985  matroska->skip_to_keyframe = 0;
2986  matroska->done = 0;
2987  matroska->num_levels = 0;
2988  return -1;
2989 }
2990 
2992 {
2993  MatroskaDemuxContext *matroska = s->priv_data;
2994  MatroskaTrack *tracks = matroska->tracks.elem;
2995  int n;
2996 
2997  matroska_clear_queue(matroska);
2998 
2999  for (n = 0; n < matroska->tracks.nb_elem; n++)
3000  if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
3001  av_free(tracks[n].audio.buf);
3002  ebml_free(matroska_cluster, &matroska->current_cluster);
3003  ebml_free(matroska_segment, matroska);
3004 
3005  return 0;
3006 }
3007 
3008 typedef struct {
3009  int64_t start_time_ns;
3010  int64_t end_time_ns;
3011  int64_t start_offset;
3012  int64_t end_offset;
3013 } CueDesc;
3014 
3015 /* This function searches all the Cues and returns the CueDesc corresponding the
3016  * the timestamp ts. Returned CueDesc will be such that start_time_ns <= ts <
3017  * end_time_ns. All 4 fields will be set to -1 if ts >= file's duration.
3018  */
3019 static CueDesc get_cue_desc(AVFormatContext *s, int64_t ts, int64_t cues_start) {
3020  MatroskaDemuxContext *matroska = s->priv_data;
3021  CueDesc cue_desc;
3022  int i;
3023  int nb_index_entries = s->streams[0]->nb_index_entries;
3024  AVIndexEntry *index_entries = s->streams[0]->index_entries;
3025  if (ts >= matroska->duration * matroska->time_scale) return (CueDesc) {-1, -1, -1, -1};
3026  for (i = 1; i < nb_index_entries; i++) {
3027  if (index_entries[i - 1].timestamp * matroska->time_scale <= ts &&
3028  index_entries[i].timestamp * matroska->time_scale > ts) {
3029  break;
3030  }
3031  }
3032  --i;
3033  cue_desc.start_time_ns = index_entries[i].timestamp * matroska->time_scale;
3034  cue_desc.start_offset = index_entries[i].pos - matroska->segment_start;
3035  if (i != nb_index_entries - 1) {
3036  cue_desc.end_time_ns = index_entries[i + 1].timestamp * matroska->time_scale;
3037  cue_desc.end_offset = index_entries[i + 1].pos - matroska->segment_start;
3038  } else {
3039  cue_desc.end_time_ns = matroska->duration * matroska->time_scale;
3040  // FIXME: this needs special handling for files where Cues appear
3041  // before Clusters. the current logic assumes Cues appear after
3042  // Clusters.
3043  cue_desc.end_offset = cues_start - matroska->segment_start;
3044  }
3045  return cue_desc;
3046 }
3047 
3049 {
3050  MatroskaDemuxContext *matroska = s->priv_data;
3051  int64_t cluster_pos, before_pos;
3052  int index, rv = 1;
3053  if (s->streams[0]->nb_index_entries <= 0) return 0;
3054  // seek to the first cluster using cues.
3055  index = av_index_search_timestamp(s->streams[0], 0, 0);
3056  if (index < 0) return 0;
3057  cluster_pos = s->streams[0]->index_entries[index].pos;
3058  before_pos = avio_tell(s->pb);
3059  while (1) {
3060  int64_t cluster_id = 0, cluster_length = 0;
3061  AVPacket *pkt;
3062  avio_seek(s->pb, cluster_pos, SEEK_SET);
3063  // read cluster id and length
3064  ebml_read_num(matroska, matroska->ctx->pb, 4, &cluster_id);
3065  ebml_read_length(matroska, matroska->ctx->pb, &cluster_length);
3066  if (cluster_id != 0xF43B675) { // done with all clusters
3067  break;
3068  }
3069  avio_seek(s->pb, cluster_pos, SEEK_SET);
3070  matroska->current_id = 0;
3071  matroska_clear_queue(matroska);
3072  if (matroska_parse_cluster(matroska) < 0 ||
3073  matroska->num_packets <= 0) {
3074  break;
3075  }
3076  pkt = matroska->packets[0];
3077  cluster_pos += cluster_length + 12; // 12 is the offset of the cluster id and length.
3078  if (!(pkt->flags & AV_PKT_FLAG_KEY)) {
3079  rv = 0;
3080  break;
3081  }
3082  }
3083  avio_seek(s->pb, before_pos, SEEK_SET);
3084  return rv;
3085 }
3086 
3087 static int buffer_size_after_time_downloaded(int64_t time_ns, double search_sec, int64_t bps,
3088  double min_buffer, double* buffer,
3089  double* sec_to_download, AVFormatContext *s,
3090  int64_t cues_start)
3091 {
3092  double nano_seconds_per_second = 1000000000.0;
3093  double time_sec = time_ns / nano_seconds_per_second;
3094  int rv = 0;
3095  int64_t time_to_search_ns = (int64_t)(search_sec * nano_seconds_per_second);
3096  int64_t end_time_ns = time_ns + time_to_search_ns;
3097  double sec_downloaded = 0.0;
3098  CueDesc desc_curr = get_cue_desc(s, time_ns, cues_start);
3099  if (desc_curr.start_time_ns == -1)
3100  return -1;
3101  *sec_to_download = 0.0;
3102 
3103  // Check for non cue start time.
3104  if (time_ns > desc_curr.start_time_ns) {
3105  int64_t cue_nano = desc_curr.end_time_ns - time_ns;
3106  double percent = (double)(cue_nano) / (desc_curr.end_time_ns - desc_curr.start_time_ns);
3107  double cueBytes = (desc_curr.end_offset - desc_curr.start_offset) * percent;
3108  double timeToDownload = (cueBytes * 8.0) / bps;
3109 
3110  sec_downloaded += (cue_nano / nano_seconds_per_second) - timeToDownload;
3111  *sec_to_download += timeToDownload;
3112 
3113  // Check if the search ends within the first cue.
3114  if (desc_curr.end_time_ns >= end_time_ns) {
3115  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
3116  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
3117  sec_downloaded = percent_to_sub * sec_downloaded;
3118  *sec_to_download = percent_to_sub * *sec_to_download;
3119  }
3120 
3121  if ((sec_downloaded + *buffer) <= min_buffer) {
3122  return 1;
3123  }
3124 
3125  // Get the next Cue.
3126  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
3127  }
3128 
3129  while (desc_curr.start_time_ns != -1) {
3130  int64_t desc_bytes = desc_curr.end_offset - desc_curr.start_offset;
3131  int64_t desc_ns = desc_curr.end_time_ns - desc_curr.start_time_ns;
3132  double desc_sec = desc_ns / nano_seconds_per_second;
3133  double bits = (desc_bytes * 8.0);
3134  double time_to_download = bits / bps;
3135 
3136  sec_downloaded += desc_sec - time_to_download;
3137  *sec_to_download += time_to_download;
3138 
3139  if (desc_curr.end_time_ns >= end_time_ns) {
3140  double desc_end_time_sec = desc_curr.end_time_ns / nano_seconds_per_second;
3141  double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
3142  sec_downloaded = percent_to_sub * sec_downloaded;
3143  *sec_to_download = percent_to_sub * *sec_to_download;
3144 
3145  if ((sec_downloaded + *buffer) <= min_buffer)
3146  rv = 1;
3147  break;
3148  }
3149 
3150  if ((sec_downloaded + *buffer) <= min_buffer) {
3151  rv = 1;
3152  break;
3153  }
3154 
3155  desc_curr = get_cue_desc(s, desc_curr.end_time_ns, cues_start);
3156  }
3157  *buffer = *buffer + sec_downloaded;
3158  return rv;
3159 }
3160 
3161 /* This function computes the bandwidth of the WebM file with the help of
3162  * buffer_size_after_time_downloaded() function. Both of these functions are
3163  * adapted from WebM Tools project and are adapted to work with FFmpeg's
3164  * Matroska parsing mechanism.
3165  *
3166  * Returns the bandwidth of the file on success; -1 on error.
3167  * */
3168 static int64_t webm_dash_manifest_compute_bandwidth(AVFormatContext *s, int64_t cues_start)
3169 {
3170  MatroskaDemuxContext *matroska = s->priv_data;
3171  AVStream *st = s->streams[0];
3172  double bandwidth = 0.0;
3173  int i;
3174 
3175  for (i = 0; i < st->nb_index_entries; i++) {
3176  int64_t prebuffer_ns = 1000000000;
3177  int64_t time_ns = st->index_entries[i].timestamp * matroska->time_scale;
3178  double nano_seconds_per_second = 1000000000.0;
3179  int64_t prebuffered_ns = time_ns + prebuffer_ns;
3180  double prebuffer_bytes = 0.0;
3181  int64_t temp_prebuffer_ns = prebuffer_ns;
3182  int64_t pre_bytes, pre_ns;
3183  double pre_sec, prebuffer, bits_per_second;
3184  CueDesc desc_beg = get_cue_desc(s, time_ns, cues_start);
3185 
3186  // Start with the first Cue.
3187  CueDesc desc_end = desc_beg;
3188 
3189  // Figure out how much data we have downloaded for the prebuffer. This will
3190  // be used later to adjust the bits per sample to try.
3191  while (desc_end.start_time_ns != -1 && desc_end.end_time_ns < prebuffered_ns) {
3192  // Prebuffered the entire Cue.
3193  prebuffer_bytes += desc_end.end_offset - desc_end.start_offset;
3194  temp_prebuffer_ns -= desc_end.end_time_ns - desc_end.start_time_ns;
3195  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
3196  }
3197  if (desc_end.start_time_ns == -1) {
3198  // The prebuffer is larger than the duration.
3199  if (matroska->duration * matroska->time_scale >= prebuffered_ns)
3200  return -1;
3201  bits_per_second = 0.0;
3202  } else {
3203  // The prebuffer ends in the last Cue. Estimate how much data was
3204  // prebuffered.
3205  pre_bytes = desc_end.end_offset - desc_end.start_offset;
3206  pre_ns = desc_end.end_time_ns - desc_end.start_time_ns;
3207  pre_sec = pre_ns / nano_seconds_per_second;
3208  prebuffer_bytes +=
3209  pre_bytes * ((temp_prebuffer_ns / nano_seconds_per_second) / pre_sec);
3210 
3211  prebuffer = prebuffer_ns / nano_seconds_per_second;
3212 
3213  // Set this to 0.0 in case our prebuffer buffers the entire video.
3214  bits_per_second = 0.0;
3215  do {
3216  int64_t desc_bytes = desc_end.end_offset - desc_beg.start_offset;
3217  int64_t desc_ns = desc_end.end_time_ns - desc_beg.start_time_ns;
3218  double desc_sec = desc_ns / nano_seconds_per_second;
3219  double calc_bits_per_second = (desc_bytes * 8) / desc_sec;
3220 
3221  // Drop the bps by the percentage of bytes buffered.
3222  double percent = (desc_bytes - prebuffer_bytes) / desc_bytes;
3223  double mod_bits_per_second = calc_bits_per_second * percent;
3224 
3225  if (prebuffer < desc_sec) {
3226  double search_sec =
3227  (double)(matroska->duration * matroska->time_scale) / nano_seconds_per_second;
3228 
3229  // Add 1 so the bits per second should be a little bit greater than file
3230  // datarate.
3231  int64_t bps = (int64_t)(mod_bits_per_second) + 1;
3232  const double min_buffer = 0.0;
3233  double buffer = prebuffer;
3234  double sec_to_download = 0.0;
3235 
3236  int rv = buffer_size_after_time_downloaded(prebuffered_ns, search_sec, bps,
3237  min_buffer, &buffer, &sec_to_download,
3238  s, cues_start);
3239  if (rv < 0) {
3240  return -1;
3241  } else if (rv == 0) {
3242  bits_per_second = (double)(bps);
3243  break;
3244  }
3245  }
3246 
3247  desc_end = get_cue_desc(s, desc_end.end_time_ns, cues_start);
3248  } while (desc_end.start_time_ns != -1);
3249  }
3250  if (bandwidth < bits_per_second) bandwidth = bits_per_second;
3251  }
3252  return (int64_t)bandwidth;
3253 }
3254 
3256 {
3257  MatroskaDemuxContext *matroska = s->priv_data;
3258  EbmlList *seekhead_list = &matroska->seekhead;
3259  MatroskaSeekhead *seekhead = seekhead_list->elem;
3260  char *buf;
3261  int64_t cues_start = -1, cues_end = -1, before_pos, bandwidth;
3262  int i;
3263 
3264  // determine cues start and end positions
3265  for (i = 0; i < seekhead_list->nb_elem; i++)
3266  if (seekhead[i].id == MATROSKA_ID_CUES)
3267  break;
3268 
3269  if (i >= seekhead_list->nb_elem) return -1;
3270 
3271  before_pos = avio_tell(matroska->ctx->pb);
3272  cues_start = seekhead[i].pos + matroska->segment_start;
3273  if (avio_seek(matroska->ctx->pb, cues_start, SEEK_SET) == cues_start) {
3274  // cues_end is computed as cues_start + cues_length + length of the
3275  // Cues element ID + EBML length of the Cues element. cues_end is
3276  // inclusive and the above sum is reduced by 1.
3277  uint64_t cues_length = 0, cues_id = 0, bytes_read = 0;
3278  bytes_read += ebml_read_num(matroska, matroska->ctx->pb, 4, &cues_id);
3279  bytes_read += ebml_read_length(matroska, matroska->ctx->pb, &cues_length);
3280  cues_end = cues_start + cues_length + bytes_read - 1;
3281  }
3282  avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
3283  if (cues_start == -1 || cues_end == -1) return -1;
3284 
3285  // parse the cues
3286  matroska_parse_cues(matroska);
3287 
3288  // cues start
3289  av_dict_set_int(&s->streams[0]->metadata, CUES_START, cues_start, 0);
3290 
3291  // cues end
3292  av_dict_set_int(&s->streams[0]->metadata, CUES_END, cues_end, 0);
3293 
3294  // bandwidth
3295  bandwidth = webm_dash_manifest_compute_bandwidth(s, cues_start);
3296  if (bandwidth < 0) return -1;
3297  av_dict_set_int(&s->streams[0]->metadata, BANDWIDTH, bandwidth, 0);
3298 
3299  // check if all clusters start with key frames
3301 
3302  // store cue point timestamps as a comma separated list for checking subsegment alignment in
3303  // the muxer. assumes that each timestamp cannot be more than 20 characters long.
3304  buf = av_malloc(s->streams[0]->nb_index_entries * 20 * sizeof(char));
3305  if (!buf) return -1;
3306  strcpy(buf, "");
3307  for (i = 0; i < s->streams[0]->nb_index_entries; i++) {
3308  snprintf(buf, (i + 1) * 20 * sizeof(char),
3309  "%s%" PRId64, buf, s->streams[0]->index_entries[i].timestamp);
3310  if (i != s->streams[0]->nb_index_entries - 1)
3311  strncat(buf, ",", sizeof(char));
3312  }
3313  av_dict_set(&s->streams[0]->metadata, CUE_TIMESTAMPS, buf, 0);
3314  av_free(buf);
3315 
3316  return 0;
3317 }
3318 
3320 {
3321  char *buf;
3322  int ret = matroska_read_header(s);
3323  MatroskaTrack *tracks;
3324  MatroskaDemuxContext *matroska = s->priv_data;
3325  if (ret) {
3326  av_log(s, AV_LOG_ERROR, "Failed to read file headers\n");
3327  return -1;
3328  }
3329 
3330  // initialization range
3331  // 5 is the offset of Cluster ID.
3333 
3334  // basename of the file
3335  buf = strrchr(s->filename, '/');
3336  av_dict_set(&s->streams[0]->metadata, FILENAME, buf ? ++buf : s->filename, 0);
3337 
3338  // duration
3339  buf = av_asprintf("%g", matroska->duration);
3340  if (!buf) return AVERROR(ENOMEM);
3341  av_dict_set(&s->streams[0]->metadata, DURATION, buf, 0);
3342  av_free(buf);
3343 
3344  // track number
3345  tracks = matroska->tracks.elem;
3346  av_dict_set_int(&s->streams[0]->metadata, TRACK_NUMBER, tracks[0].num, 0);
3347 
3348  // parse the cues and populate Cue related fields
3349  return webm_dash_manifest_cues(s);
3350 }
3351 
3353 {
3354  return AVERROR_EOF;
3355 }
3356 
3358  .name = "matroska,webm",
3359  .long_name = NULL_IF_CONFIG_SMALL("Matroska / WebM"),
3360  .extensions = "mkv,mk3d,mka,mks",
3361  .priv_data_size = sizeof(MatroskaDemuxContext),
3367  .mime_type = "audio/webm,audio/x-matroska,video/webm,video/x-matroska"
3368 };
3369 
3371  .name = "webm_dash_manifest",
3372  .long_name = NULL_IF_CONFIG_SMALL("WebM DASH Manifest"),
3373  .priv_data_size = sizeof(MatroskaDemuxContext),
3377 };