FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
matroskaenc.c
Go to the documentation of this file.
1 /*
2  * Matroska muxer
3  * Copyright (c) 2007 David Conrad
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 #include <stdint.h>
23 
24 #include "avc.h"
25 #include "hevc.h"
26 #include "avformat.h"
27 #include "avio_internal.h"
28 #include "avlanguage.h"
29 #include "flacenc.h"
30 #include "internal.h"
31 #include "isom.h"
32 #include "matroska.h"
33 #include "riff.h"
34 #include "subtitles.h"
35 #include "vorbiscomment.h"
36 #include "wv.h"
37 
38 #include "libavutil/avstring.h"
40 #include "libavutil/dict.h"
41 #include "libavutil/intfloat.h"
42 #include "libavutil/intreadwrite.h"
43 #include "libavutil/lfg.h"
44 #include "libavutil/mathematics.h"
45 #include "libavutil/opt.h"
46 #include "libavutil/random_seed.h"
47 #include "libavutil/samplefmt.h"
48 #include "libavutil/sha.h"
49 #include "libavutil/stereo3d.h"
50 
51 #include "libavcodec/xiph.h"
52 #include "libavcodec/mpeg4audio.h"
53 #include "libavcodec/internal.h"
54 
55 typedef struct ebml_master {
56  int64_t pos; ///< absolute offset in the file where the master's elements start
57  int sizebytes; ///< how many bytes were reserved for the size
58 } ebml_master;
59 
60 typedef struct mkv_seekhead_entry {
61  unsigned int elementid;
62  uint64_t segmentpos;
64 
65 typedef struct mkv_seekhead {
66  int64_t filepos;
67  int64_t segment_offset; ///< the file offset to the beginning of the segment
68  int reserved_size; ///< -1 if appending to file
72 } mkv_seekhead;
73 
74 typedef struct mkv_cuepoint {
75  uint64_t pts;
77  int tracknum;
78  int64_t cluster_pos; ///< file offset of the cluster containing the block
79  int64_t relative_pos; ///< relative offset from the position of the cluster containing the block
80  int64_t duration; ///< duration of the block according to time base
81 } mkv_cuepoint;
82 
83 typedef struct mkv_cues {
84  int64_t segment_offset;
87 } mkv_cues;
88 
89 typedef struct mkv_track {
90  int write_dts;
91  int has_cue;
92  int64_t ts_offset;
93 } mkv_track;
94 
95 #define MODE_MATROSKAv2 0x01
96 #define MODE_WEBM 0x02
97 
98 /** Maximum number of tracks allowed in a Matroska file (with track numbers in
99  * range 1 to 126 (inclusive) */
100 #define MAX_TRACKS 126
101 
102 typedef struct MatroskaMuxContext {
103  const AVClass *class;
104  int mode;
107  int64_t segment_offset;
109  int64_t cluster_pos; ///< file offset of the current cluster
110  int64_t cluster_pts;
112  int64_t duration;
116 
118 
120 
123  int64_t cues_pos;
125  int is_dash;
127  int is_live;
128 
131 
133 
136 
137 
138 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
139  * offset, 4 bytes for target EBML ID */
140 #define MAX_SEEKENTRY_SIZE 21
141 
142 /** per-cuepoint-track - 5 1-byte EBML IDs, 5 1-byte EBML sizes, 4
143  * 8-byte uint max */
144 #define MAX_CUETRACKPOS_SIZE 42
145 
146 /** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */
147 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE * num_tracks
148 
149 /** Seek preroll value for opus */
150 #define OPUS_SEEK_PREROLL 80000000
151 
152 static int ebml_id_size(unsigned int id)
153 {
154  return (av_log2(id + 1) - 1) / 7 + 1;
155 }
156 
157 static void put_ebml_id(AVIOContext *pb, unsigned int id)
158 {
159  int i = ebml_id_size(id);
160  while (i--)
161  avio_w8(pb, (uint8_t)(id >> (i * 8)));
162 }
163 
164 /**
165  * Write an EBML size meaning "unknown size".
166  *
167  * @param bytes The number of bytes the size should occupy (maximum: 8).
168  */
169 static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
170 {
171  av_assert0(bytes <= 8);
172  avio_w8(pb, 0x1ff >> bytes);
173  ffio_fill(pb, 0xff, bytes - 1);
174 }
175 
176 /**
177  * Calculate how many bytes are needed to represent a given number in EBML.
178  */
179 static int ebml_num_size(uint64_t num)
180 {
181  int bytes = 1;
182  while ((num + 1) >> bytes * 7)
183  bytes++;
184  return bytes;
185 }
186 
187 /**
188  * Write a number in EBML variable length format.
189  *
190  * @param bytes The number of bytes that need to be used to write the number.
191  * If zero, any number of bytes can be used.
192  */
193 static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
194 {
195  int i, needed_bytes = ebml_num_size(num);
196 
197  // sizes larger than this are currently undefined in EBML
198  av_assert0(num < (1ULL << 56) - 1);
199 
200  if (bytes == 0)
201  // don't care how many bytes are used, so use the min
202  bytes = needed_bytes;
203  // the bytes needed to write the given size would exceed the bytes
204  // that we need to use, so write unknown size. This shouldn't happen.
205  av_assert0(bytes >= needed_bytes);
206 
207  num |= 1ULL << bytes * 7;
208  for (i = bytes - 1; i >= 0; i--)
209  avio_w8(pb, (uint8_t)(num >> i * 8));
210 }
211 
212 static void put_ebml_uint(AVIOContext *pb, unsigned int elementid, uint64_t val)
213 {
214  int i, bytes = 1;
215  uint64_t tmp = val;
216  while (tmp >>= 8)
217  bytes++;
218 
219  put_ebml_id(pb, elementid);
220  put_ebml_num(pb, bytes, 0);
221  for (i = bytes - 1; i >= 0; i--)
222  avio_w8(pb, (uint8_t)(val >> i * 8));
223 }
224 
225 static void put_ebml_sint(AVIOContext *pb, unsigned int elementid, int64_t val)
226 {
227  int i, bytes = 1;
228  uint64_t tmp = 2*(val < 0 ? val^-1 : val);
229 
230  while (tmp>>=8) bytes++;
231 
232  put_ebml_id(pb, elementid);
233  put_ebml_num(pb, bytes, 0);
234  for (i = bytes - 1; i >= 0; i--)
235  avio_w8(pb, (uint8_t)(val >> i * 8));
236 }
237 
238 static void put_ebml_float(AVIOContext *pb, unsigned int elementid, double val)
239 {
240  put_ebml_id(pb, elementid);
241  put_ebml_num(pb, 8, 0);
242  avio_wb64(pb, av_double2int(val));
243 }
244 
245 static void put_ebml_binary(AVIOContext *pb, unsigned int elementid,
246  const void *buf, int size)
247 {
248  put_ebml_id(pb, elementid);
249  put_ebml_num(pb, size, 0);
250  avio_write(pb, buf, size);
251 }
252 
253 static void put_ebml_string(AVIOContext *pb, unsigned int elementid,
254  const char *str)
255 {
256  put_ebml_binary(pb, elementid, str, strlen(str));
257 }
258 
259 /**
260  * Write a void element of a given size. Useful for reserving space in
261  * the file to be written to later.
262  *
263  * @param size The number of bytes to reserve, which must be at least 2.
264  */
265 static void put_ebml_void(AVIOContext *pb, uint64_t size)
266 {
267  int64_t currentpos = avio_tell(pb);
268 
269  av_assert0(size >= 2);
270 
272  // we need to subtract the length needed to store the size from the
273  // size we need to reserve so 2 cases, we use 8 bytes to store the
274  // size if possible, 1 byte otherwise
275  if (size < 10)
276  put_ebml_num(pb, size - 1, 0);
277  else
278  put_ebml_num(pb, size - 9, 8);
279  ffio_fill(pb, 0, currentpos + size - avio_tell(pb));
280 }
281 
282 static ebml_master start_ebml_master(AVIOContext *pb, unsigned int elementid,
283  uint64_t expectedsize)
284 {
285  int bytes = expectedsize ? ebml_num_size(expectedsize) : 8;
286  put_ebml_id(pb, elementid);
287  put_ebml_size_unknown(pb, bytes);
288  return (ebml_master) {avio_tell(pb), bytes };
289 }
290 
292 {
293  int64_t pos = avio_tell(pb);
294 
295  if (avio_seek(pb, master.pos - master.sizebytes, SEEK_SET) < 0)
296  return;
297  put_ebml_num(pb, pos - master.pos, master.sizebytes);
298  avio_seek(pb, pos, SEEK_SET);
299 }
300 
301 static void put_xiph_size(AVIOContext *pb, int size)
302 {
303  ffio_fill(pb, 255, size / 255);
304  avio_w8(pb, size % 255);
305 }
306 
307 /**
308  * Initialize a mkv_seekhead element to be ready to index level 1 Matroska
309  * elements. If a maximum number of elements is specified, enough space
310  * will be reserved at the current file location to write a seek head of
311  * that size.
312  *
313  * @param segment_offset The absolute offset to the position in the file
314  * where the segment begins.
315  * @param numelements The maximum number of elements that will be indexed
316  * by this seek head, 0 if unlimited.
317  */
318 static mkv_seekhead *mkv_start_seekhead(AVIOContext *pb, int64_t segment_offset,
319  int numelements)
320 {
321  mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead));
322  if (!new_seekhead)
323  return NULL;
324 
325  new_seekhead->segment_offset = segment_offset;
326 
327  if (numelements > 0) {
328  new_seekhead->filepos = avio_tell(pb);
329  // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
330  // and size, and 3 bytes to guarantee that an EBML void element
331  // will fit afterwards
332  new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13;
333  new_seekhead->max_entries = numelements;
334  put_ebml_void(pb, new_seekhead->reserved_size);
335  }
336  return new_seekhead;
337 }
338 
339 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos)
340 {
341  mkv_seekhead_entry *entries = seekhead->entries;
342 
343  // don't store more elements than we reserved space for
344  if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries)
345  return -1;
346 
347  entries = av_realloc_array(entries, seekhead->num_entries + 1, sizeof(mkv_seekhead_entry));
348  if (!entries)
349  return AVERROR(ENOMEM);
350  seekhead->entries = entries;
351 
352  seekhead->entries[seekhead->num_entries].elementid = elementid;
353  seekhead->entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset;
354 
355  return 0;
356 }
357 
358 /**
359  * Write the seek head to the file and free it. If a maximum number of
360  * elements was specified to mkv_start_seekhead(), the seek head will
361  * be written at the location reserved for it. Otherwise, it is written
362  * at the current location in the file.
363  *
364  * @return The file offset where the seekhead was written,
365  * -1 if an error occurred.
366  */
367 static int64_t mkv_write_seekhead(AVIOContext *pb, mkv_seekhead *seekhead)
368 {
369  ebml_master metaseek, seekentry;
370  int64_t currentpos;
371  int i;
372 
373  currentpos = avio_tell(pb);
374 
375  if (seekhead->reserved_size > 0) {
376  if (avio_seek(pb, seekhead->filepos, SEEK_SET) < 0) {
377  currentpos = -1;
378  goto fail;
379  }
380  }
381 
382  metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size);
383  for (i = 0; i < seekhead->num_entries; i++) {
384  mkv_seekhead_entry *entry = &seekhead->entries[i];
385 
387 
389  put_ebml_num(pb, ebml_id_size(entry->elementid), 0);
390  put_ebml_id(pb, entry->elementid);
391 
393  end_ebml_master(pb, seekentry);
394  }
395  end_ebml_master(pb, metaseek);
396 
397  if (seekhead->reserved_size > 0) {
398  uint64_t remaining = seekhead->filepos + seekhead->reserved_size - avio_tell(pb);
399  put_ebml_void(pb, remaining);
400  avio_seek(pb, currentpos, SEEK_SET);
401 
402  currentpos = seekhead->filepos;
403  }
404 fail:
405  av_freep(&seekhead->entries);
406  av_free(seekhead);
407 
408  return currentpos;
409 }
410 
411 static mkv_cues *mkv_start_cues(int64_t segment_offset)
412 {
413  mkv_cues *cues = av_mallocz(sizeof(mkv_cues));
414  if (!cues)
415  return NULL;
416 
417  cues->segment_offset = segment_offset;
418  return cues;
419 }
420 
421 static int mkv_add_cuepoint(mkv_cues *cues, int stream, int tracknum, int64_t ts,
422  int64_t cluster_pos, int64_t relative_pos, int64_t duration)
423 {
424  mkv_cuepoint *entries = cues->entries;
425 
426  if (ts < 0)
427  return 0;
428 
429  entries = av_realloc_array(entries, cues->num_entries + 1, sizeof(mkv_cuepoint));
430  if (!entries)
431  return AVERROR(ENOMEM);
432  cues->entries = entries;
433 
434  cues->entries[cues->num_entries].pts = ts;
435  cues->entries[cues->num_entries].stream_idx = stream;
436  cues->entries[cues->num_entries].tracknum = tracknum;
437  cues->entries[cues->num_entries].cluster_pos = cluster_pos - cues->segment_offset;
438  cues->entries[cues->num_entries].relative_pos = relative_pos;
439  cues->entries[cues->num_entries++].duration = duration;
440 
441  return 0;
442 }
443 
444 static int64_t mkv_write_cues(AVFormatContext *s, mkv_cues *cues, mkv_track *tracks, int num_tracks)
445 {
446  AVIOContext *pb = s->pb;
447  ebml_master cues_element;
448  int64_t currentpos;
449  int i, j;
450 
451  currentpos = avio_tell(pb);
452  cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0);
453 
454  for (i = 0; i < cues->num_entries; i++) {
455  ebml_master cuepoint, track_positions;
456  mkv_cuepoint *entry = &cues->entries[i];
457  uint64_t pts = entry->pts;
458  int ctp_nb = 0;
459 
460  // Calculate the number of entries, so we know the element size
461  for (j = 0; j < num_tracks; j++)
462  tracks[j].has_cue = 0;
463  for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
464  int tracknum = entry[j].stream_idx;
465  av_assert0(tracknum>=0 && tracknum<num_tracks);
466  if (tracks[tracknum].has_cue && s->streams[tracknum]->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
467  continue;
468  tracks[tracknum].has_cue = 1;
469  ctp_nb ++;
470  }
471 
474 
475  // put all the entries from different tracks that have the exact same
476  // timestamp into the same CuePoint
477  for (j = 0; j < num_tracks; j++)
478  tracks[j].has_cue = 0;
479  for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
480  int tracknum = entry[j].stream_idx;
481  av_assert0(tracknum>=0 && tracknum<num_tracks);
482  if (tracks[tracknum].has_cue && s->streams[tracknum]->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
483  continue;
484  tracks[tracknum].has_cue = 1;
486  put_ebml_uint(pb, MATROSKA_ID_CUETRACK , entry[j].tracknum );
487  put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION , entry[j].cluster_pos);
488  put_ebml_uint(pb, MATROSKA_ID_CUERELATIVEPOSITION, entry[j].relative_pos);
489  if (entry[j].duration != -1)
491  end_ebml_master(pb, track_positions);
492  }
493  i += j - 1;
494  end_ebml_master(pb, cuepoint);
495  }
496  end_ebml_master(pb, cues_element);
497 
498  return currentpos;
499 }
500 
502 {
503  const uint8_t *header_start[3];
504  int header_len[3];
505  int first_header_size;
506  int j;
507 
508  if (codec->codec_id == AV_CODEC_ID_VORBIS)
509  first_header_size = 30;
510  else
511  first_header_size = 42;
512 
514  first_header_size, header_start, header_len) < 0) {
515  av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n");
516  return -1;
517  }
518 
519  avio_w8(pb, 2); // number packets - 1
520  for (j = 0; j < 2; j++) {
521  put_xiph_size(pb, header_len[j]);
522  }
523  for (j = 0; j < 3; j++)
524  avio_write(pb, header_start[j], header_len[j]);
525 
526  return 0;
527 }
528 
530 {
531  if (codec->extradata && codec->extradata_size == 2)
532  avio_write(pb, codec->extradata, 2);
533  else
534  avio_wl16(pb, 0x403); // fallback to the version mentioned in matroska specs
535  return 0;
536 }
537 
539  AVIOContext *pb, AVCodecContext *codec)
540 {
541  int write_comment = (codec->channel_layout &&
542  !(codec->channel_layout & ~0x3ffffULL) &&
544  int ret = ff_flac_write_header(pb, codec->extradata, codec->extradata_size,
545  !write_comment);
546 
547  if (ret < 0)
548  return ret;
549 
550  if (write_comment) {
551  const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
552  "Lavf" : LIBAVFORMAT_IDENT;
553  AVDictionary *dict = NULL;
554  uint8_t buf[32], *data, *p;
555  int64_t len;
556 
557  snprintf(buf, sizeof(buf), "0x%"PRIx64, codec->channel_layout);
558  av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
559 
560  len = ff_vorbiscomment_length(dict, vendor);
561  if (len >= ((1<<24) - 4))
562  return AVERROR(EINVAL);
563 
564  data = av_malloc(len + 4);
565  if (!data) {
566  av_dict_free(&dict);
567  return AVERROR(ENOMEM);
568  }
569 
570  data[0] = 0x84;
571  AV_WB24(data + 1, len);
572 
573  p = data + 4;
574  ff_vorbiscomment_write(&p, &dict, vendor);
575 
576  avio_write(pb, data, len + 4);
577 
578  av_freep(&data);
579  av_dict_free(&dict);
580  }
581 
582  return 0;
583 }
584 
586  int *sample_rate, int *output_sample_rate)
587 {
588  MPEG4AudioConfig mp4ac;
589 
590  if (avpriv_mpeg4audio_get_config(&mp4ac, codec->extradata,
591  codec->extradata_size * 8, 1) < 0) {
592  av_log(s, AV_LOG_ERROR,
593  "Error parsing AAC extradata, unable to determine samplerate.\n");
594  return AVERROR(EINVAL);
595  }
596 
597  *sample_rate = mp4ac.sample_rate;
598  *output_sample_rate = mp4ac.ext_sample_rate;
599  return 0;
600 }
601 
603  AVCodecContext *codec,
604  AVIOContext *dyn_cp)
605 {
606  switch (codec->codec_id) {
607  case AV_CODEC_ID_VORBIS:
608  case AV_CODEC_ID_THEORA:
609  return put_xiph_codecpriv(s, dyn_cp, codec);
610  case AV_CODEC_ID_FLAC:
611  return put_flac_codecpriv(s, dyn_cp, codec);
612  case AV_CODEC_ID_WAVPACK:
613  return put_wv_codecpriv(dyn_cp, codec);
614  case AV_CODEC_ID_H264:
615  return ff_isom_write_avcc(dyn_cp, codec->extradata,
616  codec->extradata_size);
617  case AV_CODEC_ID_HEVC:
618  ff_isom_write_hvcc(dyn_cp, codec->extradata,
619  codec->extradata_size, 0);
620  return 0;
621  case AV_CODEC_ID_ALAC:
622  if (codec->extradata_size < 36) {
623  av_log(s, AV_LOG_ERROR,
624  "Invalid extradata found, ALAC expects a 36-byte "
625  "QuickTime atom.");
626  return AVERROR_INVALIDDATA;
627  } else
628  avio_write(dyn_cp, codec->extradata + 12,
629  codec->extradata_size - 12);
630  break;
631  default:
632  if (codec->codec_id == AV_CODEC_ID_PRORES &&
634  avio_wl32(dyn_cp, codec->codec_tag);
635  } else if (codec->extradata_size && codec->codec_id != AV_CODEC_ID_TTA)
636  avio_write(dyn_cp, codec->extradata, codec->extradata_size);
637  }
638 
639  return 0;
640 }
641 
643  AVCodecContext *codec, int native_id,
644  int qt_id)
645 {
646  AVIOContext *dyn_cp;
647  uint8_t *codecpriv;
648  int ret, codecpriv_size;
649 
650  ret = avio_open_dyn_buf(&dyn_cp);
651  if (ret < 0)
652  return ret;
653 
654  if (native_id) {
655  ret = mkv_write_native_codecprivate(s, codec, dyn_cp);
656  } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
657  if (qt_id) {
658  if (!codec->codec_tag)
660  codec->codec_id);
661  if (codec->extradata_size) {
664  ) {
665  int i;
666  avio_wb32(dyn_cp, 0x5a + codec->extradata_size);
667  avio_wl32(dyn_cp, codec->codec_tag);
668  for(i = 0; i < 0x5a - 8; i++)
669  avio_w8(dyn_cp, 0);
670  }
671  avio_write(dyn_cp, codec->extradata, codec->extradata_size);
672  }
673  } else {
675  av_log(s, AV_LOG_WARNING, "codec %s is not supported by this format\n",
676  avcodec_get_name(codec->codec_id));
677 
678  if (!codec->codec_tag)
680  codec->codec_id);
681  if (!codec->codec_tag && codec->codec_id != AV_CODEC_ID_RAWVIDEO) {
682  av_log(s, AV_LOG_ERROR, "No bmp codec tag found for codec %s\n",
683  avcodec_get_name(codec->codec_id));
684  ret = AVERROR(EINVAL);
685  }
686 
687  ff_put_bmp_header(dyn_cp, codec, ff_codec_bmp_tags, 0, 0);
688  }
689  } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
690  unsigned int tag;
692  if (!tag) {
693  av_log(s, AV_LOG_ERROR, "No wav codec tag found for codec %s\n",
694  avcodec_get_name(codec->codec_id));
695  ret = AVERROR(EINVAL);
696  }
697  if (!codec->codec_tag)
698  codec->codec_tag = tag;
699 
701  }
702 
703  codecpriv_size = avio_close_dyn_buf(dyn_cp, &codecpriv);
704  if (codecpriv_size)
706  codecpriv_size);
707  av_free(codecpriv);
708  return ret;
709 }
710 
711 
713  AVStream *st, int mode, int *h_width, int *h_height)
714 {
715  int i;
716  int ret = 0;
719 
720  *h_width = 1;
721  *h_height = 1;
722  // convert metadata into proper side data and add it to the stream
723  if ((tag = av_dict_get(st->metadata, "stereo_mode", NULL, 0)) ||
724  (tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
725  int stereo_mode = atoi(tag->value);
726 
727  for (i=0; i<MATROSKA_VIDEO_STEREOMODE_TYPE_NB; i++)
728  if (!strcmp(tag->value, ff_matroska_video_stereo_mode[i])){
729  stereo_mode = i;
730  break;
731  }
732 
733  if (stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB &&
734  stereo_mode != 10 && stereo_mode != 12) {
735  int ret = ff_mkv_stereo3d_conv(st, stereo_mode);
736  if (ret < 0)
737  return ret;
738  }
739  }
740 
741  // iterate to find the stereo3d side data
742  for (i = 0; i < st->nb_side_data; i++) {
743  AVPacketSideData sd = st->side_data[i];
744  if (sd.type == AV_PKT_DATA_STEREO3D) {
745  AVStereo3D *stereo = (AVStereo3D *)sd.data;
746 
747  switch (stereo->type) {
748  case AV_STEREO3D_2D:
750  break;
752  format = (stereo->flags & AV_STEREO3D_FLAG_INVERT)
755  *h_width = 2;
756  break;
759  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
760  format--;
761  *h_height = 2;
762  break;
765  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
766  format--;
767  break;
768  case AV_STEREO3D_LINES:
770  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
771  format--;
772  *h_height = 2;
773  break;
774  case AV_STEREO3D_COLUMNS:
776  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
777  format--;
778  *h_width = 2;
779  break;
782  if (stereo->flags & AV_STEREO3D_FLAG_INVERT)
783  format++;
784  break;
785  }
786  break;
787  }
788  }
789 
790  if (format == MATROSKA_VIDEO_STEREOMODE_TYPE_NB)
791  return ret;
792 
793  // if webm, do not write unsupported modes
794  if ((mode == MODE_WEBM &&
797  || format >= MATROSKA_VIDEO_STEREOMODE_TYPE_NB) {
798  av_log(s, AV_LOG_ERROR,
799  "The specified stereo mode is not valid.\n");
801  return AVERROR(EINVAL);
802  }
803 
804  // write StereoMode if format is valid
806 
807  return ret;
808 }
809 
811  int i, AVIOContext *pb, int default_stream_exists)
812 {
813  AVStream *st = s->streams[i];
814  AVCodecContext *codec = st->codec;
815  ebml_master subinfo, track;
816  int native_id = 0;
817  int qt_id = 0;
818  int bit_depth = av_get_bits_per_sample(codec->codec_id);
819  int sample_rate = codec->sample_rate;
820  int output_sample_rate = 0;
821  int display_width_div = 1;
822  int display_height_div = 1;
823  int j, ret;
825 
826  // ms precision is the de-facto standard timescale for mkv files
827  avpriv_set_pts_info(st, 64, 1, 1000);
828 
829  if (codec->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
830  mkv->have_attachments = 1;
831  return 0;
832  }
833 
834  if (!bit_depth && codec->codec_id != AV_CODEC_ID_ADPCM_G726)
835  bit_depth = av_get_bytes_per_sample(codec->sample_fmt) << 3;
836  if (!bit_depth)
837  bit_depth = codec->bits_per_coded_sample;
838 
839  if (codec->codec_id == AV_CODEC_ID_AAC) {
840  ret = get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate);
841  if (ret < 0)
842  return ret;
843  }
844 
847  mkv->is_dash ? mkv->dash_track_number : i + 1);
849  mkv->is_dash ? mkv->dash_track_number : i + 1);
850  put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0); // no lacing (yet)
851 
852  if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
854  tag = av_dict_get(st->metadata, "language", NULL, 0);
855  if (mkv->mode != MODE_WEBM || codec->codec_id != AV_CODEC_ID_WEBVTT) {
856  put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag && tag->value ? tag->value:"und");
857  } else if (tag && tag->value) {
859  }
860 
861  // The default value for TRACKFLAGDEFAULT is 1, so add element
862  // if we need to clear it.
863  if (default_stream_exists && !(st->disposition & AV_DISPOSITION_DEFAULT))
865 
868 
869  if (mkv->mode == MODE_WEBM && codec->codec_id == AV_CODEC_ID_WEBVTT) {
870  const char *codec_id;
872  codec_id = "D_WEBVTT/CAPTIONS";
873  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
874  } else if (st->disposition & AV_DISPOSITION_DESCRIPTIONS) {
875  codec_id = "D_WEBVTT/DESCRIPTIONS";
876  native_id = MATROSKA_TRACK_TYPE_METADATA;
877  } else if (st->disposition & AV_DISPOSITION_METADATA) {
878  codec_id = "D_WEBVTT/METADATA";
879  native_id = MATROSKA_TRACK_TYPE_METADATA;
880  } else {
881  codec_id = "D_WEBVTT/SUBTITLES";
882  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
883  }
884  put_ebml_string(pb, MATROSKA_ID_CODECID, codec_id);
885  } else {
886  // look for a codec ID string specific to mkv to use,
887  // if none are found, use AVI codes
888  for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
889  if (ff_mkv_codec_tags[j].id == codec->codec_id) {
891  native_id = 1;
892  break;
893  }
894  }
895  if (codec->codec_id == AV_CODEC_ID_RAWVIDEO && !codec->codec_tag) {
896  if (mkv->allow_raw_vfw) {
897  native_id = 0;
898  } else {
899  av_log(s, AV_LOG_ERROR, "Raw RGB is not supported Natively in Matroska, you can use AVI or NUT or\n"
900  "If you would like to store it anyway using VFW mode, enable allow_raw_vfw (-allow_raw_vfw 1)\n");
901  return AVERROR(EINVAL);
902  }
903  }
904  }
905 
906  if (codec->codec_type == AVMEDIA_TYPE_AUDIO && codec->initial_padding && codec->codec_id == AV_CODEC_ID_OPUS) {
907 // mkv->tracks[i].ts_offset = av_rescale_q(codec->initial_padding,
908 // (AVRational){ 1, codec->sample_rate },
909 // st->time_base);
910 
913  (AVRational){ 1, codec->sample_rate },
914  (AVRational){ 1, 1000000000 }));
915  }
916  if (codec->codec_id == AV_CODEC_ID_OPUS) {
918  }
919 
920  if (mkv->mode == MODE_WEBM && !(codec->codec_id == AV_CODEC_ID_VP8 ||
921  codec->codec_id == AV_CODEC_ID_VP9 ||
922  codec->codec_id == AV_CODEC_ID_OPUS ||
923  codec->codec_id == AV_CODEC_ID_VORBIS ||
924  codec->codec_id == AV_CODEC_ID_WEBVTT)) {
926  "Only VP8 or VP9 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
927  return AVERROR(EINVAL);
928  }
929 
930  switch (codec->codec_type) {
931  case AVMEDIA_TYPE_VIDEO:
933 
934  if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
935  && av_cmp_q(av_inv_q(st->avg_frame_rate), codec->time_base) > 0)
936  put_ebml_uint(pb, MATROSKA_ID_TRACKDEFAULTDURATION, 1000000000LL * st->avg_frame_rate.den / st->avg_frame_rate.num);
937  else
938  put_ebml_uint(pb, MATROSKA_ID_TRACKDEFAULTDURATION, 1000000000LL * codec->time_base.num / codec->time_base.den);
939 
940  if (!native_id &&
941  ff_codec_get_tag(ff_codec_movvideo_tags, codec->codec_id) &&
942  ((!ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id) && codec->codec_id != AV_CODEC_ID_RAWVIDEO) ||
943  codec->codec_id == AV_CODEC_ID_SVQ1 ||
944  codec->codec_id == AV_CODEC_ID_SVQ3 ||
945  codec->codec_id == AV_CODEC_ID_CINEPAK))
946  qt_id = 1;
947 
948  if (qt_id)
949  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME");
950  else if (!native_id) {
951  // if there is no mkv-specific codec ID, use VFW mode
952  put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC");
953  mkv->tracks[i].write_dts = 1;
954  s->internal->avoid_negative_ts_use_pts = 0;
955  }
956 
957  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0);
958  // XXX: interlace flag?
959  put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width);
960  put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height);
961 
962  // check both side data and metadata for stereo information,
963  // write the result to the bitstream if any is found
964  ret = mkv_write_stereo_mode(s, pb, st, mkv->mode,
965  &display_width_div,
966  &display_height_div);
967  if (ret < 0)
968  return ret;
969 
970  if (((tag = av_dict_get(st->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
971  ((tag = av_dict_get( s->metadata, "alpha_mode", NULL, 0)) && atoi(tag->value)) ||
972  (codec->pix_fmt == AV_PIX_FMT_YUVA420P)) {
974  }
975 
976  // write DisplayWidth and DisplayHeight, they contain the size of
977  // a single source view and/or the display aspect ratio
978  if (st->sample_aspect_ratio.num) {
979  int64_t d_width = av_rescale(codec->width, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
980  if (d_width > INT_MAX) {
981  av_log(s, AV_LOG_ERROR, "Overflow in display width\n");
982  return AVERROR(EINVAL);
983  }
984  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
985  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, codec->height / display_height_div);
986  } else if (display_width_div != 1 || display_height_div != 1) {
987  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , codec->width / display_width_div);
988  put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, codec->height / display_height_div);
989  }
990 
991  if (codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
992  uint32_t color_space = av_le2ne32(codec->codec_tag);
993  put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLORSPACE, &color_space, sizeof(color_space));
994  }
995 
996  end_ebml_master(pb, subinfo);
997  break;
998 
999  case AVMEDIA_TYPE_AUDIO:
1001 
1002  if (!native_id)
1003  // no mkv-specific ID, use ACM mode
1004  put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM");
1005 
1006  subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
1007  put_ebml_uint (pb, MATROSKA_ID_AUDIOCHANNELS , codec->channels);
1009  if (output_sample_rate)
1010  put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
1011  if (bit_depth)
1012  put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth);
1013  end_ebml_master(pb, subinfo);
1014  break;
1015 
1016  case AVMEDIA_TYPE_SUBTITLE:
1017  if (!native_id) {
1018  av_log(s, AV_LOG_ERROR, "Subtitle codec %d is not supported.\n", codec->codec_id);
1019  return AVERROR(ENOSYS);
1020  }
1021 
1022  if (mkv->mode != MODE_WEBM || codec->codec_id != AV_CODEC_ID_WEBVTT)
1023  native_id = MATROSKA_TRACK_TYPE_SUBTITLE;
1024 
1025  put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, native_id);
1026  break;
1027  default:
1028  av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska.\n");
1029  return AVERROR(EINVAL);
1030  }
1031 
1032  if (mkv->mode != MODE_WEBM || codec->codec_id != AV_CODEC_ID_WEBVTT) {
1033  ret = mkv_write_codecprivate(s, pb, codec, native_id, qt_id);
1034  if (ret < 0)
1035  return ret;
1036  }
1037 
1038  end_ebml_master(pb, track);
1039 
1040  return 0;
1041 }
1042 
1044 {
1045  MatroskaMuxContext *mkv = s->priv_data;
1046  AVIOContext *pb = s->pb;
1047  ebml_master tracks;
1048  int i, ret, default_stream_exists = 0;
1049 
1051  if (ret < 0)
1052  return ret;
1053 
1054  tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0);
1055  for (i = 0; i < s->nb_streams; i++) {
1056  AVStream *st = s->streams[i];
1057  default_stream_exists |= st->disposition & AV_DISPOSITION_DEFAULT;
1058  }
1059  for (i = 0; i < s->nb_streams; i++) {
1060  ret = mkv_write_track(s, mkv, i, pb, default_stream_exists);
1061  if (ret < 0)
1062  return ret;
1063  }
1064  end_ebml_master(pb, tracks);
1065  return 0;
1066 }
1067 
1069 {
1070  MatroskaMuxContext *mkv = s->priv_data;
1071  AVIOContext *pb = s->pb;
1072  ebml_master chapters, editionentry;
1073  AVRational scale = {1, 1E9};
1074  int i, ret;
1075 
1076  if (!s->nb_chapters || mkv->wrote_chapters)
1077  return 0;
1078 
1080  if (ret < 0) return ret;
1081 
1082  chapters = start_ebml_master(pb, MATROSKA_ID_CHAPTERS , 0);
1083  editionentry = start_ebml_master(pb, MATROSKA_ID_EDITIONENTRY, 0);
1086  for (i = 0; i < s->nb_chapters; i++) {
1087  ebml_master chapteratom, chapterdisplay;
1088  AVChapter *c = s->chapters[i];
1089  int64_t chapterstart = av_rescale_q(c->start, c->time_base, scale);
1090  int64_t chapterend = av_rescale_q(c->end, c->time_base, scale);
1091  AVDictionaryEntry *t = NULL;
1092  if (chapterstart < 0 || chapterstart > chapterend || chapterend < 0) {
1093  av_log(s, AV_LOG_ERROR,
1094  "Invalid chapter start (%"PRId64") or end (%"PRId64").\n",
1095  chapterstart, chapterend);
1096  return AVERROR_INVALIDDATA;
1097  }
1098 
1099  chapteratom = start_ebml_master(pb, MATROSKA_ID_CHAPTERATOM, 0);
1101  put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
1102  put_ebml_uint(pb, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
1105  if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
1106  chapterdisplay = start_ebml_master(pb, MATROSKA_ID_CHAPTERDISPLAY, 0);
1109  end_ebml_master(pb, chapterdisplay);
1110  }
1111  end_ebml_master(pb, chapteratom);
1112  }
1113  end_ebml_master(pb, editionentry);
1114  end_ebml_master(pb, chapters);
1115 
1116  mkv->wrote_chapters = 1;
1117  return 0;
1118 }
1119 
1121 {
1122  uint8_t *key = av_strdup(t->key);
1123  uint8_t *p = key;
1124  const uint8_t *lang = NULL;
1125  ebml_master tag;
1126 
1127  if (!key)
1128  return AVERROR(ENOMEM);
1129 
1130  if ((p = strrchr(p, '-')) &&
1131  (lang = av_convert_lang_to(p + 1, AV_LANG_ISO639_2_BIBL)))
1132  *p = 0;
1133 
1134  p = key;
1135  while (*p) {
1136  if (*p == ' ')
1137  *p = '_';
1138  else if (*p >= 'a' && *p <= 'z')
1139  *p -= 'a' - 'A';
1140  p++;
1141  }
1142 
1145  if (lang)
1148  end_ebml_master(pb, tag);
1149 
1150  av_freep(&key);
1151  return 0;
1152 }
1153 
1154 static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, unsigned int elementid,
1155  unsigned int uid, ebml_master *tags)
1156 {
1157  MatroskaMuxContext *mkv = s->priv_data;
1158  ebml_master tag, targets;
1159  AVDictionaryEntry *t = NULL;
1160  int ret;
1161 
1162  if (!tags->pos) {
1164  if (ret < 0) return ret;
1165 
1166  *tags = start_ebml_master(s->pb, MATROSKA_ID_TAGS, 0);
1167  }
1168 
1169  tag = start_ebml_master(s->pb, MATROSKA_ID_TAG, 0);
1170  targets = start_ebml_master(s->pb, MATROSKA_ID_TAGTARGETS, 0);
1171  if (elementid)
1172  put_ebml_uint(s->pb, elementid, uid);
1173  end_ebml_master(s->pb, targets);
1174 
1175  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
1176  if (av_strcasecmp(t->key, "title") &&
1177  av_strcasecmp(t->key, "stereo_mode") &&
1178  av_strcasecmp(t->key, "encoding_tool")) {
1179  ret = mkv_write_simpletag(s->pb, t);
1180  if (ret < 0)
1181  return ret;
1182  }
1183  }
1184 
1185  end_ebml_master(s->pb, tag);
1186  return 0;
1187 }
1188 
1190 {
1191  AVDictionaryEntry *t = NULL;
1192 
1193  while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
1194  if (av_strcasecmp(t->key, "title") && av_strcasecmp(t->key, "stereo_mode"))
1195  return 1;
1196 
1197  return 0;
1198 }
1199 
1201 {
1202  MatroskaMuxContext *mkv = s->priv_data;
1203  ebml_master tags = {0};
1204  int i, ret;
1205 
1207 
1208  if (mkv_check_tag(s->metadata)) {
1209  ret = mkv_write_tag(s, s->metadata, 0, 0, &tags);
1210  if (ret < 0) return ret;
1211  }
1212 
1213  for (i = 0; i < s->nb_streams; i++) {
1214  AVStream *st = s->streams[i];
1215 
1216  if (!mkv_check_tag(st->metadata))
1217  continue;
1218 
1219  ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_TRACKUID, i + 1, &tags);
1220  if (ret < 0) return ret;
1221  }
1222 
1223  for (i = 0; i < s->nb_chapters; i++) {
1224  AVChapter *ch = s->chapters[i];
1225 
1226  if (!mkv_check_tag(ch->metadata))
1227  continue;
1228 
1230  if (ret < 0) return ret;
1231  }
1232 
1233  if (tags.pos)
1234  end_ebml_master(s->pb, tags);
1235  return 0;
1236 }
1237 
1239 {
1240  MatroskaMuxContext *mkv = s->priv_data;
1241  AVIOContext *pb = s->pb;
1242  ebml_master attachments;
1243  AVLFG c;
1244  int i, ret;
1245 
1246  if (!mkv->have_attachments)
1247  return 0;
1248 
1250 
1252  if (ret < 0) return ret;
1253 
1254  attachments = start_ebml_master(pb, MATROSKA_ID_ATTACHMENTS, 0);
1255 
1256  for (i = 0; i < s->nb_streams; i++) {
1257  AVStream *st = s->streams[i];
1258  ebml_master attached_file;
1259  AVDictionaryEntry *t;
1260  const char *mimetype = NULL;
1261  uint64_t fileuid;
1262 
1264  continue;
1265 
1266  attached_file = start_ebml_master(pb, MATROSKA_ID_ATTACHEDFILE, 0);
1267 
1268  if (t = av_dict_get(st->metadata, "title", NULL, 0))
1270  if (!(t = av_dict_get(st->metadata, "filename", NULL, 0))) {
1271  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no filename tag.\n", i);
1272  return AVERROR(EINVAL);
1273  }
1275  if (t = av_dict_get(st->metadata, "mimetype", NULL, 0))
1276  mimetype = t->value;
1277  else if (st->codec->codec_id != AV_CODEC_ID_NONE ) {
1278  int i;
1279  for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1280  if (ff_mkv_mime_tags[i].id == st->codec->codec_id) {
1281  mimetype = ff_mkv_mime_tags[i].str;
1282  break;
1283  }
1284  for (i = 0; ff_mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++)
1285  if (ff_mkv_image_mime_tags[i].id == st->codec->codec_id) {
1286  mimetype = ff_mkv_image_mime_tags[i].str;
1287  break;
1288  }
1289  }
1290  if (!mimetype) {
1291  av_log(s, AV_LOG_ERROR, "Attachment stream %d has no mimetype tag and "
1292  "it cannot be deduced from the codec id.\n", i);
1293  return AVERROR(EINVAL);
1294  }
1295 
1296  if (s->flags & AVFMT_FLAG_BITEXACT) {
1297  struct AVSHA *sha = av_sha_alloc();
1298  uint8_t digest[20];
1299  if (!sha)
1300  return AVERROR(ENOMEM);
1301  av_sha_init(sha, 160);
1303  av_sha_final(sha, digest);
1304  av_free(sha);
1305  fileuid = AV_RL64(digest);
1306  } else {
1307  fileuid = av_lfg_get(&c);
1308  }
1309  av_log(s, AV_LOG_VERBOSE, "Using %.16"PRIx64" for attachment %d\n",
1310  fileuid, i);
1311 
1314  put_ebml_uint(pb, MATROSKA_ID_FILEUID, fileuid);
1315  end_ebml_master(pb, attached_file);
1316  }
1317  end_ebml_master(pb, attachments);
1318 
1319  return 0;
1320 }
1321 
1323 {
1324  MatroskaMuxContext *mkv = s->priv_data;
1325  AVIOContext *pb = s->pb;
1326  ebml_master ebml_header, segment_info;
1328  int ret, i, version = 2;
1329 
1330  if (!strcmp(s->oformat->name, "webm"))
1331  mkv->mode = MODE_WEBM;
1332  else
1333  mkv->mode = MODE_MATROSKAv2;
1334 
1335  if (s->avoid_negative_ts < 0) {
1336  s->avoid_negative_ts = 1;
1338  }
1339 
1340  if (mkv->mode != MODE_WEBM ||
1341  av_dict_get(s->metadata, "stereo_mode", NULL, 0) ||
1342  av_dict_get(s->metadata, "alpha_mode", NULL, 0))
1343  version = 4;
1344 
1345  for (i = 0; i < s->nb_streams; i++) {
1346  if (s->streams[i]->codec->codec_id == AV_CODEC_ID_ATRAC3 ||
1347  s->streams[i]->codec->codec_id == AV_CODEC_ID_COOK ||
1349  s->streams[i]->codec->codec_id == AV_CODEC_ID_SIPR ||
1350  s->streams[i]->codec->codec_id == AV_CODEC_ID_RV10 ||
1351  s->streams[i]->codec->codec_id == AV_CODEC_ID_RV20) {
1352  av_log(s, AV_LOG_ERROR,
1353  "The Matroska muxer does not yet support muxing %s\n",
1355  return AVERROR_PATCHWELCOME;
1356  }
1357  if (s->streams[i]->codec->codec_id == AV_CODEC_ID_OPUS ||
1358  av_dict_get(s->streams[i]->metadata, "stereo_mode", NULL, 0) ||
1359  av_dict_get(s->streams[i]->metadata, "alpha_mode", NULL, 0))
1360  version = 4;
1361  }
1362 
1363  mkv->tracks = av_mallocz_array(s->nb_streams, sizeof(*mkv->tracks));
1364  if (!mkv->tracks)
1365  return AVERROR(ENOMEM);
1366 
1367  ebml_header = start_ebml_master(pb, EBML_ID_HEADER, 0);
1373  put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , version);
1375  end_ebml_master(pb, ebml_header);
1376 
1378  mkv->segment_offset = avio_tell(pb);
1379 
1380  // we write 2 seek heads - one at the end of the file to point to each
1381  // cluster, and one at the beginning to point to all other level one
1382  // elements (including the seek head at the end of the file), which
1383  // isn't more than 10 elements if we only write one of each other
1384  // currently defined level 1 element
1385  mkv->main_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10);
1386  if (!mkv->main_seekhead)
1387  return AVERROR(ENOMEM);
1388 
1390  if (ret < 0) return ret;
1391 
1392  segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0);
1394  if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
1396  if (!(s->flags & AVFMT_FLAG_BITEXACT)) {
1397  uint32_t segment_uid[4];
1398  AVLFG lfg;
1399 
1401 
1402  for (i = 0; i < 4; i++)
1403  segment_uid[i] = av_lfg_get(&lfg);
1404 
1406  if ((tag = av_dict_get(s->metadata, "encoding_tool", NULL, 0)))
1408  else
1410  put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16);
1411  } else {
1412  const char *ident = "Lavf";
1415  }
1416 
1417  if (tag = av_dict_get(s->metadata, "creation_time", NULL, 0)) {
1418  // Adjust time so it's relative to 2001-01-01 and convert to nanoseconds.
1419  int64_t date_utc = (ff_iso8601_to_unix_time(tag->value) - 978307200) * 1000000000;
1420  uint8_t date_utc_buf[8];
1421  AV_WB64(date_utc_buf, date_utc);
1422  put_ebml_binary(pb, MATROSKA_ID_DATEUTC, date_utc_buf, 8);
1423  }
1424 
1425  // reserve space for the duration
1426  mkv->duration = 0;
1427  mkv->duration_offset = avio_tell(pb);
1428  if (!mkv->is_live) {
1429  put_ebml_void(pb, 11); // assumes double-precision float to be written
1430  }
1431  end_ebml_master(pb, segment_info);
1432 
1433  ret = mkv_write_tracks(s);
1434  if (ret < 0)
1435  return ret;
1436 
1437  for (i = 0; i < s->nb_chapters; i++)
1438  mkv->chapter_id_offset = FFMAX(mkv->chapter_id_offset, 1LL - s->chapters[i]->id);
1439 
1440  if (mkv->mode != MODE_WEBM) {
1441  ret = mkv_write_chapters(s);
1442  if (ret < 0)
1443  return ret;
1444 
1445  ret = mkv_write_tags(s);
1446  if (ret < 0)
1447  return ret;
1448 
1449  ret = mkv_write_attachments(s);
1450  if (ret < 0)
1451  return ret;
1452  }
1453 
1454  if (!s->pb->seekable && !mkv->is_live)
1456 
1457  mkv->cues = mkv_start_cues(mkv->segment_offset);
1458  if (!mkv->cues)
1459  return AVERROR(ENOMEM);
1460 
1461  if (pb->seekable && mkv->reserve_cues_space) {
1462  mkv->cues_pos = avio_tell(pb);
1464  }
1465 
1467  mkv->cur_audio_pkt.size = 0;
1468  mkv->cluster_pos = -1;
1469 
1470  avio_flush(pb);
1471 
1472  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1473  // after 4k and on a keyframe
1474  if (pb->seekable) {
1475  if (mkv->cluster_time_limit < 0)
1476  mkv->cluster_time_limit = 5000;
1477  if (mkv->cluster_size_limit < 0)
1478  mkv->cluster_size_limit = 5 * 1024 * 1024;
1479  } else {
1480  if (mkv->cluster_time_limit < 0)
1481  mkv->cluster_time_limit = 1000;
1482  if (mkv->cluster_size_limit < 0)
1483  mkv->cluster_size_limit = 32 * 1024;
1484  }
1485 
1486  return 0;
1487 }
1488 
1489 static int mkv_blockgroup_size(int pkt_size)
1490 {
1491  int size = pkt_size + 4;
1492  size += ebml_num_size(size);
1493  size += 2; // EBML ID for block and block duration
1494  size += 8; // max size of block duration
1495  size += ebml_num_size(size);
1496  size += 1; // blockgroup EBML ID
1497  return size;
1498 }
1499 
1500 static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
1501 {
1502  uint8_t *dst;
1503  int srclen = *size;
1504  int offset = 0;
1505  int ret;
1506 
1507  dst = av_malloc(srclen);
1508  if (!dst)
1509  return AVERROR(ENOMEM);
1510 
1511  while (srclen >= WV_HEADER_SIZE) {
1512  WvHeader header;
1513 
1514  ret = ff_wv_parse_header(&header, src);
1515  if (ret < 0)
1516  goto fail;
1517  src += WV_HEADER_SIZE;
1518  srclen -= WV_HEADER_SIZE;
1519 
1520  if (srclen < header.blocksize) {
1521  ret = AVERROR_INVALIDDATA;
1522  goto fail;
1523  }
1524 
1525  if (header.initial) {
1526  AV_WL32(dst + offset, header.samples);
1527  offset += 4;
1528  }
1529  AV_WL32(dst + offset, header.flags);
1530  AV_WL32(dst + offset + 4, header.crc);
1531  offset += 8;
1532 
1533  if (!(header.initial && header.final)) {
1534  AV_WL32(dst + offset, header.blocksize);
1535  offset += 4;
1536  }
1537 
1538  memcpy(dst + offset, src, header.blocksize);
1539  src += header.blocksize;
1540  srclen -= header.blocksize;
1541  offset += header.blocksize;
1542  }
1543 
1544  *pdst = dst;
1545  *size = offset;
1546 
1547  return 0;
1548 fail:
1549  av_freep(&dst);
1550  return ret;
1551 }
1552 
1554  unsigned int blockid, AVPacket *pkt, int keyframe)
1555 {
1556  MatroskaMuxContext *mkv = s->priv_data;
1557  AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
1558  uint8_t *data = NULL, *side_data = NULL;
1559  int offset = 0, size = pkt->size, side_data_size = 0;
1560  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
1561  uint64_t additional_id = 0;
1562  int64_t discard_padding = 0;
1563  uint8_t track_number = (mkv->is_dash ? mkv->dash_track_number : (pkt->stream_index + 1));
1564  ebml_master block_group, block_additions, block_more;
1565 
1566  av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
1567  "pts %" PRId64 ", dts %" PRId64 ", duration %d, keyframe %d\n",
1568  avio_tell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration,
1569  keyframe != 0);
1570  if (codec->codec_id == AV_CODEC_ID_H264 && codec->extradata_size > 0 &&
1571  (AV_RB24(codec->extradata) == 1 || AV_RB32(codec->extradata) == 1))
1572  ff_avc_parse_nal_units_buf(pkt->data, &data, &size);
1573  else if (codec->codec_id == AV_CODEC_ID_HEVC && codec->extradata_size > 6 &&
1574  (AV_RB24(codec->extradata) == 1 || AV_RB32(codec->extradata) == 1))
1575  /* extradata is Annex B, assume the bitstream is too and convert it */
1576  ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL);
1577  else if (codec->codec_id == AV_CODEC_ID_WAVPACK) {
1578  int ret = mkv_strip_wavpack(pkt->data, &data, &size);
1579  if (ret < 0) {
1580  av_log(s, AV_LOG_ERROR, "Error stripping a WavPack packet.\n");
1581  return;
1582  }
1583  } else
1584  data = pkt->data;
1585 
1586  if (codec->codec_id == AV_CODEC_ID_PRORES && size >= 8) {
1587  /* Matroska specification requires to remove the first QuickTime atom
1588  */
1589  size -= 8;
1590  offset = 8;
1591  }
1592 
1593  side_data = av_packet_get_side_data(pkt,
1595  &side_data_size);
1596 
1597  if (side_data && side_data_size >= 10) {
1598  discard_padding = av_rescale_q(AV_RL32(side_data + 4),
1599  (AVRational){1, codec->sample_rate},
1600  (AVRational){1, 1000000000});
1601  }
1602 
1603  side_data = av_packet_get_side_data(pkt,
1605  &side_data_size);
1606  if (side_data) {
1607  additional_id = AV_RB64(side_data);
1608  side_data += 8;
1609  side_data_size -= 8;
1610  }
1611 
1612  if ((side_data_size && additional_id == 1) || discard_padding) {
1613  block_group = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, 0);
1614  blockid = MATROSKA_ID_BLOCK;
1615  }
1616 
1617  put_ebml_id(pb, blockid);
1618  put_ebml_num(pb, size + 4, 0);
1619  // this assumes stream_index is less than 126
1620  avio_w8(pb, 0x80 | track_number);
1621  avio_wb16(pb, ts - mkv->cluster_pts);
1622  avio_w8(pb, (blockid == MATROSKA_ID_SIMPLEBLOCK && keyframe) ? (1 << 7) : 0);
1623  avio_write(pb, data + offset, size);
1624  if (data != pkt->data)
1625  av_free(data);
1626 
1627  if (blockid == MATROSKA_ID_BLOCK && !keyframe) {
1629  mkv->last_track_timestamp[track_number - 1]);
1630  }
1631  mkv->last_track_timestamp[track_number - 1] = ts - mkv->cluster_pts;
1632 
1633  if (discard_padding) {
1634  put_ebml_sint(pb, MATROSKA_ID_DISCARDPADDING, discard_padding);
1635  }
1636 
1637  if (side_data_size && additional_id == 1) {
1638  block_additions = start_ebml_master(pb, MATROSKA_ID_BLOCKADDITIONS, 0);
1639  block_more = start_ebml_master(pb, MATROSKA_ID_BLOCKMORE, 0);
1642  put_ebml_num(pb, side_data_size, 0);
1643  avio_write(pb, side_data, side_data_size);
1644  end_ebml_master(pb, block_more);
1645  end_ebml_master(pb, block_additions);
1646  }
1647  if ((side_data_size && additional_id == 1) || discard_padding) {
1648  end_ebml_master(pb, block_group);
1649  }
1650 }
1651 
1653 {
1654  MatroskaMuxContext *mkv = s->priv_data;
1655  ebml_master blockgroup;
1656  int id_size, settings_size, size;
1657  uint8_t *id, *settings;
1658  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
1659  const int flags = 0;
1660 
1661  id_size = 0;
1663  &id_size);
1664 
1665  settings_size = 0;
1667  &settings_size);
1668 
1669  size = id_size + 1 + settings_size + 1 + pkt->size;
1670 
1671  av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
1672  "pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n",
1673  avio_tell(pb), size, pkt->pts, pkt->dts, pkt->duration, flags);
1674 
1676 
1678  put_ebml_num(pb, size + 4, 0);
1679  avio_w8(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126
1680  avio_wb16(pb, ts - mkv->cluster_pts);
1681  avio_w8(pb, flags);
1682  avio_printf(pb, "%.*s\n%.*s\n%.*s", id_size, id, settings_size, settings, pkt->size, pkt->data);
1683 
1685  end_ebml_master(pb, blockgroup);
1686 
1687  return pkt->duration;
1688 }
1689 
1691 {
1692  MatroskaMuxContext *mkv = s->priv_data;
1693  int bufsize;
1694  uint8_t *dyn_buf;
1695 
1696  if (!mkv->dyn_bc)
1697  return;
1698 
1699  bufsize = avio_close_dyn_buf(mkv->dyn_bc, &dyn_buf);
1700  avio_write(s->pb, dyn_buf, bufsize);
1701  av_free(dyn_buf);
1702  mkv->dyn_bc = NULL;
1703 }
1704 
1706 {
1707  MatroskaMuxContext *mkv = s->priv_data;
1708  AVIOContext *pb;
1709 
1710  if (s->pb->seekable) {
1711  pb = s->pb;
1712  } else {
1713  pb = mkv->dyn_bc;
1714  }
1715 
1716  av_log(s, AV_LOG_DEBUG,
1717  "Starting new cluster at offset %" PRIu64 " bytes, "
1718  "pts %" PRIu64 "dts %" PRIu64 "\n",
1719  avio_tell(pb), pkt->pts, pkt->dts);
1720  end_ebml_master(pb, mkv->cluster);
1721  mkv->cluster_pos = -1;
1722  if (mkv->dyn_bc)
1723  mkv_flush_dynbuf(s);
1724  avio_flush(s->pb);
1725 }
1726 
1728 {
1729  MatroskaMuxContext *mkv = s->priv_data;
1730  AVIOContext *pb = s->pb;
1731  AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
1732  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
1733  int duration = pkt->duration;
1734  int ret;
1735  int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
1736  int64_t relative_packet_pos;
1737  int dash_tracknum = mkv->is_dash ? mkv->dash_track_number : pkt->stream_index + 1;
1738 
1739  if (ts == AV_NOPTS_VALUE) {
1740  av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
1741  return AVERROR(EINVAL);
1742  }
1743  ts += mkv->tracks[pkt->stream_index].ts_offset;
1744 
1745  if (mkv->cluster_pos != -1) {
1746  int64_t cluster_time = ts - mkv->cluster_pts + mkv->tracks[pkt->stream_index].ts_offset;
1747  if ((int16_t)cluster_time != cluster_time) {
1748  av_log(s, AV_LOG_WARNING, "Starting new cluster due to timestamp\n");
1749  mkv_start_new_cluster(s, pkt);
1750  }
1751  }
1752 
1753  if (!s->pb->seekable) {
1754  if (!mkv->dyn_bc) {
1755  ret = avio_open_dyn_buf(&mkv->dyn_bc);
1756  if (ret < 0) {
1757  av_log(s, AV_LOG_ERROR, "Failed to open dynamic buffer\n");
1758  return ret;
1759  }
1760  }
1761  pb = mkv->dyn_bc;
1762  }
1763 
1764  if (mkv->cluster_pos == -1) {
1765  mkv->cluster_pos = avio_tell(s->pb);
1768  mkv->cluster_pts = FFMAX(0, ts);
1769  }
1770 
1771  relative_packet_pos = avio_tell(s->pb) - mkv->cluster.pos;
1772 
1773  if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1774  mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
1775  if (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe || add_cue) {
1776  ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts, mkv->cluster_pos, relative_packet_pos, -1);
1777  if (ret < 0) return ret;
1778  }
1779  } else {
1780  if (codec->codec_id == AV_CODEC_ID_WEBVTT) {
1781  duration = mkv_write_vtt_blocks(s, pb, pkt);
1782  } else {
1784  mkv_blockgroup_size(pkt->size));
1785  /* For backward compatibility, prefer convergence_duration. */
1786  if (pkt->convergence_duration > 0) {
1787  duration = pkt->convergence_duration;
1788  }
1789  /* All subtitle blocks are considered to be keyframes. */
1790  mkv_write_block(s, pb, MATROSKA_ID_BLOCK, pkt, 1);
1792  end_ebml_master(pb, blockgroup);
1793  }
1794 
1795  ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts,
1796  mkv->cluster_pos, relative_packet_pos, duration);
1797  if (ret < 0)
1798  return ret;
1799  }
1800 
1801  mkv->duration = FFMAX(mkv->duration, ts + duration);
1802  return 0;
1803 }
1804 
1806 {
1807  MatroskaMuxContext *mkv = s->priv_data;
1808  int codec_type = s->streams[pkt->stream_index]->codec->codec_type;
1809  int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
1810  int cluster_size;
1811  int64_t cluster_time;
1812  int ret;
1813  int start_new_cluster;
1814 
1815  if (mkv->tracks[pkt->stream_index].write_dts)
1816  cluster_time = pkt->dts - mkv->cluster_pts;
1817  else
1818  cluster_time = pkt->pts - mkv->cluster_pts;
1819  cluster_time += mkv->tracks[pkt->stream_index].ts_offset;
1820 
1821  // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
1822  // after 4k and on a keyframe
1823  if (s->pb->seekable) {
1824  cluster_size = avio_tell(s->pb) - mkv->cluster_pos;
1825  } else {
1826  cluster_size = avio_tell(mkv->dyn_bc);
1827  }
1828 
1829  if (mkv->is_dash && codec_type == AVMEDIA_TYPE_VIDEO) {
1830  // WebM DASH specification states that the first block of every cluster
1831  // has to be a key frame. So for DASH video, we only create a cluster
1832  // on seeing key frames.
1833  start_new_cluster = keyframe;
1834  } else if (mkv->is_dash && codec_type == AVMEDIA_TYPE_AUDIO &&
1835  (mkv->cluster_pos == -1 ||
1836  cluster_time > mkv->cluster_time_limit)) {
1837  // For DASH audio, we create a Cluster based on cluster_time_limit
1838  start_new_cluster = 1;
1839  } else if (!mkv->is_dash &&
1840  (cluster_size > mkv->cluster_size_limit ||
1841  cluster_time > mkv->cluster_time_limit ||
1842  (codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
1843  cluster_size > 4 * 1024))) {
1844  start_new_cluster = 1;
1845  } else {
1846  start_new_cluster = 0;
1847  }
1848 
1849  if (mkv->cluster_pos != -1 && start_new_cluster) {
1850  mkv_start_new_cluster(s, pkt);
1851  }
1852 
1853  // check if we have an audio packet cached
1854  if (mkv->cur_audio_pkt.size > 0) {
1855  // for DASH audio, a CuePoint has to be added when there is a new cluster.
1857  mkv->is_dash ? start_new_cluster : 0);
1859  if (ret < 0) {
1860  av_log(s, AV_LOG_ERROR,
1861  "Could not write cached audio packet ret:%d\n", ret);
1862  return ret;
1863  }
1864  }
1865 
1866  // buffer an audio packet to ensure the packet containing the video
1867  // keyframe's timecode is contained in the same cluster for WebM
1868  if (codec_type == AVMEDIA_TYPE_AUDIO) {
1869  mkv->cur_audio_pkt = *pkt;
1870  if (pkt->buf) {
1871  mkv->cur_audio_pkt.buf = av_buffer_ref(pkt->buf);
1872  ret = mkv->cur_audio_pkt.buf ? 0 : AVERROR(ENOMEM);
1873  } else
1874  ret = av_dup_packet(&mkv->cur_audio_pkt);
1875  if (mkv->cur_audio_pkt.side_data_elems > 0) {
1877  }
1878  } else
1879  ret = mkv_write_packet_internal(s, pkt, 0);
1880  return ret;
1881 }
1882 
1884 {
1885  MatroskaMuxContext *mkv = s->priv_data;
1886  AVIOContext *pb;
1887  if (s->pb->seekable)
1888  pb = s->pb;
1889  else
1890  pb = mkv->dyn_bc;
1891  if (!pkt) {
1892  if (mkv->cluster_pos != -1) {
1893  av_log(s, AV_LOG_DEBUG,
1894  "Flushing cluster at offset %" PRIu64 " bytes\n",
1895  avio_tell(pb));
1896  end_ebml_master(pb, mkv->cluster);
1897  mkv->cluster_pos = -1;
1898  if (mkv->dyn_bc)
1899  mkv_flush_dynbuf(s);
1900  avio_flush(s->pb);
1901  }
1902  return 1;
1903  }
1904  return mkv_write_packet(s, pkt);
1905 }
1906 
1908 {
1909  MatroskaMuxContext *mkv = s->priv_data;
1910  AVIOContext *pb = s->pb;
1911  int64_t currentpos, cuespos;
1912  int ret;
1913 
1914  // check if we have an audio packet cached
1915  if (mkv->cur_audio_pkt.size > 0) {
1916  ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt, 0);
1918  if (ret < 0) {
1919  av_log(s, AV_LOG_ERROR,
1920  "Could not write cached audio packet ret:%d\n", ret);
1921  return ret;
1922  }
1923  }
1924 
1925  if (mkv->dyn_bc) {
1926  end_ebml_master(mkv->dyn_bc, mkv->cluster);
1927  mkv_flush_dynbuf(s);
1928  } else if (mkv->cluster_pos != -1) {
1929  end_ebml_master(pb, mkv->cluster);
1930  }
1931 
1932  if (mkv->mode != MODE_WEBM) {
1933  ret = mkv_write_chapters(s);
1934  if (ret < 0)
1935  return ret;
1936  }
1937 
1938  if (pb->seekable) {
1939  if (mkv->cues->num_entries) {
1940  if (mkv->reserve_cues_space) {
1941  int64_t cues_end;
1942 
1943  currentpos = avio_tell(pb);
1944  avio_seek(pb, mkv->cues_pos, SEEK_SET);
1945 
1946  cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
1947  cues_end = avio_tell(pb);
1948  if (cues_end > cuespos + mkv->reserve_cues_space) {
1949  av_log(s, AV_LOG_ERROR,
1950  "Insufficient space reserved for cues: %d "
1951  "(needed: %" PRId64 ").\n",
1952  mkv->reserve_cues_space, cues_end - cuespos);
1953  return AVERROR(EINVAL);
1954  }
1955 
1956  if (cues_end < cuespos + mkv->reserve_cues_space)
1958  (cues_end - cuespos));
1959 
1960  avio_seek(pb, currentpos, SEEK_SET);
1961  } else {
1962  cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
1963  }
1964 
1966  cuespos);
1967  if (ret < 0)
1968  return ret;
1969  }
1970 
1972 
1973  // update the duration
1974  av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration);
1975  currentpos = avio_tell(pb);
1976  avio_seek(pb, mkv->duration_offset, SEEK_SET);
1978 
1979  avio_seek(pb, currentpos, SEEK_SET);
1980  }
1981 
1982  if (!mkv->is_live) {
1983  end_ebml_master(pb, mkv->segment);
1984  }
1985  av_freep(&mkv->tracks);
1986  av_freep(&mkv->cues->entries);
1987  av_freep(&mkv->cues);
1988 
1989  return 0;
1990 }
1991 
1992 static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
1993 {
1994  int i;
1995  for (i = 0; ff_mkv_codec_tags[i].id != AV_CODEC_ID_NONE; i++)
1996  if (ff_mkv_codec_tags[i].id == codec_id)
1997  return 1;
1998 
1999  if (std_compliance < FF_COMPLIANCE_NORMAL) {
2000  enum AVMediaType type = avcodec_get_type(codec_id);
2001  // mkv theoretically supports any video/audio through VFW/ACM
2002  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO)
2003  return 1;
2004  }
2005 
2006  return 0;
2007 }
2008 
2010  { AV_CODEC_ID_ALAC, 0XFFFFFFFF },
2011  { AV_CODEC_ID_EAC3, 0XFFFFFFFF },
2012  { AV_CODEC_ID_MLP, 0xFFFFFFFF },
2013  { AV_CODEC_ID_OPUS, 0xFFFFFFFF },
2014  { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
2015  { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
2016  { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
2017  { AV_CODEC_ID_QDM2, 0xFFFFFFFF },
2018  { AV_CODEC_ID_RA_144, 0xFFFFFFFF },
2019  { AV_CODEC_ID_RA_288, 0xFFFFFFFF },
2020  { AV_CODEC_ID_COOK, 0xFFFFFFFF },
2021  { AV_CODEC_ID_TRUEHD, 0xFFFFFFFF },
2022  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2023 };
2024 
2026  { AV_CODEC_ID_RV10, 0xFFFFFFFF },
2027  { AV_CODEC_ID_RV20, 0xFFFFFFFF },
2028  { AV_CODEC_ID_RV30, 0xFFFFFFFF },
2029  { AV_CODEC_ID_RV40, 0xFFFFFFFF },
2030  { AV_CODEC_ID_VP9, 0xFFFFFFFF },
2031  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2032 };
2033 
2035  { AV_CODEC_ID_DVB_SUBTITLE, 0xFFFFFFFF },
2036  { AV_CODEC_ID_HDMV_PGS_SUBTITLE, 0xFFFFFFFF },
2037  { AV_CODEC_ID_NONE, 0xFFFFFFFF }
2038 };
2039 
2040 #define OFFSET(x) offsetof(MatroskaMuxContext, x)
2041 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
2042 static const AVOption options[] = {
2043  { "reserve_index_space", "Reserve a given amount of space (in bytes) at the beginning of the file for the index (cues).", OFFSET(reserve_cues_space), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
2044  { "cluster_size_limit", "Store at most the provided amount of bytes in a cluster. ", OFFSET(cluster_size_limit), AV_OPT_TYPE_INT , { .i64 = -1 }, -1, INT_MAX, FLAGS },
2045  { "cluster_time_limit", "Store at most the provided number of milliseconds in a cluster.", OFFSET(cluster_time_limit), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, FLAGS },
2046  { "dash", "Create a WebM file conforming to WebM DASH specification", OFFSET(is_dash), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
2047  { "dash_track_number", "Track number for the DASH stream", OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 127, FLAGS },
2048  { "live", "Write files assuming it is a live stream.", OFFSET(is_live), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
2049  { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
2050  { NULL },
2051 };
2052 
2053 #if CONFIG_MATROSKA_MUXER
2054 static const AVClass matroska_class = {
2055  .class_name = "matroska muxer",
2056  .item_name = av_default_item_name,
2057  .option = options,
2058  .version = LIBAVUTIL_VERSION_INT,
2059 };
2060 
2061 AVOutputFormat ff_matroska_muxer = {
2062  .name = "matroska",
2063  .long_name = NULL_IF_CONFIG_SMALL("Matroska"),
2064  .mime_type = "video/x-matroska",
2065  .extensions = "mkv",
2066  .priv_data_size = sizeof(MatroskaMuxContext),
2067  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2069  .video_codec = CONFIG_LIBX264_ENCODER ?
2076  .codec_tag = (const AVCodecTag* const []){
2079  },
2080  .subtitle_codec = AV_CODEC_ID_ASS,
2081  .query_codec = mkv_query_codec,
2082  .priv_class = &matroska_class,
2083 };
2084 #endif
2085 
2086 #if CONFIG_WEBM_MUXER
2087 static const AVClass webm_class = {
2088  .class_name = "webm muxer",
2089  .item_name = av_default_item_name,
2090  .option = options,
2091  .version = LIBAVUTIL_VERSION_INT,
2092 };
2093 
2094 AVOutputFormat ff_webm_muxer = {
2095  .name = "webm",
2096  .long_name = NULL_IF_CONFIG_SMALL("WebM"),
2097  .mime_type = "video/webm",
2098  .extensions = "webm",
2099  .priv_data_size = sizeof(MatroskaMuxContext),
2100  .audio_codec = AV_CODEC_ID_VORBIS,
2101  .video_codec = AV_CODEC_ID_VP8,
2102  .subtitle_codec = AV_CODEC_ID_WEBVTT,
2108  .priv_class = &webm_class,
2109 };
2110 #endif
2111 
2112 #if CONFIG_MATROSKA_AUDIO_MUXER
2113 static const AVClass mka_class = {
2114  .class_name = "matroska audio muxer",
2115  .item_name = av_default_item_name,
2116  .option = options,
2117  .version = LIBAVUTIL_VERSION_INT,
2118 };
2119 AVOutputFormat ff_matroska_audio_muxer = {
2120  .name = "matroska",
2121  .long_name = NULL_IF_CONFIG_SMALL("Matroska Audio"),
2122  .mime_type = "audio/x-matroska",
2123  .extensions = "mka",
2124  .priv_data_size = sizeof(MatroskaMuxContext),
2125  .audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2126  AV_CODEC_ID_VORBIS : AV_CODEC_ID_AC3,
2127  .video_codec = AV_CODEC_ID_NONE,
2133  .codec_tag = (const AVCodecTag* const []){
2135  },
2136  .priv_class = &mka_class,
2137 };
2138 #endif
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1471
static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt, int add_cue)
Definition: matroskaenc.c:1727
Definition: lfg.h:25
#define MATROSKA_ID_SEEKPREROLL
Definition: matroska.h:95
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:341
internal header for HEVC (de)muxer utilities
#define AV_DISPOSITION_METADATA
Definition: avformat.h:826
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:410
#define NULL
Definition: coverity.c:32
static int mkv_write_vtt_blocks(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
Definition: matroskaenc.c:1652
const char const char void * val
Definition: avisynth_c.h:634
#define MATROSKA_ID_BLOCKADDID
Definition: matroska.h:194
#define MATROSKA_ID_TRACKDEFAULTDURATION
Definition: matroska.h:104
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:416
static void put_ebml_size_unknown(AVIOContext *pb, int bytes)
Write an EBML size meaning "unknown size".
Definition: matroskaenc.c:169
const char * s
Definition: avisynth_c.h:631
Bytestream IO Context.
Definition: avio.h:111
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int mkv_check_tag(AVDictionary *m)
Definition: matroskaenc.c:1189
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
Views are packed per line, as if interlaced.
Definition: stereo3d.h:97
#define MATROSKA_ID_DATEUTC
Definition: matroska.h:71
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:280
int sizebytes
how many bytes were reserved for the size
Definition: matroskaenc.c:57
#define MAX_TRACKS
Maximum number of tracks allowed in a Matroska file (with track numbers in range 1 to 126 (inclusive)...
Definition: matroskaenc.c:100
The optional first identifier line of a WebVTT cue.
Definition: avcodec.h:1095
uint32_t samples
Definition: wv.h:39
int initial
Definition: wv.h:43
void av_sha_update(AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha.c:314
#define MATROSKA_ID_TRACKFLAGLACING
Definition: matroska.h:101
#define MATROSKA_ID_TRACKENTRY
Definition: matroska.h:75
#define MATROSKA_ID_VIDEODISPLAYHEIGHT
Definition: matroska.h:113
static void mkv_start_new_cluster(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:1705
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1125
AVOption.
Definition: opt.h:255
hash context
Definition: sha.c:34
int64_t cluster_pos
file offset of the cluster containing the block
Definition: matroskaenc.c:78
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
Views are alternated temporally.
Definition: stereo3d.h:66
enum AVCodecID id
Definition: mxfenc.c:99
#define MATROSKA_ID_CUETRACKPOSITION
Definition: matroska.h:156
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:2713
#define MATROSKA_ID_CODECPRIVATE
Definition: matroska.h:89
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
Definition: sha.c:273
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:62
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4006
#define MATROSKA_ID_AUDIOBITDEPTH
Definition: matroska.h:131
#define MATROSKA_ID_TRACKFLAGDEFAULT
Definition: matroska.h:99
static const AVCodecTag additional_subtitle_tags[]
Definition: matroskaenc.c:2034
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition: avcodec.h:1038
static int mkv_write_attachments(AVFormatContext *s)
Definition: matroskaenc.c:1238
uint64_t pts
Definition: matroskaenc.c:75
int size
Definition: avcodec.h:1163
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:203
#define MATROSKA_ID_FILEDATA
Definition: matroska.h:210
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1695
#define EBML_ID_DOCTYPEREADVERSION
Definition: matroska.h:42
#define MATROSKA_ID_BLOCKREFERENCE
Definition: matroska.h:201
static int mkv_write_header(AVFormatContext *s)
Definition: matroskaenc.c:1322
#define MATROSKA_ID_TRACKTYPE
Definition: matroska.h:80
enum AVMediaType codec_type
Definition: rtp.c:37
#define MATROSKA_ID_TAGTARGETS_CHAPTERUID
Definition: matroska.h:177
int ff_flac_is_native_layout(uint64_t channel_layout)
int64_t duration
duration of the block according to time base
Definition: matroskaenc.c:80
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:66
#define MATROSKA_ID_MUXINGAPP
Definition: matroska.h:70
int64_t cluster_time_limit
Definition: matroskaenc.c:124
#define MATROSKA_ID_AUDIOCHANNELS
Definition: matroska.h:132
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:2703
int64_t segment_offset
Definition: matroskaenc.c:84
int version
Definition: avisynth_c.h:629
uint64_t_TMPL AV_RL64
Definition: bytestream.h:85
int avoid_negative_ts_use_pts
Definition: internal.h:101
const char * master
Definition: vf_curves.c:110
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:954
static AVPacket pkt
#define av_le2ne32(x)
Definition: bswap.h:96
#define MATROSKA_ID_CUECLUSTERPOSITION
Definition: matroska.h:160
Definition: matroskaenc.c:60
AVDictionary * metadata
Definition: avformat.h:1239
int av_dup_packet(AVPacket *pkt)
Definition: avpacket.c:248
mkv_track * tracks
Definition: matroskaenc.c:115
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:481
#define MATROSKA_ID_EDITIONFLAGDEFAULT
Definition: matroska.h:223
#define MATROSKA_ID_CLUSTERTIMECODE
Definition: matroska.h:188
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1113
#define EBML_ID_DOCTYPE
Definition: matroska.h:40
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:483
#define MATROSKA_ID_CHAPTERTIMEEND
Definition: matroska.h:217
int64_t pos
absolute offset in the file where the master's elements start
Definition: matroskaenc.c:56
MatroskaVideoStereoModeType
Definition: matroska.h:248
int ff_vorbiscomment_write(uint8_t **p, AVDictionary **m, const char *vendor_string)
Write a VorbisComment into a buffer.
Definition: vorbiscomment.c:54
#define FLAGS
Definition: matroskaenc.c:2041
#define MATROSKA_ID_FILEDESC
Definition: matroska.h:207
Format I/O context.
Definition: avformat.h:1272
UID uid
Definition: mxfenc.c:1802
char str[32]
Definition: internal.h:46
int64_t cluster_pos
file offset of the current cluster
Definition: matroskaenc.c:109
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static const AVCodecTag additional_audio_tags[]
Definition: matroskaenc.c:2009
Public dictionary API.
static int mkv_write_native_codecprivate(AVFormatContext *s, AVCodecContext *codec, AVIOContext *dyn_cp)
Definition: matroskaenc.c:602
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:103
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:318
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1993
uint8_t
#define MATROSKA_ID_CHAPLANG
Definition: matroska.h:220
#define av_malloc(s)
static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, unsigned int elementid, unsigned int uid, ebml_master *tags)
Definition: matroskaenc.c:1154
mode
Definition: f_perms.c:27
AVOptions.
#define MATROSKA_ID_TRACKLANGUAGE
Definition: matroska.h:97
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:123
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom.c:71
static int ebml_id_size(unsigned int id)
Definition: matroskaenc.c:152
#define OPUS_SEEK_PREROLL
Seek preroll value for opus.
Definition: matroskaenc.c:150
uint32_t flags
Definition: wv.h:40
int ff_mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
Definition: matroska.c:151
uint64_t segmentpos
Definition: matroskaenc.c:62
int id
unique ID to identify the chapter
Definition: avformat.h:1236
#define MATROSKA_ID_TIMECODESCALE
Definition: matroska.h:66
#define MATROSKA_ID_SIMPLEBLOCK
Definition: matroska.h:196
#define MATROSKA_ID_EDITIONFLAGHIDDEN
Definition: matroska.h:222
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:958
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1355
#define MATROSKA_ID_BLOCKMORE
Definition: matroska.h:193
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:85
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1340
#define MATROSKA_ID_CUERELATIVEPOSITION
Definition: matroska.h:161
#define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ
Definition: matroska.h:129
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:39
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1383
uint8_t * data
Definition: avcodec.h:1162
static int64_t mkv_write_cues(AVFormatContext *s, mkv_cues *cues, mkv_track *tracks, int num_tracks)
Definition: matroskaenc.c:444
#define MATROSKA_ID_VIDEODISPLAYWIDTH
Definition: matroska.h:112
#define MATROSKA_ID_BLOCKADDITIONS
Definition: matroska.h:192
uint32_t tag
Definition: movenc.c:1333
#define WV_HEADER_SIZE
Definition: wavpack.h:30
enum AVCodecID id
Definition: internal.h:47
static int put_flac_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecContext *codec)
Definition: matroskaenc.c:538
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
uint8_t * data
Definition: avcodec.h:1112
#define MATROSKA_ID_CUES
Definition: matroska.h:58
int64_t ts_offset
Definition: matroskaenc.c:92
ptrdiff_t size
Definition: opengl_enc.c:101
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:365
static const uint8_t header[24]
Definition: sdr2.c:67
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2720
#define MATROSKA_ID_TRACKNUMBER
Definition: matroska.h:78
static int64_t duration
Definition: ffplay.c:321
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:177
static int get_aac_sample_rates(AVFormatContext *s, AVCodecContext *codec, int *sample_rate, int *output_sample_rate)
Definition: matroskaenc.c:585
Definition: wv.h:34
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1400
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1180
#define MATROSKA_ID_SEGMENTUID
Definition: matroska.h:72
static void put_ebml_num(AVIOContext *pb, uint64_t num, int bytes)
Write a number in EBML variable length format.
Definition: matroskaenc.c:193
#define av_log(a,...)
int has_cue
Definition: matroskaenc.c:91
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:824
unsigned m
Definition: audioconvert.c:187
static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos)
Definition: matroskaenc.c:339
int64_t segment_offset
the file offset to the beginning of the segment
Definition: matroskaenc.c:67
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1291
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1208
#define MATROSKA_ID_TRACKUID
Definition: matroska.h:79
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:140
ebml_master segment
Definition: matroskaenc.c:106
static int mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t)
Definition: matroskaenc.c:1120
#define MATROSKA_ID_VIDEOSTEREOMODE
Definition: matroska.h:122
uint32_t chapter_id_offset
Definition: matroskaenc.c:129
AVPacket cur_audio_pkt
Definition: matroskaenc.c:117
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:102
static int mkv_write_tags(AVFormatContext *s)
Definition: matroskaenc.c:1200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:3318
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1482
int flags
Additional information about the frame packing.
Definition: stereo3d.h:132
#define MATROSKA_ID_BLOCKDURATION
Definition: matroska.h:200
#define EBML_ID_EBMLREADVERSION
Definition: matroska.h:37
#define MAX_CUETRACKPOS_SIZE
per-cuepoint-track - 5 1-byte EBML IDs, 5 1-byte EBML sizes, 4 8-byte uint max
Definition: matroskaenc.c:144
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
unsigned int elementid
Definition: matroskaenc.c:61
int reserved_size
-1 if appending to file
Definition: matroskaenc.c:68
#define MATROSKA_ID_CLUSTER
Definition: matroska.h:62
const char * av_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition: avlanguage.c:736
static int put_xiph_codecpriv(AVFormatContext *s, AVIOContext *pb, AVCodecContext *codec)
Definition: matroskaenc.c:501
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
#define MATROSKA_ID_FILEMIMETYPE
Definition: matroska.h:209
int64_t convergence_duration
Time difference in AVStream->time_base units from the pts of this packet to the point at which the ou...
Definition: avcodec.h:1206
#define MATROSKA_ID_WRITINGAPP
Definition: matroska.h:69
int initial_padding
Audio only.
Definition: avcodec.h:3015
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2546
const char *const ff_matroska_video_stereo_mode[MATROSKA_VIDEO_STEREOMODE_TYPE_NB]
Definition: matroska.c:127
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:199
static int mkv_blockgroup_size(int pkt_size)
Definition: matroskaenc.c:1489
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1145
static int ebml_num_size(uint64_t num)
Calculate how many bytes are needed to represent a given number in EBML.
Definition: matroskaenc.c:179
int write_dts
Definition: matroskaenc.c:90
int final
Definition: wv.h:43
AVChapter ** chapters
Definition: avformat.h:1472
enum AVCodecID id
Definition: matroska.h:273
enum AVPacketSideDataType type
Definition: avcodec.h:1114
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: utils.c:3759
static int mkv_write_chapters(AVFormatContext *s)
Definition: matroskaenc.c:1068
int side_data_elems
Definition: avcodec.h:1174
#define EBML_ID_EBMLMAXIDLENGTH
Definition: matroska.h:38
int64_t ff_vorbiscomment_length(AVDictionary *m, const char *vendor_string)
Calculate the length in bytes of a VorbisComment.
Definition: vorbiscomment.c:41
#define MATROSKA_ID_CHAPTERFLAGHIDDEN
Definition: matroska.h:226
enum AVCodecID codec_id
Definition: mov_chan.c:433
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:35
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
uint32_t crc
Definition: wv.h:41
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:376
#define FFMAX(a, b)
Definition: common.h:64
static mkv_seekhead * mkv_start_seekhead(AVIOContext *pb, int64_t segment_offset, int numelements)
Initialize a mkv_seekhead element to be ready to index level 1 Matroska elements. ...
Definition: matroskaenc.c:318
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:92
int64_t filepos
Definition: matroskaenc.c:66
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1168
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2046
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:861
const CodecMime ff_mkv_mime_tags[]
Definition: matroska.c:111
#define MATROSKA_ID_TAG
Definition: matroska.h:166
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:809
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1328
#define LIBAVFORMAT_IDENT
Definition: version.h:44
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:160
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:197
audio channel layout utility functions
#define EBML_ID_EBMLVERSION
Definition: matroska.h:36
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:127
mkv_cuepoint * entries
Definition: matroskaenc.c:85
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:163
#define MATROSKA_ID_TAGTARGETS
Definition: matroska.h:173
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
#define MATROSKA_ID_TAGNAME
Definition: matroska.h:168
ret
Definition: avfilter.c:974
#define MATROSKA_ID_CHAPTERFLAGENABLED
Definition: matroska.h:227
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
int64_t ff_iso8601_to_unix_time(const char *datestr)
Convert a date string in ISO8601 format to Unix timestamp.
Definition: utils.c:4094
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:471
int ff_wv_parse_header(WvHeader *wv, const uint8_t *data)
Parse a WavPack block header.
Definition: wv.c:29
int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to a data buffer.
Definition: hevc.c:1073
#define MATROSKA_ID_SIMPLETAG
Definition: matroska.h:167
const char * name
Definition: avformat.h:513
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:114
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
int ff_flac_write_header(AVIOContext *pb, uint8_t *extradata, int extradata_size, int last_block)
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1573
#define MATROSKA_ID_CHAPTERATOM
Definition: matroska.h:215
int avpriv_split_xiph_headers(const uint8_t *extradata, int extradata_size, int first_header_size, const uint8_t *header_start[3], int header_len[3])
Split a single extradata buffer into the three headers that most Xiph codecs use. ...
Definition: xiph.c:24
AVDictionary * metadata
Definition: avformat.h:916
Opaque data information usually sparse.
Definition: avutil.h:198
#define MATROSKA_ID_VIDEOCOLORSPACE
Definition: matroska.h:125
#define MATROSKA_ID_CHAPTERS
Definition: matroska.h:63
#define EBML_ID_VOID
Definition: matroska.h:45
#define OFFSET(x)
Definition: matroskaenc.c:2040
#define MATROSKA_ID_AUDIOSAMPLINGFREQ
Definition: matroska.h:128
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:2970
static int mkv_add_cuepoint(mkv_cues *cues, int stream, int tracknum, int64_t ts, int64_t cluster_pos, int64_t relative_pos, int64_t duration)
Definition: matroskaenc.c:421
static void put_ebml_float(AVIOContext *pb, unsigned int elementid, double val)
Definition: matroskaenc.c:238
Stream structure.
Definition: avformat.h:842
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static void put_ebml_string(AVIOContext *pb, unsigned int elementid, const char *str)
Definition: matroskaenc.c:253
int64_t end
chapter start/end time in time_base units
Definition: avformat.h:1238
static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv, int i, AVIOContext *pb, int default_stream_exists)
Definition: matroskaenc.c:810
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:797
sample_rate
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:127
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:825
AVS_Value src
Definition: avisynth_c.h:482
#define MATROSKA_ID_TRACKFLAGFORCED
Definition: matroska.h:100
#define MATROSKA_ID_TAGS
Definition: matroska.h:59
enum AVMediaType codec_type
Definition: avcodec.h:1249
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:85
enum AVCodecID codec_id
Definition: avcodec.h:1258
#define MATROSKA_ID_SEEKID
Definition: matroska.h:184
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:265
int sample_rate
samples per second
Definition: avcodec.h:1985
AVIOContext * pb
I/O context.
Definition: avformat.h:1314
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:155
main external API structure.
Definition: avcodec.h:1241
#define MATROSKA_ID_BLOCK
Definition: matroska.h:199
#define MATROSKA_ID_INFO
Definition: matroska.h:56
#define MATROSKA_ID_TAGTARGETS_TRACKUID
Definition: matroska.h:176
static const EbmlSyntax ebml_header[]
Definition: matroskadec.c:327
#define MATROSKA_ID_TAGLANG
Definition: matroska.h:170
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1273
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
Definition: sha.c:45
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
#define MATROSKA_ID_TRACKS
Definition: matroska.h:57
void * buf
Definition: avisynth_c.h:553
Data found in BlockAdditional element of matroska container.
Definition: avcodec.h:1090
GLint GLenum type
Definition: opengl_enc.c:105
int extradata_size
Definition: avcodec.h:1356
#define MATROSKA_ID_TRACKNAME
Definition: matroska.h:96
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:69
#define MATROSKA_ID_SEEKENTRY
Definition: matroska.h:181
Describe the class of an AVClass context structure.
Definition: log.h:67
#define MATROSKA_ID_EDITIONENTRY
Definition: matroska.h:214
#define MAX_CUEPOINT_SIZE(num_tracks)
per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max
Definition: matroskaenc.c:147
#define MATROSKA_ID_BLOCKGROUP
Definition: matroska.h:191
#define MATROSKA_ID_VIDEOPIXELHEIGHT
Definition: matroska.h:115
static int mkv_write_tracks(AVFormatContext *s)
Definition: matroskaenc.c:1043
rational number numerator/denominator
Definition: rational.h:43
static void put_ebml_uint(AVIOContext *pb, unsigned int elementid, uint64_t val)
Definition: matroskaenc.c:212
#define MATROSKA_ID_CUEDURATION
Definition: matroska.h:162
void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc, const AVCodecTag *tags, int for_asf, int ignore_extradata)
Definition: riffenc.c:205
#define MATROSKA_ID_CUETIME
Definition: matroska.h:155
static int64_t mkv_write_seekhead(AVIOContext *pb, mkv_seekhead *seekhead)
Write the seek head to the file and free it.
Definition: matroskaenc.c:367
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1055
AVIOContext * dyn_bc
Definition: matroskaenc.c:105
AVMediaType
Definition: avutil.h:192
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
int64_t duration_offset
Definition: matroskaenc.c:111
#define MATROSKA_ID_TITLE
Definition: matroska.h:68
#define snprintf
Definition: snprintf.h:34
#define MATROSKA_ID_TRACKVIDEO
Definition: matroska.h:81
static int mkv_strip_wavpack(const uint8_t *src, uint8_t **pdst, int *size)
Definition: matroskaenc.c:1500
static void put_ebml_id(AVIOContext *pb, unsigned int id)
Definition: matroskaenc.c:157
static void put_ebml_sint(AVIOContext *pb, unsigned int elementid, int64_t val)
Definition: matroskaenc.c:225
static int put_wv_codecpriv(AVIOContext *pb, AVCodecContext *codec)
Definition: matroskaenc.c:529
Views are on top of each other.
Definition: stereo3d.h:55
#define MATROSKA_ID_ATTACHMENTS
Definition: matroska.h:61
static int64_t pts
Global timestamp for the audio frames.
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:422
#define MATROSKA_ID_CHAPTERDISPLAY
Definition: matroska.h:218
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:133
static int flags
Definition: cpu.c:47
#define MATROSKA_ID_FILENAME
Definition: matroska.h:208
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
#define MATROSKA_ID_BLOCKADDITIONAL
Definition: matroska.h:195
const AVMetadataConv ff_mkv_metadata_conv[]
Definition: matroska.c:121
#define MATROSKA_ID_CODECID
Definition: matroska.h:88
static const AVCodecTag additional_video_tags[]
Definition: matroskaenc.c:2025
int64_t start
Definition: avformat.h:1238
Views are next to each other.
Definition: stereo3d.h:45
#define MATROSKA_ID_VIDEOALPHAMODE
Definition: matroska.h:123
static int mkv_write_trailer(AVFormatContext *s)
Definition: matroskaenc.c:1907
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:85
Main libavformat public API header.
#define MATROSKA_ID_CUETRACK
Definition: matroska.h:159
#define MATROSKA_ID_SEEKPOSITION
Definition: matroska.h:185
int64_t last_track_timestamp[MAX_TRACKS]
Definition: matroskaenc.c:132
#define MATROSKA_ID_CODECDELAY
Definition: matroska.h:94
#define MATROSKA_ID_CHAPTERTIMESTART
Definition: matroska.h:216
common internal api header.
static void put_ebml_binary(AVIOContext *pb, unsigned int elementid, const void *buf, int size)
Definition: matroskaenc.c:245
static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb, AVCodecContext *codec, int native_id, int qt_id)
Definition: matroskaenc.c:642
static double c[64]
static void mkv_write_block(AVFormatContext *s, AVIOContext *pb, unsigned int blockid, AVPacket *pkt, int keyframe)
Definition: matroskaenc.c:1553
static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:1883
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:905
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
static void put_ebml_void(AVIOContext *pb, uint64_t size)
Write a void element of a given size.
Definition: matroskaenc.c:265
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1237
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:206
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:49
char * key
Definition: dict.h:87
#define MATROSKA_ID_SEGMENT
Definition: matroska.h:53
int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int bit_size, int sync_extension)
Parse MPEG-4 systems extradata to retrieve audio configuration.
Definition: mpeg4audio.c:81
The optional settings (rendering instructions) that immediately follow the timestamp specifier of a W...
Definition: avcodec.h:1101
#define MATROSKA_ID_SEEKHEAD
Definition: matroska.h:60
ASS as defined in Matroska.
Definition: avcodec.h:527
#define EBML_ID_HEADER
Definition: matroska.h:33
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:475
ebml_master cluster
Definition: matroskaenc.c:108
#define av_free(p)
char * value
Definition: dict.h:88
#define MATROSKA_ID_POINTENTRY
Definition: matroska.h:152
mkv_seekhead_entry * entries
Definition: matroskaenc.c:70
int len
#define av_log2
Definition: intmath.h:105
static int mkv_write_stereo_mode(AVFormatContext *s, AVIOContext *pb, AVStream *st, int mode, int *h_width, int *h_height)
Definition: matroskaenc.c:712
#define MATROSKA_ID_FILEUID
Definition: matroska.h:211
int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc, int flags)
Write WAVEFORMAT header structure.
Definition: riffenc.c:54
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:76
void * priv_data
Format private data.
Definition: avformat.h:1300
#define MATROSKA_ID_CHAPTERUID
Definition: matroska.h:225
Views are packed per column.
Definition: stereo3d.h:107
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:493
int64_t relative_pos
relative offset from the position of the cluster containing the block
Definition: matroskaenc.c:79
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1161
static void mkv_flush_dynbuf(AVFormatContext *s)
Definition: matroskaenc.c:1690
static const AVOption options[]
Definition: matroskaenc.c:2042
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:228
#define EBML_ID_EBMLMAXSIZELENGTH
Definition: matroska.h:39
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:326
#define MATROSKA_ID_CHAPSTRING
Definition: matroska.h:219
#define av_freep(p)
#define MATROSKA_ID_TAGSTRING
Definition: matroska.h:169
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:72
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:324
#define MODE_MATROSKAv2
Definition: matroskaenc.c:95
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:109
int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes HEVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext...
Definition: hevc.c:1089
const CodecMime ff_mkv_image_mime_tags[]
Definition: matroska.c:102
#define MODE_WEBM
Definition: matroskaenc.c:96
static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: matroskaenc.c:1805
#define MATROSKA_ID_DURATION
Definition: matroska.h:67
#define MAX_SEEKENTRY_SIZE
2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit offset, 4 bytes for target EBML I...
Definition: matroskaenc.c:140
static mkv_cues * mkv_start_cues(int64_t segment_offset)
Definition: matroskaenc.c:411
int stream_index
Definition: avcodec.h:1164
int num_entries
Definition: matroskaenc.c:86
#define EBML_ID_DOCTYPEVERSION
Definition: matroska.h:41
static void end_ebml_master(AVIOContext *pb, ebml_master master)
Definition: matroskaenc.c:291
int64_t segment_offset
Definition: matroskaenc.c:107
int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src)
Copy packet side data.
Definition: avpacket.c:223
#define MATROSKA_ID_ATTACHEDFILE
Definition: matroska.h:206
static ebml_master start_ebml_master(AVIOContext *pb, unsigned int elementid, uint64_t expectedsize)
Definition: matroskaenc.c:282
mkv_seekhead * main_seekhead
Definition: matroskaenc.c:113
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:85
This structure stores compressed data.
Definition: avcodec.h:1139
static int write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: v4l2enc.c:86
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:250
uint32_t blocksize
Definition: wv.h:35
static int mkv_query_codec(enum AVCodecID codec_id, int std_compliance)
Definition: matroskaenc.c:1992
static void put_xiph_size(AVIOContext *pb, int size)
Definition: matroskaenc.c:301
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1155
#define MATROSKA_ID_VIDEOPIXELWIDTH
Definition: matroska.h:114
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:106
#define MATROSKA_ID_TRACKAUDIO
Definition: matroska.h:82
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:241
const CodecTags ff_mkv_codec_tags[]
Definition: matroska.c:29
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
#define MATROSKA_ID_DISCARDPADDING
Definition: matroska.h:203
#define FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX
Tell ff_put_wav_header() to use WAVEFORMATEX even for PCM codecs.
Definition: riff.h:53